]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_gdi_wrap.cpp
projects / wxWidgets.git / blob
? search:


b3927dbdceaaaee666ffc906ef61d57fb70aa63a
[wxWidgets.git] / wxPython / src / mac / _gdi_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxPostScriptDC swig_types[0]
1342 #define SWIGTYPE_p_wxBrush swig_types[1]
1343 #define SWIGTYPE_p_wxColour swig_types[2]
1344 #define SWIGTYPE_p_wxDC swig_types[3]
1345 #define SWIGTYPE_p_wxMirrorDC swig_types[4]
1346 #define SWIGTYPE_p_form_ops_t swig_types[5]
1347 #define SWIGTYPE_p_wxDuplexMode swig_types[6]
1348 #define SWIGTYPE_p_wxPyFontEnumerator swig_types[7]
1349 #define SWIGTYPE_p_char swig_types[8]
1350 #define SWIGTYPE_p_wxIconLocation swig_types[9]
1351 #define SWIGTYPE_p_wxImage swig_types[10]
1352 #define SWIGTYPE_p_wxMetaFileDC swig_types[11]
1353 #define SWIGTYPE_p_wxMask swig_types[12]
1354 #define SWIGTYPE_p_wxSize swig_types[13]
1355 #define SWIGTYPE_p_wxFont swig_types[14]
1356 #define SWIGTYPE_p_wxWindow swig_types[15]
1357 #define SWIGTYPE_p_double swig_types[16]
1358 #define SWIGTYPE_p_wxMemoryDC swig_types[17]
1359 #define SWIGTYPE_p_wxFontMapper swig_types[18]
1360 #define SWIGTYPE_p_wxEffects swig_types[19]
1361 #define SWIGTYPE_p_wxNativeEncodingInfo swig_types[20]
1362 #define SWIGTYPE_p_wxPalette swig_types[21]
1363 #define SWIGTYPE_p_wxBitmap swig_types[22]
1364 #define SWIGTYPE_p_wxObject swig_types[23]
1365 #define SWIGTYPE_p_wxRegionIterator swig_types[24]
1366 #define SWIGTYPE_p_wxRect swig_types[25]
1367 #define SWIGTYPE_p_wxPaperSize swig_types[26]
1368 #define SWIGTYPE_p_wxString swig_types[27]
1369 #define SWIGTYPE_unsigned_int swig_types[28]
1370 #define SWIGTYPE_p_unsigned_int swig_types[29]
1371 #define SWIGTYPE_p_wxPrinterDC swig_types[30]
1372 #define SWIGTYPE_p_wxIconBundle swig_types[31]
1373 #define SWIGTYPE_p_wxPoint swig_types[32]
1374 #define SWIGTYPE_p_wxDash swig_types[33]
1375 #define SWIGTYPE_p_wxScreenDC swig_types[34]
1376 #define SWIGTYPE_p_wxCursor swig_types[35]
1377 #define SWIGTYPE_p_wxClientDC swig_types[36]
1378 #define SWIGTYPE_p_wxBufferedDC swig_types[37]
1379 #define SWIGTYPE_p_wxImageList swig_types[38]
1380 #define SWIGTYPE_p_unsigned_char swig_types[39]
1381 #define SWIGTYPE_p_wxGDIObject swig_types[40]
1382 #define SWIGTYPE_p_wxIcon swig_types[41]
1383 #define SWIGTYPE_p_wxLocale swig_types[42]
1384 #define SWIGTYPE_ptrdiff_t swig_types[43]
1385 #define SWIGTYPE_std__ptrdiff_t swig_types[44]
1386 #define SWIGTYPE_p_wxRegion swig_types[45]
1387 #define SWIGTYPE_p_wxConfigBase swig_types[46]
1388 #define SWIGTYPE_p_wxLanguageInfo swig_types[47]
1389 #define SWIGTYPE_p_wxWindowDC swig_types[48]
1390 #define SWIGTYPE_p_wxPrintData swig_types[49]
1391 #define SWIGTYPE_p_wxBrushList swig_types[50]
1392 #define SWIGTYPE_p_wxFontList swig_types[51]
1393 #define SWIGTYPE_p_wxPen swig_types[52]
1394 #define SWIGTYPE_p_wxBufferedPaintDC swig_types[53]
1395 #define SWIGTYPE_p_wxPaintDC swig_types[54]
1396 #define SWIGTYPE_p_wxPenList swig_types[55]
1397 #define SWIGTYPE_p_int swig_types[56]
1398 #define SWIGTYPE_p_wxMetaFile swig_types[57]
1399 #define SWIGTYPE_p_unsigned_long swig_types[58]
1400 #define SWIGTYPE_p_wxNativeFontInfo swig_types[59]
1401 #define SWIGTYPE_p_wxEncodingConverter swig_types[60]
1402 #define SWIGTYPE_p_wxColourDatabase swig_types[61]
1403 static swig_type_info *swig_types[63];
1404
1405 /* -------- TYPES TABLE (END) -------- */
1406
1407
1408 /*-----------------------------------------------
1409 @(target):= _gdi_.so
1410 ------------------------------------------------*/
1411 #define SWIG_init init_gdi_
1412
1413 #define SWIG_name "_gdi_"
1414
1415 #include "wx/wxPython/wxPython.h"
1416 #include "wx/wxPython/pyclasses.h"
1417
1418
1419 static const wxString wxPyEmptyString(wxEmptyString);
1420
1421 #include <limits.h>
1422
1423
1424 SWIGINTERN int
1425 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1426 const char *errmsg)
1427 {
1428 if (value < min_value) {
1429 if (errmsg) {
1430 PyErr_Format(PyExc_OverflowError,
1431 "value %ld is less than '%s' minimum %ld",
1432 value, errmsg, min_value);
1433 }
1434 return 0;
1435 } else if (value > max_value) {
1436 if (errmsg) {
1437 PyErr_Format(PyExc_OverflowError,
1438 "value %ld is greater than '%s' maximum %ld",
1439 value, errmsg, max_value);
1440 }
1441 return 0;
1442 }
1443 return 1;
1444 }
1445
1446
1447 SWIGINTERN int
1448 SWIG_AsVal_long(PyObject* obj, long* val)
1449 {
1450 if (PyNumber_Check(obj)) {
1451 if (val) *val = PyInt_AsLong(obj);
1452 return 1;
1453 }
1454 else {
1455 SWIG_type_error("number", obj);
1456 }
1457 return 0;
1458 }
1459
1460
1461 #if INT_MAX != LONG_MAX
1462 SWIGINTERN int
1463 SWIG_AsVal_int(PyObject *obj, int *val)
1464 {
1465 const char* errmsg = val ? "int" : (char*)0;
1466 long v;
1467 if (SWIG_AsVal_long(obj, &v)) {
1468 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1469 if (val) *val = (int)(v);
1470 return 1;
1471 } else {
1472 return 0;
1473 }
1474 } else {
1475 PyErr_Clear();
1476 }
1477 if (val) {
1478 SWIG_type_error(errmsg, obj);
1479 }
1480 return 0;
1481 }
1482 #else
1483 SWIGINTERNSHORT int
1484 SWIG_AsVal_int(PyObject *obj, int *val)
1485 {
1486 return SWIG_AsVal_long(obj,(long*)val);
1487 }
1488 #endif
1489
1490
1491 SWIGINTERN int
1492 SWIG_AsVal_bool(PyObject *obj, bool *val)
1493 {
1494 if (obj == Py_True) {
1495 if (val) *val = true;
1496 return 1;
1497 }
1498 if (obj == Py_False) {
1499 if (val) *val = false;
1500 return 1;
1501 }
1502 int res = 0;
1503 if (SWIG_AsVal_int(obj, &res)) {
1504 if (val) *val = res ? true : false;
1505 return 1;
1506 } else {
1507 PyErr_Clear();
1508 }
1509 if (val) {
1510 SWIG_type_error("bool", obj);
1511 }
1512 return 0;
1513 }
1514
1515
1516 SWIGINTERNSHORT bool
1517 SWIG_As_bool(PyObject* obj)
1518 {
1519 bool v;
1520 if (!SWIG_AsVal_bool(obj, &v)) {
1521 /*
1522 this is needed to make valgrind/purify happier.
1523 */
1524 memset((void*)&v, 0, sizeof(bool));
1525 }
1526 return v;
1527 }
1528
1529
1530 SWIGINTERNSHORT int
1531 SWIG_Check_bool(PyObject* obj)
1532 {
1533 return SWIG_AsVal_bool(obj, (bool*)0);
1534 }
1535
1536
1537 SWIGINTERN int
1538 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1539 {
1540 long v = 0;
1541 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1542 SWIG_type_error("unsigned number", obj);
1543 }
1544 else if (val)
1545 *val = (unsigned long)v;
1546 return 1;
1547 }
1548
1549
1550 SWIGINTERNSHORT int
1551 SWIG_CheckUnsignedLongInRange(unsigned long value,
1552 unsigned long max_value,
1553 const char *errmsg)
1554 {
1555 if (value > max_value) {
1556 if (errmsg) {
1557 PyErr_Format(PyExc_OverflowError,
1558 "value %lu is greater than '%s' minimum %lu",
1559 value, errmsg, max_value);
1560 }
1561 return 0;
1562 }
1563 return 1;
1564 }
1565
1566
1567 SWIGINTERN int
1568 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
1569 {
1570 const char* errmsg = val ? "unsigned char" : (char*)0;
1571 unsigned long v;
1572 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1573 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
1574 if (val) *val = (unsigned char)(v);
1575 return 1;
1576 } else {
1577 return 0;
1578 }
1579 } else {
1580 PyErr_Clear();
1581 }
1582 if (val) {
1583 SWIG_type_error(errmsg, obj);
1584 }
1585 return 0;
1586 }
1587
1588
1589 SWIGINTERNSHORT unsigned char
1590 SWIG_As_unsigned_SS_char(PyObject* obj)
1591 {
1592 unsigned char v;
1593 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
1594 /*
1595 this is needed to make valgrind/purify happier.
1596 */
1597 memset((void*)&v, 0, sizeof(unsigned char));
1598 }
1599 return v;
1600 }
1601
1602
1603 SWIGINTERNSHORT int
1604 SWIG_Check_unsigned_SS_char(PyObject* obj)
1605 {
1606 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
1607 }
1608
1609
1610 SWIGINTERNSHORT unsigned long
1611 SWIG_As_unsigned_SS_long(PyObject* obj)
1612 {
1613 unsigned long v;
1614 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1615 /*
1616 this is needed to make valgrind/purify happier.
1617 */
1618 memset((void*)&v, 0, sizeof(unsigned long));
1619 }
1620 return v;
1621 }
1622
1623
1624 SWIGINTERNSHORT int
1625 SWIG_Check_unsigned_SS_long(PyObject* obj)
1626 {
1627 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1628 }
1629
1630
1631 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1632 #define SWIG_From_unsigned_SS_char PyInt_FromLong
1633 /*@@*/
1634
1635
1636 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1637 #define SWIG_From_long PyInt_FromLong
1638 /*@@*/
1639
1640 static PyObject *wxColour_Get(wxColour *self){
1641 PyObject* rv = PyTuple_New(3);
1642 int red = -1;
1643 int green = -1;
1644 int blue = -1;
1645 if (self->Ok()) {
1646 red = self->Red();
1647 green = self->Green();
1648 blue = self->Blue();
1649 }
1650 PyTuple_SetItem(rv, 0, PyInt_FromLong(red));
1651 PyTuple_SetItem(rv, 1, PyInt_FromLong(green));
1652 PyTuple_SetItem(rv, 2, PyInt_FromLong(blue));
1653 return rv;
1654 }
1655 static unsigned long wxColour_GetRGB(wxColour *self){
1656 return self->Red() | (self->Green() << 8) | (self->Blue() << 16);
1657 }
1658
1659 SWIGINTERNSHORT PyObject*
1660 SWIG_From_unsigned_SS_long(unsigned long value)
1661 {
1662 return (value > LONG_MAX) ?
1663 PyLong_FromUnsignedLong(value)
1664 : PyInt_FromLong((long)(value));
1665 }
1666
1667
1668 SWIGINTERNSHORT int
1669 SWIG_As_int(PyObject* obj)
1670 {
1671 int v;
1672 if (!SWIG_AsVal_int(obj, &v)) {
1673 /*
1674 this is needed to make valgrind/purify happier.
1675 */
1676 memset((void*)&v, 0, sizeof(int));
1677 }
1678 return v;
1679 }
1680
1681
1682 SWIGINTERNSHORT int
1683 SWIG_Check_int(PyObject* obj)
1684 {
1685 return SWIG_AsVal_int(obj, (int*)0);
1686 }
1687
1688
1689 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1690 #define SWIG_From_int PyInt_FromLong
1691 /*@@*/
1692
1693
1694 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1695 PyObject* o2;
1696 PyObject* o3;
1697
1698 if (!target) {
1699 target = o;
1700 } else if (target == Py_None) {
1701 Py_DECREF(Py_None);
1702 target = o;
1703 } else {
1704 if (!PyTuple_Check(target)) {
1705 o2 = target;
1706 target = PyTuple_New(1);
1707 PyTuple_SetItem(target, 0, o2);
1708 }
1709 o3 = PyTuple_New(1);
1710 PyTuple_SetItem(o3, 0, o);
1711
1712 o2 = target;
1713 target = PySequence_Concat(o2, o3);
1714 Py_DECREF(o2);
1715 Py_DECREF(o3);
1716 }
1717 return target;
1718 }
1719
1720
1721 static PyObject *wxPen_GetDashes(wxPen *self){
1722 wxDash* dashes;
1723 int count = self->GetDashes(&dashes);
1724 bool blocked = wxPyBeginBlockThreads();
1725 PyObject* retval = PyList_New(0);
1726 for (int x=0; x<count; x++) {
1727 PyObject* pyint = PyInt_FromLong(dashes[x]);
1728 PyList_Append(retval, pyint);
1729 Py_DECREF(pyint);
1730 }
1731 wxPyEndBlockThreads(blocked);
1732 return retval;
1733 }
1734 static void wxPen__SetDashes(wxPen *self,PyObject *_self,PyObject *pyDashes){
1735 bool blocked = wxPyBeginBlockThreads();
1736 int size = PyList_Size(pyDashes);
1737 wxDash* dashes = (wxDash*)byte_LIST_helper(pyDashes);
1738
1739 // black magic warning! The array of wxDashes needs to exist as
1740 // long as the pen does because wxPen does not copy the array. So
1741 // stick a copy in a Python string object and attach it to _self,
1742 // and then call SetDashes with a pointer to that array. Then
1743 // when the Python pen object is destroyed the array will be
1744 // cleaned up too.
1745 PyObject* strDashes = PyString_FromStringAndSize((char*)dashes, size*sizeof(wxDash));
1746 PyObject_SetAttrString(_self, "_dashes", strDashes);
1747
1748 self->SetDashes(size, (wxDash*)PyString_AS_STRING(strDashes));
1749 delete [] dashes;
1750 Py_DECREF(strDashes);
1751 wxPyEndBlockThreads(blocked);
1752 }
1753 static bool wxPen___eq__(wxPen *self,wxPen const *other){ return other ? (*self == *other) : false; }
1754 static bool wxPen___ne__(wxPen *self,wxPen const *other){ return other ? (*self != *other) : true; }
1755
1756 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1757 #define SWIG_From_short PyInt_FromLong
1758 /*@@*/
1759
1760
1761 SWIGINTERN int
1762 SWIG_AsVal_short(PyObject *obj, short *val)
1763 {
1764 const char* errmsg = val ? "short" : (char*)0;
1765 long v;
1766 if (SWIG_AsVal_long(obj, &v)) {
1767 if (SWIG_CheckLongInRange(v, SHRT_MIN, SHRT_MAX, errmsg)) {
1768 if (val) *val = (short)(v);
1769 return 1;
1770 } else {
1771 return 0;
1772 }
1773 } else {
1774 PyErr_Clear();
1775 }
1776 if (val) {
1777 SWIG_type_error(errmsg, obj);
1778 }
1779 return 0;
1780 }
1781
1782
1783 SWIGINTERNSHORT short
1784 SWIG_As_short(PyObject* obj)
1785 {
1786 short v;
1787 if (!SWIG_AsVal_short(obj, &v)) {
1788 /*
1789 this is needed to make valgrind/purify happier.
1790 */
1791 memset((void*)&v, 0, sizeof(short));
1792 }
1793 return v;
1794 }
1795
1796
1797 SWIGINTERNSHORT int
1798 SWIG_Check_short(PyObject* obj)
1799 {
1800 return SWIG_AsVal_short(obj, (short*)0);
1801 }
1802
1803
1804 #include <wx/image.h>
1805
1806 static char** ConvertListOfStrings(PyObject* listOfStrings) {
1807 char** cArray = NULL;
1808 int count;
1809
1810 if (!PyList_Check(listOfStrings)) {
1811 PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
1812 return NULL;
1813 }
1814 count = PyList_Size(listOfStrings);
1815 cArray = new char*[count];
1816
1817 for(int x=0; x<count; x++) {
1818 // TODO: Need some validation and error checking here
1819 cArray[x] = PyString_AsString(PyList_GET_ITEM(listOfStrings, x));
1820 }
1821 return cArray;
1822 }
1823
1824
1825 static wxBitmap *new_wxBitmap(PyObject *listOfStrings){
1826 char** cArray = NULL;
1827 wxBitmap* bmp;
1828
1829 cArray = ConvertListOfStrings(listOfStrings);
1830 if (! cArray)
1831 return NULL;
1832 bmp = new wxBitmap(cArray);
1833 delete [] cArray;
1834 return bmp;
1835 }
1836 static wxBitmap *new_wxBitmap(PyObject *bits,int width,int height,int depth=1){
1837 char* buf;
1838 int length;
1839 PyString_AsStringAndSize(bits, &buf, &length);
1840 return new wxBitmap(buf, width, height, depth);
1841 }
1842 static wxSize wxBitmap_GetSize(wxBitmap *self){
1843 wxSize size(self->GetWidth(), self->GetHeight());
1844 return size;
1845 }
1846 static void wxBitmap_SetMaskColour(wxBitmap *self,wxColour const &colour){
1847 wxMask *mask = new wxMask(*self, colour);
1848 self->SetMask(mask);
1849 }
1850 static void wxBitmap_SetSize(wxBitmap *self,wxSize const &size){
1851 self->SetWidth(size.x);
1852 self->SetHeight(size.y);
1853 }
1854 static bool wxBitmap___eq__(wxBitmap *self,wxBitmap const *other){ return other ? (*self == *other) : false; }
1855 static bool wxBitmap___ne__(wxBitmap *self,wxBitmap const *other){ return other ? (*self != *other) : true; }
1856 static wxMask *new_wxMask(wxBitmap const &bitmap,wxColour const &colour=wxNullColour){
1857 if ( !colour.Ok() )
1858 return new wxMask(bitmap, *wxBLACK);
1859 else
1860 return new wxMask(bitmap, colour);
1861 }
1862
1863 #include <wx/iconbndl.h>
1864
1865 static wxIcon *new_wxIcon(wxBitmap const &bmp){
1866 wxIcon* icon = new wxIcon();
1867 icon->CopyFromBitmap(bmp);
1868 return icon;
1869 }
1870 static wxIcon *new_wxIcon(PyObject *listOfStrings){
1871 char** cArray = NULL;
1872 wxIcon* icon;
1873
1874 cArray = ConvertListOfStrings(listOfStrings);
1875 if (! cArray)
1876 return NULL;
1877 icon = new wxIcon(cArray);
1878 delete [] cArray;
1879 return icon;
1880 }
1881 static wxIconLocation *new_wxIconLocation(wxString const *filename=&wxPyEmptyString,int num=0){
1882
1883
1884
1885 return new wxIconLocation(*filename);
1886
1887 }
1888 static void wxIconLocation_SetIndex(wxIconLocation *self,int num){
1889
1890
1891
1892 // do nothing
1893
1894 }
1895 static int wxIconLocation_GetIndex(wxIconLocation *self){
1896
1897
1898
1899 return -1;
1900
1901 }
1902
1903 SWIGINTERNSHORT long
1904 SWIG_As_long(PyObject* obj)
1905 {
1906 long v;
1907 if (!SWIG_AsVal_long(obj, &v)) {
1908 /*
1909 this is needed to make valgrind/purify happier.
1910 */
1911 memset((void*)&v, 0, sizeof(long));
1912 }
1913 return v;
1914 }
1915
1916
1917 SWIGINTERNSHORT int
1918 SWIG_Check_long(PyObject* obj)
1919 {
1920 return SWIG_AsVal_long(obj, (long*)0);
1921 }
1922
1923 static wxCursor *new_wxCursor(wxString const &cursorName,long type,int hotSpotX=0,int hotSpotY=0){
1924 #ifdef __WXGTK__
1925 wxImage img(cursorName, type);
1926 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X, hotSpotX);
1927 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y, hotSpotY);
1928 return new wxCursor(img);
1929 #else
1930 return new wxCursor(cursorName, type, hotSpotX, hotSpotY);
1931 #endif
1932 }
1933
1934
1935 static void wxRegionIterator_Next(wxRegionIterator *self){
1936 (*self) ++;
1937 }
1938 static bool wxRegionIterator___nonzero__(wxRegionIterator *self){
1939 return self->operator bool();
1940 }
1941
1942 #include <wx/fontutil.h>
1943 #include <wx/fontmap.h>
1944 #include <wx/fontenum.h>
1945
1946 static wxString wxNativeFontInfo___str__(wxNativeFontInfo *self){
1947 return self->ToString();
1948 }
1949
1950 wxNativeEncodingInfo* wxGetNativeFontEncoding(wxFontEncoding encoding) {
1951 static wxNativeEncodingInfo info;
1952 if ( wxGetNativeFontEncoding(encoding, &info) )
1953 return &info;
1954 else
1955 return NULL;
1956 }
1957
1958 static PyObject *wxFontMapper_GetAltForEncoding(wxFontMapper *self,wxFontEncoding encoding,wxString const &facename=wxPyEmptyString,bool interactive=true){
1959 wxFontEncoding alt_enc;
1960 if (self->GetAltForEncoding(encoding, &alt_enc, facename, interactive))
1961 return PyInt_FromLong(alt_enc);
1962 else {
1963 Py_INCREF(Py_None);
1964 return Py_None;
1965 }
1966 }
1967 static wxFont *new_wxFont(wxString const &info){
1968 wxNativeFontInfo nfi;
1969 nfi.FromString(info);
1970 return new wxFont(nfi);
1971 }
1972 static wxFont *new_wxFont(int pointSize,wxFontFamily family,int flags=wxFONTFLAG_DEFAULT,wxString const &face=wxPyEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1973 return wxFont::New(pointSize, family, flags, face, encoding);
1974 }
1975 static wxFont *new_wxFont(wxSize const &pixelSize,int family,int style,int weight,bool underlined=false,wxString const &face=wxEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1976 return wxFontBase::New(pixelSize, family,
1977 style, weight, underlined,
1978 face, encoding);
1979 }
1980 static bool wxFont___eq__(wxFont *self,wxFont const *other){ return other ? (*self == *other) : false; }
1981 static bool wxFont___ne__(wxFont *self,wxFont const *other){ return other ? (*self != *other) : true; }
1982
1983 class wxPyFontEnumerator : public wxFontEnumerator {
1984 public:
1985 wxPyFontEnumerator() {}
1986 ~wxPyFontEnumerator() {}
1987
1988 DEC_PYCALLBACK_BOOL_STRING(OnFacename);
1989 DEC_PYCALLBACK_BOOL_STRINGSTRING(OnFontEncoding);
1990
1991 PYPRIVATE;
1992 };
1993
1994 IMP_PYCALLBACK_BOOL_STRING(wxPyFontEnumerator, wxFontEnumerator, OnFacename);
1995 IMP_PYCALLBACK_BOOL_STRINGSTRING(wxPyFontEnumerator, wxFontEnumerator, OnFontEncoding);
1996
1997
1998 static PyObject *wxPyFontEnumerator_GetEncodings(wxPyFontEnumerator *self){
1999 wxArrayString* arr = self->GetEncodings();
2000 if (arr)
2001 return wxArrayString2PyList_helper(*arr);
2002 else
2003 return PyList_New(0);
2004 }
2005 static PyObject *wxPyFontEnumerator_GetFacenames(wxPyFontEnumerator *self){
2006 wxArrayString* arr = self->GetFacenames();
2007 if (arr)
2008 return wxArrayString2PyList_helper(*arr);
2009 else
2010 return PyList_New(0);
2011 }
2012
2013 #include <locale.h>
2014
2015 static wxLocale *new_wxLocale(int language=-1,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
2016 wxLocale* loc;
2017 if (language == -1)
2018 loc = new wxLocale();
2019 else
2020 loc = new wxLocale(language, flags);
2021 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
2022 // for the floating point conversions and such to work right.
2023 #if PY_VERSION_HEX < 0x02040000
2024 setlocale(LC_NUMERIC, "C");
2025 #endif
2026 return loc;
2027 }
2028 static bool wxLocale_Init1(wxLocale *self,wxString const &szName,wxString const &szShort=wxPyEmptyString,wxString const &szLocale=wxPyEmptyString,bool bLoadDefault=true,bool bConvertEncoding=false){
2029 bool rc = self->Init(szName, szShort, szLocale, bLoadDefault, bConvertEncoding);
2030 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
2031 // for the floating point conversions and such to work right.
2032 #if PY_VERSION_HEX < 0x02040000
2033 setlocale(LC_NUMERIC, "C");
2034 #endif
2035 return rc;
2036 }
2037 static bool wxLocale_Init2(wxLocale *self,int language=wxLANGUAGE_DEFAULT,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
2038 bool rc = self->Init(language, flags);
2039 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
2040 // for the floating point conversions and such to work right.
2041 #if PY_VERSION_HEX < 0x02040000
2042 setlocale(LC_NUMERIC, "C");
2043 #endif
2044 return rc;
2045 }
2046
2047 #include "wx/wxPython/pydrawxxx.h"
2048
2049 static wxColour wxDC_GetPixel(wxDC *self,int x,int y){
2050 wxColour col;
2051 self->GetPixel(x, y, &col);
2052 return col;
2053 }
2054 static wxColour wxDC_GetPixelPoint(wxDC *self,wxPoint const &pt){
2055 wxColour col;
2056 self->GetPixel(pt, &col);
2057 return col;
2058 }
2059
2060 SWIGINTERN int
2061 SWIG_AsVal_double(PyObject *obj, double* val)
2062 {
2063 if (PyNumber_Check(obj)) {
2064 if (val) *val = PyFloat_AsDouble(obj);
2065 return 1;
2066 }
2067 else {
2068 SWIG_type_error("number", obj);
2069 }
2070 return 0;
2071 }
2072
2073
2074 SWIGINTERNSHORT double
2075 SWIG_As_double(PyObject* obj)
2076 {
2077 double v;
2078 if (!SWIG_AsVal_double(obj, &v)) {
2079 /*
2080 this is needed to make valgrind/purify happier.
2081 */
2082 memset((void*)&v, 0, sizeof(double));
2083 }
2084 return v;
2085 }
2086
2087
2088 SWIGINTERNSHORT int
2089 SWIG_Check_double(PyObject* obj)
2090 {
2091 return SWIG_AsVal_double(obj, (double*)0);
2092 }
2093
2094 static wxRect wxDC_DrawImageLabel(wxDC *self,wxString const &text,wxBitmap const &image,wxRect const &rect,int alignment=wxALIGN_LEFT|wxALIGN_TOP,int indexAccel=-1){
2095 wxRect rv;
2096 self->DrawLabel(text, image, rect, alignment, indexAccel, &rv);
2097 return rv;
2098 }
2099
2100 static wxRect wxDC_GetClippingRect(wxDC *self){
2101 wxRect rect;
2102 self->GetClippingBox(rect);
2103 return rect;
2104 }
2105 static wxArrayInt wxDC_GetPartialTextExtents(wxDC *self,wxString const &text){
2106 wxArrayInt widths;
2107 self->GetPartialTextExtents(text, widths);
2108 return widths;
2109 }
2110
2111 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2112 #define SWIG_From_double PyFloat_FromDouble
2113 /*@@*/
2114
2115
2116 static void wxDC_SetLogicalOriginPoint(wxDC *self,wxPoint const &point){
2117 self->SetLogicalOrigin(point.x, point.y);
2118 }
2119 static void wxDC_SetDeviceOriginPoint(wxDC *self,wxPoint const &point){
2120 self->SetDeviceOrigin(point.x, point.y);
2121 }
2122 static void wxDC_CalcBoundingBoxPoint(wxDC *self,wxPoint const &point){
2123 self->CalcBoundingBox(point.x, point.y);
2124 }
2125 static PyObject *wxDC__DrawPointList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2126 return wxPyDrawXXXList(*self, wxPyDrawXXXPoint, pyCoords, pyPens, pyBrushes);
2127 }
2128 static PyObject *wxDC__DrawLineList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2129 return wxPyDrawXXXList(*self, wxPyDrawXXXLine, pyCoords, pyPens, pyBrushes);
2130 }
2131 static PyObject *wxDC__DrawRectangleList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2132 return wxPyDrawXXXList(*self, wxPyDrawXXXRectangle, pyCoords, pyPens, pyBrushes);
2133 }
2134 static PyObject *wxDC__DrawEllipseList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2135 return wxPyDrawXXXList(*self, wxPyDrawXXXEllipse, pyCoords, pyPens, pyBrushes);
2136 }
2137 static PyObject *wxDC__DrawPolygonList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2138 return wxPyDrawXXXList(*self, wxPyDrawXXXPolygon, pyCoords, pyPens, pyBrushes);
2139 }
2140 static PyObject *wxDC__DrawTextList(wxDC *self,PyObject *textList,PyObject *pyPoints,PyObject *foregroundList,PyObject *backgroundList){
2141 return wxPyDrawTextList(*self, textList, pyPoints, foregroundList, backgroundList);
2142 }
2143
2144 static void wxDC_GetBoundingBox(wxDC* dc, int* x1, int* y1, int* x2, int* y2) {
2145 *x1 = dc->MinX();
2146 *y1 = dc->MinY();
2147 *x2 = dc->MaxX();
2148 *y2 = dc->MaxY();
2149 }
2150
2151
2152 #include <wx/dcbuffer.h>
2153
2154
2155 #include <wx/dcps.h>
2156
2157
2158 #include <wx/metafile.h>
2159
2160
2161
2162 static void wxColourDatabase_Append(wxColourDatabase *self,wxString const &name,int red,int green,int blue){
2163 self->AddColour(name, wxColour(red, green, blue));
2164 }
2165
2166 #include <wx/effects.h>
2167
2168 #ifdef __cplusplus
2169 extern "C" {
2170 #endif
2171 static PyObject *_wrap_new_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2172 PyObject *resultobj;
2173 wxGDIObject *result;
2174 char *kwnames[] = {
2175 NULL
2176 };
2177
2178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GDIObject",kwnames)) goto fail;
2179 {
2180 if (!wxPyCheckForApp()) SWIG_fail;
2181 PyThreadState* __tstate = wxPyBeginAllowThreads();
2182 result = (wxGDIObject *)new wxGDIObject();
2183
2184 wxPyEndAllowThreads(__tstate);
2185 if (PyErr_Occurred()) SWIG_fail;
2186 }
2187 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGDIObject, 1);
2188 return resultobj;
2189 fail:
2190 return NULL;
2191 }
2192
2193
2194 static PyObject *_wrap_delete_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2195 PyObject *resultobj;
2196 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2197 PyObject * obj0 = 0 ;
2198 char *kwnames[] = {
2199 (char *) "self", NULL
2200 };
2201
2202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GDIObject",kwnames,&obj0)) goto fail;
2203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2204 if (SWIG_arg_fail(1)) SWIG_fail;
2205 {
2206 PyThreadState* __tstate = wxPyBeginAllowThreads();
2207 delete arg1;
2208
2209 wxPyEndAllowThreads(__tstate);
2210 if (PyErr_Occurred()) SWIG_fail;
2211 }
2212 Py_INCREF(Py_None); resultobj = Py_None;
2213 return resultobj;
2214 fail:
2215 return NULL;
2216 }
2217
2218
2219 static PyObject *_wrap_GDIObject_GetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2220 PyObject *resultobj;
2221 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2222 bool result;
2223 PyObject * obj0 = 0 ;
2224 char *kwnames[] = {
2225 (char *) "self", NULL
2226 };
2227
2228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_GetVisible",kwnames,&obj0)) goto fail;
2229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2230 if (SWIG_arg_fail(1)) SWIG_fail;
2231 {
2232 PyThreadState* __tstate = wxPyBeginAllowThreads();
2233 result = (bool)(arg1)->GetVisible();
2234
2235 wxPyEndAllowThreads(__tstate);
2236 if (PyErr_Occurred()) SWIG_fail;
2237 }
2238 {
2239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2240 }
2241 return resultobj;
2242 fail:
2243 return NULL;
2244 }
2245
2246
2247 static PyObject *_wrap_GDIObject_SetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2248 PyObject *resultobj;
2249 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2250 bool arg2 ;
2251 PyObject * obj0 = 0 ;
2252 PyObject * obj1 = 0 ;
2253 char *kwnames[] = {
2254 (char *) "self",(char *) "visible", NULL
2255 };
2256
2257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GDIObject_SetVisible",kwnames,&obj0,&obj1)) goto fail;
2258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2259 if (SWIG_arg_fail(1)) SWIG_fail;
2260 {
2261 arg2 = (bool)(SWIG_As_bool(obj1));
2262 if (SWIG_arg_fail(2)) SWIG_fail;
2263 }
2264 {
2265 PyThreadState* __tstate = wxPyBeginAllowThreads();
2266 (arg1)->SetVisible(arg2);
2267
2268 wxPyEndAllowThreads(__tstate);
2269 if (PyErr_Occurred()) SWIG_fail;
2270 }
2271 Py_INCREF(Py_None); resultobj = Py_None;
2272 return resultobj;
2273 fail:
2274 return NULL;
2275 }
2276
2277
2278 static PyObject *_wrap_GDIObject_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
2279 PyObject *resultobj;
2280 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2281 bool result;
2282 PyObject * obj0 = 0 ;
2283 char *kwnames[] = {
2284 (char *) "self", NULL
2285 };
2286
2287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_IsNull",kwnames,&obj0)) goto fail;
2288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2289 if (SWIG_arg_fail(1)) SWIG_fail;
2290 {
2291 PyThreadState* __tstate = wxPyBeginAllowThreads();
2292 result = (bool)(arg1)->IsNull();
2293
2294 wxPyEndAllowThreads(__tstate);
2295 if (PyErr_Occurred()) SWIG_fail;
2296 }
2297 {
2298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2299 }
2300 return resultobj;
2301 fail:
2302 return NULL;
2303 }
2304
2305
2306 static PyObject * GDIObject_swigregister(PyObject *, PyObject *args) {
2307 PyObject *obj;
2308 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2309 SWIG_TypeClientData(SWIGTYPE_p_wxGDIObject, obj);
2310 Py_INCREF(obj);
2311 return Py_BuildValue((char *)"");
2312 }
2313 static PyObject *_wrap_new_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2314 PyObject *resultobj;
2315 byte arg1 = (byte) 0 ;
2316 byte arg2 = (byte) 0 ;
2317 byte arg3 = (byte) 0 ;
2318 wxColour *result;
2319 PyObject * obj0 = 0 ;
2320 PyObject * obj1 = 0 ;
2321 PyObject * obj2 = 0 ;
2322 char *kwnames[] = {
2323 (char *) "red",(char *) "green",(char *) "blue", NULL
2324 };
2325
2326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Colour",kwnames,&obj0,&obj1,&obj2)) goto fail;
2327 if (obj0) {
2328 {
2329 arg1 = (byte)(SWIG_As_unsigned_SS_char(obj0));
2330 if (SWIG_arg_fail(1)) SWIG_fail;
2331 }
2332 }
2333 if (obj1) {
2334 {
2335 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2336 if (SWIG_arg_fail(2)) SWIG_fail;
2337 }
2338 }
2339 if (obj2) {
2340 {
2341 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2342 if (SWIG_arg_fail(3)) SWIG_fail;
2343 }
2344 }
2345 {
2346 PyThreadState* __tstate = wxPyBeginAllowThreads();
2347 result = (wxColour *)new wxColour(arg1,arg2,arg3);
2348
2349 wxPyEndAllowThreads(__tstate);
2350 if (PyErr_Occurred()) SWIG_fail;
2351 }
2352 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2353 return resultobj;
2354 fail:
2355 return NULL;
2356 }
2357
2358
2359 static PyObject *_wrap_new_NamedColour(PyObject *, PyObject *args, PyObject *kwargs) {
2360 PyObject *resultobj;
2361 wxString *arg1 = 0 ;
2362 wxColour *result;
2363 bool temp1 = false ;
2364 PyObject * obj0 = 0 ;
2365 char *kwnames[] = {
2366 (char *) "colorName", NULL
2367 };
2368
2369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_NamedColour",kwnames,&obj0)) goto fail;
2370 {
2371 arg1 = wxString_in_helper(obj0);
2372 if (arg1 == NULL) SWIG_fail;
2373 temp1 = true;
2374 }
2375 {
2376 if (!wxPyCheckForApp()) SWIG_fail;
2377 PyThreadState* __tstate = wxPyBeginAllowThreads();
2378 result = (wxColour *)new wxColour((wxString const &)*arg1);
2379
2380 wxPyEndAllowThreads(__tstate);
2381 if (PyErr_Occurred()) SWIG_fail;
2382 }
2383 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2384 {
2385 if (temp1)
2386 delete arg1;
2387 }
2388 return resultobj;
2389 fail:
2390 {
2391 if (temp1)
2392 delete arg1;
2393 }
2394 return NULL;
2395 }
2396
2397
2398 static PyObject *_wrap_new_ColourRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2399 PyObject *resultobj;
2400 unsigned long arg1 ;
2401 wxColour *result;
2402 PyObject * obj0 = 0 ;
2403 char *kwnames[] = {
2404 (char *) "colRGB", NULL
2405 };
2406
2407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ColourRGB",kwnames,&obj0)) goto fail;
2408 {
2409 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
2410 if (SWIG_arg_fail(1)) SWIG_fail;
2411 }
2412 {
2413 PyThreadState* __tstate = wxPyBeginAllowThreads();
2414 result = (wxColour *)new wxColour(arg1);
2415
2416 wxPyEndAllowThreads(__tstate);
2417 if (PyErr_Occurred()) SWIG_fail;
2418 }
2419 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2420 return resultobj;
2421 fail:
2422 return NULL;
2423 }
2424
2425
2426 static PyObject *_wrap_delete_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2427 PyObject *resultobj;
2428 wxColour *arg1 = (wxColour *) 0 ;
2429 PyObject * obj0 = 0 ;
2430 char *kwnames[] = {
2431 (char *) "self", NULL
2432 };
2433
2434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Colour",kwnames,&obj0)) goto fail;
2435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2436 if (SWIG_arg_fail(1)) SWIG_fail;
2437 {
2438 PyThreadState* __tstate = wxPyBeginAllowThreads();
2439 delete arg1;
2440
2441 wxPyEndAllowThreads(__tstate);
2442 if (PyErr_Occurred()) SWIG_fail;
2443 }
2444 Py_INCREF(Py_None); resultobj = Py_None;
2445 return resultobj;
2446 fail:
2447 return NULL;
2448 }
2449
2450
2451 static PyObject *_wrap_Colour_Red(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_Red",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)->Red();
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_Green(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_Green",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)->Green();
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_Blue(PyObject *, PyObject *args, PyObject *kwargs) {
2508 PyObject *resultobj;
2509 wxColour *arg1 = (wxColour *) 0 ;
2510 byte result;
2511 PyObject * obj0 = 0 ;
2512 char *kwnames[] = {
2513 (char *) "self", NULL
2514 };
2515
2516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Blue",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 = (byte)(arg1)->Blue();
2522
2523 wxPyEndAllowThreads(__tstate);
2524 if (PyErr_Occurred()) SWIG_fail;
2525 }
2526 {
2527 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2528 }
2529 return resultobj;
2530 fail:
2531 return NULL;
2532 }
2533
2534
2535 static PyObject *_wrap_Colour_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
2536 PyObject *resultobj;
2537 wxColour *arg1 = (wxColour *) 0 ;
2538 bool result;
2539 PyObject * obj0 = 0 ;
2540 char *kwnames[] = {
2541 (char *) "self", NULL
2542 };
2543
2544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Ok",kwnames,&obj0)) goto fail;
2545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2546 if (SWIG_arg_fail(1)) SWIG_fail;
2547 {
2548 PyThreadState* __tstate = wxPyBeginAllowThreads();
2549 result = (bool)(arg1)->Ok();
2550
2551 wxPyEndAllowThreads(__tstate);
2552 if (PyErr_Occurred()) SWIG_fail;
2553 }
2554 {
2555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2556 }
2557 return resultobj;
2558 fail:
2559 return NULL;
2560 }
2561
2562
2563 static PyObject *_wrap_Colour_Set(PyObject *, PyObject *args, PyObject *kwargs) {
2564 PyObject *resultobj;
2565 wxColour *arg1 = (wxColour *) 0 ;
2566 byte arg2 ;
2567 byte arg3 ;
2568 byte arg4 ;
2569 PyObject * obj0 = 0 ;
2570 PyObject * obj1 = 0 ;
2571 PyObject * obj2 = 0 ;
2572 PyObject * obj3 = 0 ;
2573 char *kwnames[] = {
2574 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2575 };
2576
2577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Colour_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2579 if (SWIG_arg_fail(1)) SWIG_fail;
2580 {
2581 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2582 if (SWIG_arg_fail(2)) SWIG_fail;
2583 }
2584 {
2585 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2586 if (SWIG_arg_fail(3)) SWIG_fail;
2587 }
2588 {
2589 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2590 if (SWIG_arg_fail(4)) SWIG_fail;
2591 }
2592 {
2593 PyThreadState* __tstate = wxPyBeginAllowThreads();
2594 (arg1)->Set(arg2,arg3,arg4);
2595
2596 wxPyEndAllowThreads(__tstate);
2597 if (PyErr_Occurred()) SWIG_fail;
2598 }
2599 Py_INCREF(Py_None); resultobj = Py_None;
2600 return resultobj;
2601 fail:
2602 return NULL;
2603 }
2604
2605
2606 static PyObject *_wrap_Colour_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2607 PyObject *resultobj;
2608 wxColour *arg1 = (wxColour *) 0 ;
2609 unsigned long arg2 ;
2610 PyObject * obj0 = 0 ;
2611 PyObject * obj1 = 0 ;
2612 char *kwnames[] = {
2613 (char *) "self",(char *) "colRGB", NULL
2614 };
2615
2616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetRGB",kwnames,&obj0,&obj1)) goto fail;
2617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2618 if (SWIG_arg_fail(1)) SWIG_fail;
2619 {
2620 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
2621 if (SWIG_arg_fail(2)) SWIG_fail;
2622 }
2623 {
2624 PyThreadState* __tstate = wxPyBeginAllowThreads();
2625 (arg1)->Set(arg2);
2626
2627 wxPyEndAllowThreads(__tstate);
2628 if (PyErr_Occurred()) SWIG_fail;
2629 }
2630 Py_INCREF(Py_None); resultobj = Py_None;
2631 return resultobj;
2632 fail:
2633 return NULL;
2634 }
2635
2636
2637 static PyObject *_wrap_Colour_SetFromName(PyObject *, PyObject *args, PyObject *kwargs) {
2638 PyObject *resultobj;
2639 wxColour *arg1 = (wxColour *) 0 ;
2640 wxString *arg2 = 0 ;
2641 bool temp2 = false ;
2642 PyObject * obj0 = 0 ;
2643 PyObject * obj1 = 0 ;
2644 char *kwnames[] = {
2645 (char *) "self",(char *) "colourName", NULL
2646 };
2647
2648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetFromName",kwnames,&obj0,&obj1)) goto fail;
2649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2650 if (SWIG_arg_fail(1)) SWIG_fail;
2651 {
2652 arg2 = wxString_in_helper(obj1);
2653 if (arg2 == NULL) SWIG_fail;
2654 temp2 = true;
2655 }
2656 {
2657 PyThreadState* __tstate = wxPyBeginAllowThreads();
2658 (arg1)->InitFromName((wxString const &)*arg2);
2659
2660 wxPyEndAllowThreads(__tstate);
2661 if (PyErr_Occurred()) SWIG_fail;
2662 }
2663 Py_INCREF(Py_None); resultobj = Py_None;
2664 {
2665 if (temp2)
2666 delete arg2;
2667 }
2668 return resultobj;
2669 fail:
2670 {
2671 if (temp2)
2672 delete arg2;
2673 }
2674 return NULL;
2675 }
2676
2677
2678 static PyObject *_wrap_Colour_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2679 PyObject *resultobj;
2680 wxColour *arg1 = (wxColour *) 0 ;
2681 long result;
2682 PyObject * obj0 = 0 ;
2683 char *kwnames[] = {
2684 (char *) "self", NULL
2685 };
2686
2687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetPixel",kwnames,&obj0)) goto fail;
2688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2689 if (SWIG_arg_fail(1)) SWIG_fail;
2690 {
2691 PyThreadState* __tstate = wxPyBeginAllowThreads();
2692 result = (long)((wxColour const *)arg1)->GetPixel();
2693
2694 wxPyEndAllowThreads(__tstate);
2695 if (PyErr_Occurred()) SWIG_fail;
2696 }
2697 {
2698 resultobj = SWIG_From_long((long)(result));
2699 }
2700 return resultobj;
2701 fail:
2702 return NULL;
2703 }
2704
2705
2706 static PyObject *_wrap_Colour___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
2707 PyObject *resultobj;
2708 wxColour *arg1 = (wxColour *) 0 ;
2709 wxColour *arg2 = 0 ;
2710 bool result;
2711 wxColour temp2 ;
2712 PyObject * obj0 = 0 ;
2713 PyObject * obj1 = 0 ;
2714 char *kwnames[] = {
2715 (char *) "self",(char *) "colour", NULL
2716 };
2717
2718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___eq__",kwnames,&obj0,&obj1)) goto fail;
2719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2720 if (SWIG_arg_fail(1)) SWIG_fail;
2721 {
2722 arg2 = &temp2;
2723 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2724 }
2725 {
2726 PyThreadState* __tstate = wxPyBeginAllowThreads();
2727 result = (bool)((wxColour const *)arg1)->operator ==((wxColour const &)*arg2);
2728
2729 wxPyEndAllowThreads(__tstate);
2730 if (PyErr_Occurred()) SWIG_fail;
2731 }
2732 {
2733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2734 }
2735 return resultobj;
2736 fail:
2737 return NULL;
2738 }
2739
2740
2741 static PyObject *_wrap_Colour___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
2742 PyObject *resultobj;
2743 wxColour *arg1 = (wxColour *) 0 ;
2744 wxColour *arg2 = 0 ;
2745 bool result;
2746 wxColour temp2 ;
2747 PyObject * obj0 = 0 ;
2748 PyObject * obj1 = 0 ;
2749 char *kwnames[] = {
2750 (char *) "self",(char *) "colour", NULL
2751 };
2752
2753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___ne__",kwnames,&obj0,&obj1)) goto fail;
2754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2755 if (SWIG_arg_fail(1)) SWIG_fail;
2756 {
2757 arg2 = &temp2;
2758 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2759 }
2760 {
2761 PyThreadState* __tstate = wxPyBeginAllowThreads();
2762 result = (bool)((wxColour const *)arg1)->operator !=((wxColour const &)*arg2);
2763
2764 wxPyEndAllowThreads(__tstate);
2765 if (PyErr_Occurred()) SWIG_fail;
2766 }
2767 {
2768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2769 }
2770 return resultobj;
2771 fail:
2772 return NULL;
2773 }
2774
2775
2776 static PyObject *_wrap_Colour_Get(PyObject *, PyObject *args, PyObject *kwargs) {
2777 PyObject *resultobj;
2778 wxColour *arg1 = (wxColour *) 0 ;
2779 PyObject *result;
2780 PyObject * obj0 = 0 ;
2781 char *kwnames[] = {
2782 (char *) "self", NULL
2783 };
2784
2785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Get",kwnames,&obj0)) goto fail;
2786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2787 if (SWIG_arg_fail(1)) SWIG_fail;
2788 {
2789 PyThreadState* __tstate = wxPyBeginAllowThreads();
2790 result = (PyObject *)wxColour_Get(arg1);
2791
2792 wxPyEndAllowThreads(__tstate);
2793 if (PyErr_Occurred()) SWIG_fail;
2794 }
2795 resultobj = result;
2796 return resultobj;
2797 fail:
2798 return NULL;
2799 }
2800
2801
2802 static PyObject *_wrap_Colour_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2803 PyObject *resultobj;
2804 wxColour *arg1 = (wxColour *) 0 ;
2805 unsigned long result;
2806 PyObject * obj0 = 0 ;
2807 char *kwnames[] = {
2808 (char *) "self", NULL
2809 };
2810
2811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetRGB",kwnames,&obj0)) goto fail;
2812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2813 if (SWIG_arg_fail(1)) SWIG_fail;
2814 {
2815 PyThreadState* __tstate = wxPyBeginAllowThreads();
2816 result = (unsigned long)wxColour_GetRGB(arg1);
2817
2818 wxPyEndAllowThreads(__tstate);
2819 if (PyErr_Occurred()) SWIG_fail;
2820 }
2821 {
2822 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
2823 }
2824 return resultobj;
2825 fail:
2826 return NULL;
2827 }
2828
2829
2830 static PyObject * Colour_swigregister(PyObject *, PyObject *args) {
2831 PyObject *obj;
2832 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2833 SWIG_TypeClientData(SWIGTYPE_p_wxColour, obj);
2834 Py_INCREF(obj);
2835 return Py_BuildValue((char *)"");
2836 }
2837 static PyObject *_wrap_new_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2838 PyObject *resultobj;
2839 int arg1 ;
2840 unsigned char *arg2 = (unsigned char *) 0 ;
2841 unsigned char *arg3 = (unsigned char *) 0 ;
2842 unsigned char *arg4 = (unsigned char *) 0 ;
2843 wxPalette *result;
2844 PyObject * obj0 = 0 ;
2845 PyObject * obj1 = 0 ;
2846 PyObject * obj2 = 0 ;
2847 PyObject * obj3 = 0 ;
2848 char *kwnames[] = {
2849 (char *) "n",(char *) "red",(char *) "green",(char *) "blue", NULL
2850 };
2851
2852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_Palette",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2853 {
2854 arg1 = (int)(SWIG_As_int(obj0));
2855 if (SWIG_arg_fail(1)) SWIG_fail;
2856 }
2857 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2858 if (SWIG_arg_fail(2)) SWIG_fail;
2859 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2860 if (SWIG_arg_fail(3)) SWIG_fail;
2861 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2862 if (SWIG_arg_fail(4)) SWIG_fail;
2863 {
2864 if (!wxPyCheckForApp()) SWIG_fail;
2865 PyThreadState* __tstate = wxPyBeginAllowThreads();
2866 result = (wxPalette *)new wxPalette(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
2867
2868 wxPyEndAllowThreads(__tstate);
2869 if (PyErr_Occurred()) SWIG_fail;
2870 }
2871 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 1);
2872 return resultobj;
2873 fail:
2874 return NULL;
2875 }
2876
2877
2878 static PyObject *_wrap_delete_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2879 PyObject *resultobj;
2880 wxPalette *arg1 = (wxPalette *) 0 ;
2881 PyObject * obj0 = 0 ;
2882 char *kwnames[] = {
2883 (char *) "self", NULL
2884 };
2885
2886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Palette",kwnames,&obj0)) goto fail;
2887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2888 if (SWIG_arg_fail(1)) SWIG_fail;
2889 {
2890 PyThreadState* __tstate = wxPyBeginAllowThreads();
2891 delete arg1;
2892
2893 wxPyEndAllowThreads(__tstate);
2894 if (PyErr_Occurred()) SWIG_fail;
2895 }
2896 Py_INCREF(Py_None); resultobj = Py_None;
2897 return resultobj;
2898 fail:
2899 return NULL;
2900 }
2901
2902
2903 static PyObject *_wrap_Palette_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2904 PyObject *resultobj;
2905 wxPalette *arg1 = (wxPalette *) 0 ;
2906 byte arg2 ;
2907 byte arg3 ;
2908 byte arg4 ;
2909 int result;
2910 PyObject * obj0 = 0 ;
2911 PyObject * obj1 = 0 ;
2912 PyObject * obj2 = 0 ;
2913 PyObject * obj3 = 0 ;
2914 char *kwnames[] = {
2915 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2916 };
2917
2918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Palette_GetPixel",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2920 if (SWIG_arg_fail(1)) SWIG_fail;
2921 {
2922 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2923 if (SWIG_arg_fail(2)) SWIG_fail;
2924 }
2925 {
2926 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2927 if (SWIG_arg_fail(3)) SWIG_fail;
2928 }
2929 {
2930 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2931 if (SWIG_arg_fail(4)) SWIG_fail;
2932 }
2933 {
2934 PyThreadState* __tstate = wxPyBeginAllowThreads();
2935 result = (int)(arg1)->GetPixel(arg2,arg3,arg4);
2936
2937 wxPyEndAllowThreads(__tstate);
2938 if (PyErr_Occurred()) SWIG_fail;
2939 }
2940 {
2941 resultobj = SWIG_From_int((int)(result));
2942 }
2943 return resultobj;
2944 fail:
2945 return NULL;
2946 }
2947
2948
2949 static PyObject *_wrap_Palette_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2950 PyObject *resultobj;
2951 wxPalette *arg1 = (wxPalette *) 0 ;
2952 int arg2 ;
2953 byte *arg3 = (byte *) 0 ;
2954 byte *arg4 = (byte *) 0 ;
2955 byte *arg5 = (byte *) 0 ;
2956 bool result;
2957 byte temp3 ;
2958 int res3 = 0 ;
2959 byte temp4 ;
2960 int res4 = 0 ;
2961 byte temp5 ;
2962 int res5 = 0 ;
2963 PyObject * obj0 = 0 ;
2964 PyObject * obj1 = 0 ;
2965 char *kwnames[] = {
2966 (char *) "self",(char *) "pixel", NULL
2967 };
2968
2969 arg3 = &temp3; res3 = SWIG_NEWOBJ;
2970 arg4 = &temp4; res4 = SWIG_NEWOBJ;
2971 arg5 = &temp5; res5 = SWIG_NEWOBJ;
2972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Palette_GetRGB",kwnames,&obj0,&obj1)) goto fail;
2973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2974 if (SWIG_arg_fail(1)) SWIG_fail;
2975 {
2976 arg2 = (int)(SWIG_As_int(obj1));
2977 if (SWIG_arg_fail(2)) SWIG_fail;
2978 }
2979 {
2980 PyThreadState* __tstate = wxPyBeginAllowThreads();
2981 result = (bool)(arg1)->GetRGB(arg2,arg3,arg4,arg5);
2982
2983 wxPyEndAllowThreads(__tstate);
2984 if (PyErr_Occurred()) SWIG_fail;
2985 }
2986 {
2987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2988 }
2989 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
2990 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
2991 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
2992 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
2993 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
2994 SWIG_From_unsigned_SS_char((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_unsigned_char, 0)));
2995 return resultobj;
2996 fail:
2997 return NULL;
2998 }
2999
3000
3001 static PyObject *_wrap_Palette_GetColoursCount(PyObject *, PyObject *args, PyObject *kwargs) {
3002 PyObject *resultobj;
3003 wxPalette *arg1 = (wxPalette *) 0 ;
3004 int result;
3005 PyObject * obj0 = 0 ;
3006 char *kwnames[] = {
3007 (char *) "self", NULL
3008 };
3009
3010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_GetColoursCount",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 = (int)((wxPalette const *)arg1)->GetColoursCount();
3016
3017 wxPyEndAllowThreads(__tstate);
3018 if (PyErr_Occurred()) SWIG_fail;
3019 }
3020 {
3021 resultobj = SWIG_From_int((int)(result));
3022 }
3023 return resultobj;
3024 fail:
3025 return NULL;
3026 }
3027
3028
3029 static PyObject *_wrap_Palette_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3030 PyObject *resultobj;
3031 wxPalette *arg1 = (wxPalette *) 0 ;
3032 bool result;
3033 PyObject * obj0 = 0 ;
3034 char *kwnames[] = {
3035 (char *) "self", NULL
3036 };
3037
3038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_Ok",kwnames,&obj0)) goto fail;
3039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
3040 if (SWIG_arg_fail(1)) SWIG_fail;
3041 {
3042 PyThreadState* __tstate = wxPyBeginAllowThreads();
3043 result = (bool)(arg1)->Ok();
3044
3045 wxPyEndAllowThreads(__tstate);
3046 if (PyErr_Occurred()) SWIG_fail;
3047 }
3048 {
3049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3050 }
3051 return resultobj;
3052 fail:
3053 return NULL;
3054 }
3055
3056
3057 static PyObject * Palette_swigregister(PyObject *, PyObject *args) {
3058 PyObject *obj;
3059 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3060 SWIG_TypeClientData(SWIGTYPE_p_wxPalette, obj);
3061 Py_INCREF(obj);
3062 return Py_BuildValue((char *)"");
3063 }
3064 static PyObject *_wrap_new_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3065 PyObject *resultobj;
3066 wxColour *arg1 = 0 ;
3067 int arg2 = (int) 1 ;
3068 int arg3 = (int) wxSOLID ;
3069 wxPen *result;
3070 wxColour temp1 ;
3071 PyObject * obj0 = 0 ;
3072 PyObject * obj1 = 0 ;
3073 PyObject * obj2 = 0 ;
3074 char *kwnames[] = {
3075 (char *) "colour",(char *) "width",(char *) "style", NULL
3076 };
3077
3078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Pen",kwnames,&obj0,&obj1,&obj2)) goto fail;
3079 {
3080 arg1 = &temp1;
3081 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3082 }
3083 if (obj1) {
3084 {
3085 arg2 = (int)(SWIG_As_int(obj1));
3086 if (SWIG_arg_fail(2)) SWIG_fail;
3087 }
3088 }
3089 if (obj2) {
3090 {
3091 arg3 = (int)(SWIG_As_int(obj2));
3092 if (SWIG_arg_fail(3)) SWIG_fail;
3093 }
3094 }
3095 {
3096 if (!wxPyCheckForApp()) SWIG_fail;
3097 PyThreadState* __tstate = wxPyBeginAllowThreads();
3098 result = (wxPen *)new wxPen(*arg1,arg2,arg3);
3099
3100 wxPyEndAllowThreads(__tstate);
3101 if (PyErr_Occurred()) SWIG_fail;
3102 }
3103 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 1);
3104 return resultobj;
3105 fail:
3106 return NULL;
3107 }
3108
3109
3110 static PyObject *_wrap_delete_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3111 PyObject *resultobj;
3112 wxPen *arg1 = (wxPen *) 0 ;
3113 PyObject * obj0 = 0 ;
3114 char *kwnames[] = {
3115 (char *) "self", NULL
3116 };
3117
3118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Pen",kwnames,&obj0)) goto fail;
3119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3120 if (SWIG_arg_fail(1)) SWIG_fail;
3121 {
3122 PyThreadState* __tstate = wxPyBeginAllowThreads();
3123 delete arg1;
3124
3125 wxPyEndAllowThreads(__tstate);
3126 if (PyErr_Occurred()) SWIG_fail;
3127 }
3128 Py_INCREF(Py_None); resultobj = Py_None;
3129 return resultobj;
3130 fail:
3131 return NULL;
3132 }
3133
3134
3135 static PyObject *_wrap_Pen_GetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3136 PyObject *resultobj;
3137 wxPen *arg1 = (wxPen *) 0 ;
3138 int result;
3139 PyObject * obj0 = 0 ;
3140 char *kwnames[] = {
3141 (char *) "self", NULL
3142 };
3143
3144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetCap",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 = (int)(arg1)->GetCap();
3150
3151 wxPyEndAllowThreads(__tstate);
3152 if (PyErr_Occurred()) SWIG_fail;
3153 }
3154 {
3155 resultobj = SWIG_From_int((int)(result));
3156 }
3157 return resultobj;
3158 fail:
3159 return NULL;
3160 }
3161
3162
3163 static PyObject *_wrap_Pen_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3164 PyObject *resultobj;
3165 wxPen *arg1 = (wxPen *) 0 ;
3166 wxColour result;
3167 PyObject * obj0 = 0 ;
3168 char *kwnames[] = {
3169 (char *) "self", NULL
3170 };
3171
3172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetColour",kwnames,&obj0)) goto fail;
3173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3174 if (SWIG_arg_fail(1)) SWIG_fail;
3175 {
3176 PyThreadState* __tstate = wxPyBeginAllowThreads();
3177 result = (arg1)->GetColour();
3178
3179 wxPyEndAllowThreads(__tstate);
3180 if (PyErr_Occurred()) SWIG_fail;
3181 }
3182 {
3183 wxColour * resultptr;
3184 resultptr = new wxColour((wxColour &)(result));
3185 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3186 }
3187 return resultobj;
3188 fail:
3189 return NULL;
3190 }
3191
3192
3193 static PyObject *_wrap_Pen_GetJoin(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_GetJoin",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)->GetJoin();
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_GetStyle(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_GetStyle",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)->GetStyle();
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_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3250 PyObject *resultobj;
3251 wxPen *arg1 = (wxPen *) 0 ;
3252 int result;
3253 PyObject * obj0 = 0 ;
3254 char *kwnames[] = {
3255 (char *) "self", NULL
3256 };
3257
3258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetWidth",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 = (int)(arg1)->GetWidth();
3264
3265 wxPyEndAllowThreads(__tstate);
3266 if (PyErr_Occurred()) SWIG_fail;
3267 }
3268 {
3269 resultobj = SWIG_From_int((int)(result));
3270 }
3271 return resultobj;
3272 fail:
3273 return NULL;
3274 }
3275
3276
3277 static PyObject *_wrap_Pen_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3278 PyObject *resultobj;
3279 wxPen *arg1 = (wxPen *) 0 ;
3280 bool result;
3281 PyObject * obj0 = 0 ;
3282 char *kwnames[] = {
3283 (char *) "self", NULL
3284 };
3285
3286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_Ok",kwnames,&obj0)) goto fail;
3287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3288 if (SWIG_arg_fail(1)) SWIG_fail;
3289 {
3290 PyThreadState* __tstate = wxPyBeginAllowThreads();
3291 result = (bool)(arg1)->Ok();
3292
3293 wxPyEndAllowThreads(__tstate);
3294 if (PyErr_Occurred()) SWIG_fail;
3295 }
3296 {
3297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3298 }
3299 return resultobj;
3300 fail:
3301 return NULL;
3302 }
3303
3304
3305 static PyObject *_wrap_Pen_SetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3306 PyObject *resultobj;
3307 wxPen *arg1 = (wxPen *) 0 ;
3308 int arg2 ;
3309 PyObject * obj0 = 0 ;
3310 PyObject * obj1 = 0 ;
3311 char *kwnames[] = {
3312 (char *) "self",(char *) "cap_style", NULL
3313 };
3314
3315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetCap",kwnames,&obj0,&obj1)) goto fail;
3316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3317 if (SWIG_arg_fail(1)) SWIG_fail;
3318 {
3319 arg2 = (int)(SWIG_As_int(obj1));
3320 if (SWIG_arg_fail(2)) SWIG_fail;
3321 }
3322 {
3323 PyThreadState* __tstate = wxPyBeginAllowThreads();
3324 (arg1)->SetCap(arg2);
3325
3326 wxPyEndAllowThreads(__tstate);
3327 if (PyErr_Occurred()) SWIG_fail;
3328 }
3329 Py_INCREF(Py_None); resultobj = Py_None;
3330 return resultobj;
3331 fail:
3332 return NULL;
3333 }
3334
3335
3336 static PyObject *_wrap_Pen_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3337 PyObject *resultobj;
3338 wxPen *arg1 = (wxPen *) 0 ;
3339 wxColour *arg2 = 0 ;
3340 wxColour temp2 ;
3341 PyObject * obj0 = 0 ;
3342 PyObject * obj1 = 0 ;
3343 char *kwnames[] = {
3344 (char *) "self",(char *) "colour", NULL
3345 };
3346
3347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetColour",kwnames,&obj0,&obj1)) goto fail;
3348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3349 if (SWIG_arg_fail(1)) SWIG_fail;
3350 {
3351 arg2 = &temp2;
3352 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3353 }
3354 {
3355 PyThreadState* __tstate = wxPyBeginAllowThreads();
3356 (arg1)->SetColour(*arg2);
3357
3358 wxPyEndAllowThreads(__tstate);
3359 if (PyErr_Occurred()) SWIG_fail;
3360 }
3361 Py_INCREF(Py_None); resultobj = Py_None;
3362 return resultobj;
3363 fail:
3364 return NULL;
3365 }
3366
3367
3368 static PyObject *_wrap_Pen_SetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3369 PyObject *resultobj;
3370 wxPen *arg1 = (wxPen *) 0 ;
3371 int arg2 ;
3372 PyObject * obj0 = 0 ;
3373 PyObject * obj1 = 0 ;
3374 char *kwnames[] = {
3375 (char *) "self",(char *) "join_style", NULL
3376 };
3377
3378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetJoin",kwnames,&obj0,&obj1)) goto fail;
3379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3380 if (SWIG_arg_fail(1)) SWIG_fail;
3381 {
3382 arg2 = (int)(SWIG_As_int(obj1));
3383 if (SWIG_arg_fail(2)) SWIG_fail;
3384 }
3385 {
3386 PyThreadState* __tstate = wxPyBeginAllowThreads();
3387 (arg1)->SetJoin(arg2);
3388
3389 wxPyEndAllowThreads(__tstate);
3390 if (PyErr_Occurred()) SWIG_fail;
3391 }
3392 Py_INCREF(Py_None); resultobj = Py_None;
3393 return resultobj;
3394 fail:
3395 return NULL;
3396 }
3397
3398
3399 static PyObject *_wrap_Pen_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3400 PyObject *resultobj;
3401 wxPen *arg1 = (wxPen *) 0 ;
3402 int arg2 ;
3403 PyObject * obj0 = 0 ;
3404 PyObject * obj1 = 0 ;
3405 char *kwnames[] = {
3406 (char *) "self",(char *) "style", NULL
3407 };
3408
3409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3411 if (SWIG_arg_fail(1)) SWIG_fail;
3412 {
3413 arg2 = (int)(SWIG_As_int(obj1));
3414 if (SWIG_arg_fail(2)) SWIG_fail;
3415 }
3416 {
3417 PyThreadState* __tstate = wxPyBeginAllowThreads();
3418 (arg1)->SetStyle(arg2);
3419
3420 wxPyEndAllowThreads(__tstate);
3421 if (PyErr_Occurred()) SWIG_fail;
3422 }
3423 Py_INCREF(Py_None); resultobj = Py_None;
3424 return resultobj;
3425 fail:
3426 return NULL;
3427 }
3428
3429
3430 static PyObject *_wrap_Pen_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3431 PyObject *resultobj;
3432 wxPen *arg1 = (wxPen *) 0 ;
3433 int arg2 ;
3434 PyObject * obj0 = 0 ;
3435 PyObject * obj1 = 0 ;
3436 char *kwnames[] = {
3437 (char *) "self",(char *) "width", NULL
3438 };
3439
3440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3442 if (SWIG_arg_fail(1)) SWIG_fail;
3443 {
3444 arg2 = (int)(SWIG_As_int(obj1));
3445 if (SWIG_arg_fail(2)) SWIG_fail;
3446 }
3447 {
3448 PyThreadState* __tstate = wxPyBeginAllowThreads();
3449 (arg1)->SetWidth(arg2);
3450
3451 wxPyEndAllowThreads(__tstate);
3452 if (PyErr_Occurred()) SWIG_fail;
3453 }
3454 Py_INCREF(Py_None); resultobj = Py_None;
3455 return resultobj;
3456 fail:
3457 return NULL;
3458 }
3459
3460
3461 static PyObject *_wrap_Pen_SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3462 PyObject *resultobj;
3463 wxPen *arg1 = (wxPen *) 0 ;
3464 int arg2 ;
3465 wxDash *arg3 = (wxDash *) 0 ;
3466 PyObject * obj0 = 0 ;
3467 PyObject * obj1 = 0 ;
3468 char *kwnames[] = {
3469 (char *) "self",(char *) "dashes", NULL
3470 };
3471
3472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetDashes",kwnames,&obj0,&obj1)) goto fail;
3473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3474 if (SWIG_arg_fail(1)) SWIG_fail;
3475 {
3476 arg2 = PyList_Size(obj1);
3477 arg3 = (wxDash*)byte_LIST_helper(obj1);
3478 if (arg3 == NULL) SWIG_fail;
3479 }
3480 {
3481 PyThreadState* __tstate = wxPyBeginAllowThreads();
3482 (arg1)->SetDashes(arg2,arg3);
3483
3484 wxPyEndAllowThreads(__tstate);
3485 if (PyErr_Occurred()) SWIG_fail;
3486 }
3487 Py_INCREF(Py_None); resultobj = Py_None;
3488 {
3489 if (arg3) delete [] arg3;
3490 }
3491 return resultobj;
3492 fail:
3493 {
3494 if (arg3) delete [] arg3;
3495 }
3496 return NULL;
3497 }
3498
3499
3500 static PyObject *_wrap_Pen_GetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3501 PyObject *resultobj;
3502 wxPen *arg1 = (wxPen *) 0 ;
3503 PyObject *result;
3504 PyObject * obj0 = 0 ;
3505 char *kwnames[] = {
3506 (char *) "self", NULL
3507 };
3508
3509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetDashes",kwnames,&obj0)) goto fail;
3510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3511 if (SWIG_arg_fail(1)) SWIG_fail;
3512 {
3513 PyThreadState* __tstate = wxPyBeginAllowThreads();
3514 result = (PyObject *)wxPen_GetDashes(arg1);
3515
3516 wxPyEndAllowThreads(__tstate);
3517 if (PyErr_Occurred()) SWIG_fail;
3518 }
3519 resultobj = result;
3520 return resultobj;
3521 fail:
3522 return NULL;
3523 }
3524
3525
3526 static PyObject *_wrap_Pen__SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3527 PyObject *resultobj;
3528 wxPen *arg1 = (wxPen *) 0 ;
3529 PyObject *arg2 = (PyObject *) 0 ;
3530 PyObject *arg3 = (PyObject *) 0 ;
3531 PyObject * obj0 = 0 ;
3532 PyObject * obj1 = 0 ;
3533 PyObject * obj2 = 0 ;
3534 char *kwnames[] = {
3535 (char *) "self",(char *) "_self",(char *) "pyDashes", NULL
3536 };
3537
3538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Pen__SetDashes",kwnames,&obj0,&obj1,&obj2)) 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 arg2 = obj1;
3542 arg3 = obj2;
3543 {
3544 PyThreadState* __tstate = wxPyBeginAllowThreads();
3545 wxPen__SetDashes(arg1,arg2,arg3);
3546
3547 wxPyEndAllowThreads(__tstate);
3548 if (PyErr_Occurred()) SWIG_fail;
3549 }
3550 Py_INCREF(Py_None); resultobj = Py_None;
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_delete_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3667 PyObject *resultobj;
3668 wxBrush *arg1 = (wxBrush *) 0 ;
3669 PyObject * obj0 = 0 ;
3670 char *kwnames[] = {
3671 (char *) "self", NULL
3672 };
3673
3674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Brush",kwnames,&obj0)) goto fail;
3675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3676 if (SWIG_arg_fail(1)) SWIG_fail;
3677 {
3678 PyThreadState* __tstate = wxPyBeginAllowThreads();
3679 delete arg1;
3680
3681 wxPyEndAllowThreads(__tstate);
3682 if (PyErr_Occurred()) SWIG_fail;
3683 }
3684 Py_INCREF(Py_None); resultobj = Py_None;
3685 return resultobj;
3686 fail:
3687 return NULL;
3688 }
3689
3690
3691 static PyObject *_wrap_Brush_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3692 PyObject *resultobj;
3693 wxBrush *arg1 = (wxBrush *) 0 ;
3694 wxColour *arg2 = 0 ;
3695 wxColour temp2 ;
3696 PyObject * obj0 = 0 ;
3697 PyObject * obj1 = 0 ;
3698 char *kwnames[] = {
3699 (char *) "self",(char *) "col", NULL
3700 };
3701
3702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetColour",kwnames,&obj0,&obj1)) goto fail;
3703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3704 if (SWIG_arg_fail(1)) SWIG_fail;
3705 {
3706 arg2 = &temp2;
3707 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3708 }
3709 {
3710 PyThreadState* __tstate = wxPyBeginAllowThreads();
3711 (arg1)->SetColour((wxColour const &)*arg2);
3712
3713 wxPyEndAllowThreads(__tstate);
3714 if (PyErr_Occurred()) SWIG_fail;
3715 }
3716 Py_INCREF(Py_None); resultobj = Py_None;
3717 return resultobj;
3718 fail:
3719 return NULL;
3720 }
3721
3722
3723 static PyObject *_wrap_Brush_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3724 PyObject *resultobj;
3725 wxBrush *arg1 = (wxBrush *) 0 ;
3726 int arg2 ;
3727 PyObject * obj0 = 0 ;
3728 PyObject * obj1 = 0 ;
3729 char *kwnames[] = {
3730 (char *) "self",(char *) "style", NULL
3731 };
3732
3733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3735 if (SWIG_arg_fail(1)) SWIG_fail;
3736 {
3737 arg2 = (int)(SWIG_As_int(obj1));
3738 if (SWIG_arg_fail(2)) SWIG_fail;
3739 }
3740 {
3741 PyThreadState* __tstate = wxPyBeginAllowThreads();
3742 (arg1)->SetStyle(arg2);
3743
3744 wxPyEndAllowThreads(__tstate);
3745 if (PyErr_Occurred()) SWIG_fail;
3746 }
3747 Py_INCREF(Py_None); resultobj = Py_None;
3748 return resultobj;
3749 fail:
3750 return NULL;
3751 }
3752
3753
3754 static PyObject *_wrap_Brush_SetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3755 PyObject *resultobj;
3756 wxBrush *arg1 = (wxBrush *) 0 ;
3757 wxBitmap *arg2 = 0 ;
3758 PyObject * obj0 = 0 ;
3759 PyObject * obj1 = 0 ;
3760 char *kwnames[] = {
3761 (char *) "self",(char *) "stipple", NULL
3762 };
3763
3764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStipple",kwnames,&obj0,&obj1)) goto fail;
3765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3766 if (SWIG_arg_fail(1)) SWIG_fail;
3767 {
3768 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3769 if (SWIG_arg_fail(2)) SWIG_fail;
3770 if (arg2 == NULL) {
3771 SWIG_null_ref("wxBitmap");
3772 }
3773 if (SWIG_arg_fail(2)) SWIG_fail;
3774 }
3775 {
3776 PyThreadState* __tstate = wxPyBeginAllowThreads();
3777 (arg1)->SetStipple((wxBitmap const &)*arg2);
3778
3779 wxPyEndAllowThreads(__tstate);
3780 if (PyErr_Occurred()) SWIG_fail;
3781 }
3782 Py_INCREF(Py_None); resultobj = Py_None;
3783 return resultobj;
3784 fail:
3785 return NULL;
3786 }
3787
3788
3789 static PyObject *_wrap_Brush_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3790 PyObject *resultobj;
3791 wxBrush *arg1 = (wxBrush *) 0 ;
3792 wxColour result;
3793 PyObject * obj0 = 0 ;
3794 char *kwnames[] = {
3795 (char *) "self", NULL
3796 };
3797
3798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetColour",kwnames,&obj0)) goto fail;
3799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3800 if (SWIG_arg_fail(1)) SWIG_fail;
3801 {
3802 PyThreadState* __tstate = wxPyBeginAllowThreads();
3803 result = ((wxBrush const *)arg1)->GetColour();
3804
3805 wxPyEndAllowThreads(__tstate);
3806 if (PyErr_Occurred()) SWIG_fail;
3807 }
3808 {
3809 wxColour * resultptr;
3810 resultptr = new wxColour((wxColour &)(result));
3811 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3812 }
3813 return resultobj;
3814 fail:
3815 return NULL;
3816 }
3817
3818
3819 static PyObject *_wrap_Brush_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3820 PyObject *resultobj;
3821 wxBrush *arg1 = (wxBrush *) 0 ;
3822 int result;
3823 PyObject * obj0 = 0 ;
3824 char *kwnames[] = {
3825 (char *) "self", NULL
3826 };
3827
3828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStyle",kwnames,&obj0)) goto fail;
3829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3830 if (SWIG_arg_fail(1)) SWIG_fail;
3831 {
3832 PyThreadState* __tstate = wxPyBeginAllowThreads();
3833 result = (int)((wxBrush const *)arg1)->GetStyle();
3834
3835 wxPyEndAllowThreads(__tstate);
3836 if (PyErr_Occurred()) SWIG_fail;
3837 }
3838 {
3839 resultobj = SWIG_From_int((int)(result));
3840 }
3841 return resultobj;
3842 fail:
3843 return NULL;
3844 }
3845
3846
3847 static PyObject *_wrap_Brush_GetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3848 PyObject *resultobj;
3849 wxBrush *arg1 = (wxBrush *) 0 ;
3850 wxBitmap *result;
3851 PyObject * obj0 = 0 ;
3852 char *kwnames[] = {
3853 (char *) "self", NULL
3854 };
3855
3856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStipple",kwnames,&obj0)) goto fail;
3857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3858 if (SWIG_arg_fail(1)) SWIG_fail;
3859 {
3860 PyThreadState* __tstate = wxPyBeginAllowThreads();
3861 result = (wxBitmap *)((wxBrush const *)arg1)->GetStipple();
3862
3863 wxPyEndAllowThreads(__tstate);
3864 if (PyErr_Occurred()) SWIG_fail;
3865 }
3866 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 0);
3867 return resultobj;
3868 fail:
3869 return NULL;
3870 }
3871
3872
3873 static PyObject *_wrap_Brush_IsHatch(PyObject *, PyObject *args, PyObject *kwargs) {
3874 PyObject *resultobj;
3875 wxBrush *arg1 = (wxBrush *) 0 ;
3876 bool result;
3877 PyObject * obj0 = 0 ;
3878 char *kwnames[] = {
3879 (char *) "self", NULL
3880 };
3881
3882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_IsHatch",kwnames,&obj0)) goto fail;
3883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3884 if (SWIG_arg_fail(1)) SWIG_fail;
3885 {
3886 PyThreadState* __tstate = wxPyBeginAllowThreads();
3887 result = (bool)((wxBrush const *)arg1)->IsHatch();
3888
3889 wxPyEndAllowThreads(__tstate);
3890 if (PyErr_Occurred()) SWIG_fail;
3891 }
3892 {
3893 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3894 }
3895 return resultobj;
3896 fail:
3897 return NULL;
3898 }
3899
3900
3901 static PyObject *_wrap_Brush_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3902 PyObject *resultobj;
3903 wxBrush *arg1 = (wxBrush *) 0 ;
3904 bool result;
3905 PyObject * obj0 = 0 ;
3906 char *kwnames[] = {
3907 (char *) "self", NULL
3908 };
3909
3910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_Ok",kwnames,&obj0)) goto fail;
3911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3912 if (SWIG_arg_fail(1)) SWIG_fail;
3913 {
3914 PyThreadState* __tstate = wxPyBeginAllowThreads();
3915 result = (bool)(arg1)->Ok();
3916
3917 wxPyEndAllowThreads(__tstate);
3918 if (PyErr_Occurred()) SWIG_fail;
3919 }
3920 {
3921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3922 }
3923 return resultobj;
3924 fail:
3925 return NULL;
3926 }
3927
3928
3929 static PyObject *_wrap_Brush_MacGetTheme(PyObject *, PyObject *args, PyObject *kwargs) {
3930 PyObject *resultobj;
3931 wxBrush *arg1 = (wxBrush *) 0 ;
3932 short result;
3933 PyObject * obj0 = 0 ;
3934 char *kwnames[] = {
3935 (char *) "self", NULL
3936 };
3937
3938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_MacGetTheme",kwnames,&obj0)) goto fail;
3939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3940 if (SWIG_arg_fail(1)) SWIG_fail;
3941 {
3942 PyThreadState* __tstate = wxPyBeginAllowThreads();
3943 result = (short)(arg1)->MacGetTheme();
3944
3945 wxPyEndAllowThreads(__tstate);
3946 if (PyErr_Occurred()) SWIG_fail;
3947 }
3948 {
3949 resultobj = SWIG_From_short((short)(result));
3950 }
3951 return resultobj;
3952 fail:
3953 return NULL;
3954 }
3955
3956
3957 static PyObject *_wrap_Brush_MacSetTheme(PyObject *, PyObject *args, PyObject *kwargs) {
3958 PyObject *resultobj;
3959 wxBrush *arg1 = (wxBrush *) 0 ;
3960 short arg2 ;
3961 PyObject * obj0 = 0 ;
3962 PyObject * obj1 = 0 ;
3963 char *kwnames[] = {
3964 (char *) "self",(char *) "macThemeBrush", NULL
3965 };
3966
3967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_MacSetTheme",kwnames,&obj0,&obj1)) goto fail;
3968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3969 if (SWIG_arg_fail(1)) SWIG_fail;
3970 {
3971 arg2 = (short)(SWIG_As_short(obj1));
3972 if (SWIG_arg_fail(2)) SWIG_fail;
3973 }
3974 {
3975 PyThreadState* __tstate = wxPyBeginAllowThreads();
3976 (arg1)->MacSetTheme(arg2);
3977
3978 wxPyEndAllowThreads(__tstate);
3979 if (PyErr_Occurred()) SWIG_fail;
3980 }
3981 Py_INCREF(Py_None); resultobj = Py_None;
3982 return resultobj;
3983 fail:
3984 return NULL;
3985 }
3986
3987
3988 static PyObject * Brush_swigregister(PyObject *, PyObject *args) {
3989 PyObject *obj;
3990 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3991 SWIG_TypeClientData(SWIGTYPE_p_wxBrush, obj);
3992 Py_INCREF(obj);
3993 return Py_BuildValue((char *)"");
3994 }
3995 static PyObject *_wrap_new_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
3996 PyObject *resultobj;
3997 wxString *arg1 = 0 ;
3998 wxBitmapType arg2 = (wxBitmapType) wxBITMAP_TYPE_ANY ;
3999 wxBitmap *result;
4000 bool temp1 = false ;
4001 PyObject * obj0 = 0 ;
4002 PyObject * obj1 = 0 ;
4003 char *kwnames[] = {
4004 (char *) "name",(char *) "type", NULL
4005 };
4006
4007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Bitmap",kwnames,&obj0,&obj1)) goto fail;
4008 {
4009 arg1 = wxString_in_helper(obj0);
4010 if (arg1 == NULL) SWIG_fail;
4011 temp1 = true;
4012 }
4013 if (obj1) {
4014 {
4015 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
4016 if (SWIG_arg_fail(2)) SWIG_fail;
4017 }
4018 }
4019 {
4020 if (!wxPyCheckForApp()) SWIG_fail;
4021 PyThreadState* __tstate = wxPyBeginAllowThreads();
4022 result = (wxBitmap *)new wxBitmap((wxString const &)*arg1,(wxBitmapType )arg2);
4023
4024 wxPyEndAllowThreads(__tstate);
4025 if (PyErr_Occurred()) SWIG_fail;
4026 }
4027 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4028 {
4029 if (temp1)
4030 delete arg1;
4031 }
4032 return resultobj;
4033 fail:
4034 {
4035 if (temp1)
4036 delete arg1;
4037 }
4038 return NULL;
4039 }
4040
4041
4042 static PyObject *_wrap_delete_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4043 PyObject *resultobj;
4044 wxBitmap *arg1 = (wxBitmap *) 0 ;
4045 PyObject * obj0 = 0 ;
4046 char *kwnames[] = {
4047 (char *) "self", NULL
4048 };
4049
4050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Bitmap",kwnames,&obj0)) goto fail;
4051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4052 if (SWIG_arg_fail(1)) SWIG_fail;
4053 {
4054 PyThreadState* __tstate = wxPyBeginAllowThreads();
4055 delete arg1;
4056
4057 wxPyEndAllowThreads(__tstate);
4058 if (PyErr_Occurred()) SWIG_fail;
4059 }
4060 Py_INCREF(Py_None); resultobj = Py_None;
4061 return resultobj;
4062 fail:
4063 return NULL;
4064 }
4065
4066
4067 static PyObject *_wrap_new_EmptyBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4068 PyObject *resultobj;
4069 int arg1 ;
4070 int arg2 ;
4071 int arg3 = (int) -1 ;
4072 wxBitmap *result;
4073 PyObject * obj0 = 0 ;
4074 PyObject * obj1 = 0 ;
4075 PyObject * obj2 = 0 ;
4076 char *kwnames[] = {
4077 (char *) "width",(char *) "height",(char *) "depth", NULL
4078 };
4079
4080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_EmptyBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
4081 {
4082 arg1 = (int)(SWIG_As_int(obj0));
4083 if (SWIG_arg_fail(1)) SWIG_fail;
4084 }
4085 {
4086 arg2 = (int)(SWIG_As_int(obj1));
4087 if (SWIG_arg_fail(2)) SWIG_fail;
4088 }
4089 if (obj2) {
4090 {
4091 arg3 = (int)(SWIG_As_int(obj2));
4092 if (SWIG_arg_fail(3)) SWIG_fail;
4093 }
4094 }
4095 {
4096 if (!wxPyCheckForApp()) SWIG_fail;
4097 PyThreadState* __tstate = wxPyBeginAllowThreads();
4098 result = (wxBitmap *)new wxBitmap(arg1,arg2,arg3);
4099
4100 wxPyEndAllowThreads(__tstate);
4101 if (PyErr_Occurred()) SWIG_fail;
4102 }
4103 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4104 return resultobj;
4105 fail:
4106 return NULL;
4107 }
4108
4109
4110 static PyObject *_wrap_new_BitmapFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4111 PyObject *resultobj;
4112 wxIcon *arg1 = 0 ;
4113 wxBitmap *result;
4114 PyObject * obj0 = 0 ;
4115 char *kwnames[] = {
4116 (char *) "icon", NULL
4117 };
4118
4119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromIcon",kwnames,&obj0)) goto fail;
4120 {
4121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4122 if (SWIG_arg_fail(1)) SWIG_fail;
4123 if (arg1 == NULL) {
4124 SWIG_null_ref("wxIcon");
4125 }
4126 if (SWIG_arg_fail(1)) SWIG_fail;
4127 }
4128 {
4129 if (!wxPyCheckForApp()) SWIG_fail;
4130 PyThreadState* __tstate = wxPyBeginAllowThreads();
4131 result = (wxBitmap *)new wxBitmap((wxIcon const &)*arg1);
4132
4133 wxPyEndAllowThreads(__tstate);
4134 if (PyErr_Occurred()) SWIG_fail;
4135 }
4136 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4137 return resultobj;
4138 fail:
4139 return NULL;
4140 }
4141
4142
4143 static PyObject *_wrap_new_BitmapFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
4144 PyObject *resultobj;
4145 wxImage *arg1 = 0 ;
4146 int arg2 = (int) -1 ;
4147 wxBitmap *result;
4148 PyObject * obj0 = 0 ;
4149 PyObject * obj1 = 0 ;
4150 char *kwnames[] = {
4151 (char *) "image",(char *) "depth", NULL
4152 };
4153
4154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BitmapFromImage",kwnames,&obj0,&obj1)) goto fail;
4155 {
4156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
4157 if (SWIG_arg_fail(1)) SWIG_fail;
4158 if (arg1 == NULL) {
4159 SWIG_null_ref("wxImage");
4160 }
4161 if (SWIG_arg_fail(1)) SWIG_fail;
4162 }
4163 if (obj1) {
4164 {
4165 arg2 = (int)(SWIG_As_int(obj1));
4166 if (SWIG_arg_fail(2)) SWIG_fail;
4167 }
4168 }
4169 {
4170 if (!wxPyCheckForApp()) SWIG_fail;
4171 PyThreadState* __tstate = wxPyBeginAllowThreads();
4172 result = (wxBitmap *)new wxBitmap((wxImage const &)*arg1,arg2);
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_BitmapFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
4185 PyObject *resultobj;
4186 PyObject *arg1 = (PyObject *) 0 ;
4187 wxBitmap *result;
4188 PyObject * obj0 = 0 ;
4189 char *kwnames[] = {
4190 (char *) "listOfStrings", NULL
4191 };
4192
4193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromXPMData",kwnames,&obj0)) goto fail;
4194 arg1 = obj0;
4195 {
4196 if (!wxPyCheckForApp()) SWIG_fail;
4197 PyThreadState* __tstate = wxPyBeginAllowThreads();
4198 result = (wxBitmap *)new_wxBitmap(arg1);
4199
4200 wxPyEndAllowThreads(__tstate);
4201 if (PyErr_Occurred()) SWIG_fail;
4202 }
4203 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4204 return resultobj;
4205 fail:
4206 return NULL;
4207 }
4208
4209
4210 static PyObject *_wrap_new_BitmapFromBits(PyObject *, PyObject *args, PyObject *kwargs) {
4211 PyObject *resultobj;
4212 PyObject *arg1 = (PyObject *) 0 ;
4213 int arg2 ;
4214 int arg3 ;
4215 int arg4 = (int) 1 ;
4216 wxBitmap *result;
4217 PyObject * obj0 = 0 ;
4218 PyObject * obj1 = 0 ;
4219 PyObject * obj2 = 0 ;
4220 PyObject * obj3 = 0 ;
4221 char *kwnames[] = {
4222 (char *) "bits",(char *) "width",(char *) "height",(char *) "depth", NULL
4223 };
4224
4225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:new_BitmapFromBits",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4226 arg1 = obj0;
4227 {
4228 arg2 = (int)(SWIG_As_int(obj1));
4229 if (SWIG_arg_fail(2)) SWIG_fail;
4230 }
4231 {
4232 arg3 = (int)(SWIG_As_int(obj2));
4233 if (SWIG_arg_fail(3)) SWIG_fail;
4234 }
4235 if (obj3) {
4236 {
4237 arg4 = (int)(SWIG_As_int(obj3));
4238 if (SWIG_arg_fail(4)) SWIG_fail;
4239 }
4240 }
4241 {
4242 if (!wxPyCheckForApp()) SWIG_fail;
4243 PyThreadState* __tstate = wxPyBeginAllowThreads();
4244 result = (wxBitmap *)new_wxBitmap(arg1,arg2,arg3,arg4);
4245
4246 wxPyEndAllowThreads(__tstate);
4247 if (PyErr_Occurred()) SWIG_fail;
4248 }
4249 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4250 return resultobj;
4251 fail:
4252 return NULL;
4253 }
4254
4255
4256 static PyObject *_wrap_Bitmap_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
4257 PyObject *resultobj;
4258 wxBitmap *arg1 = (wxBitmap *) 0 ;
4259 bool result;
4260 PyObject * obj0 = 0 ;
4261 char *kwnames[] = {
4262 (char *) "self", NULL
4263 };
4264
4265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_Ok",kwnames,&obj0)) goto fail;
4266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4267 if (SWIG_arg_fail(1)) SWIG_fail;
4268 {
4269 PyThreadState* __tstate = wxPyBeginAllowThreads();
4270 result = (bool)(arg1)->Ok();
4271
4272 wxPyEndAllowThreads(__tstate);
4273 if (PyErr_Occurred()) SWIG_fail;
4274 }
4275 {
4276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4277 }
4278 return resultobj;
4279 fail:
4280 return NULL;
4281 }
4282
4283
4284 static PyObject *_wrap_Bitmap_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4285 PyObject *resultobj;
4286 wxBitmap *arg1 = (wxBitmap *) 0 ;
4287 int result;
4288 PyObject * obj0 = 0 ;
4289 char *kwnames[] = {
4290 (char *) "self", NULL
4291 };
4292
4293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetWidth",kwnames,&obj0)) goto fail;
4294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4295 if (SWIG_arg_fail(1)) SWIG_fail;
4296 {
4297 PyThreadState* __tstate = wxPyBeginAllowThreads();
4298 result = (int)(arg1)->GetWidth();
4299
4300 wxPyEndAllowThreads(__tstate);
4301 if (PyErr_Occurred()) SWIG_fail;
4302 }
4303 {
4304 resultobj = SWIG_From_int((int)(result));
4305 }
4306 return resultobj;
4307 fail:
4308 return NULL;
4309 }
4310
4311
4312 static PyObject *_wrap_Bitmap_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4313 PyObject *resultobj;
4314 wxBitmap *arg1 = (wxBitmap *) 0 ;
4315 int result;
4316 PyObject * obj0 = 0 ;
4317 char *kwnames[] = {
4318 (char *) "self", NULL
4319 };
4320
4321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetHeight",kwnames,&obj0)) goto fail;
4322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4323 if (SWIG_arg_fail(1)) SWIG_fail;
4324 {
4325 PyThreadState* __tstate = wxPyBeginAllowThreads();
4326 result = (int)(arg1)->GetHeight();
4327
4328 wxPyEndAllowThreads(__tstate);
4329 if (PyErr_Occurred()) SWIG_fail;
4330 }
4331 {
4332 resultobj = SWIG_From_int((int)(result));
4333 }
4334 return resultobj;
4335 fail:
4336 return NULL;
4337 }
4338
4339
4340 static PyObject *_wrap_Bitmap_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4341 PyObject *resultobj;
4342 wxBitmap *arg1 = (wxBitmap *) 0 ;
4343 int result;
4344 PyObject * obj0 = 0 ;
4345 char *kwnames[] = {
4346 (char *) "self", NULL
4347 };
4348
4349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetDepth",kwnames,&obj0)) goto fail;
4350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4351 if (SWIG_arg_fail(1)) SWIG_fail;
4352 {
4353 PyThreadState* __tstate = wxPyBeginAllowThreads();
4354 result = (int)(arg1)->GetDepth();
4355
4356 wxPyEndAllowThreads(__tstate);
4357 if (PyErr_Occurred()) SWIG_fail;
4358 }
4359 {
4360 resultobj = SWIG_From_int((int)(result));
4361 }
4362 return resultobj;
4363 fail:
4364 return NULL;
4365 }
4366
4367
4368 static PyObject *_wrap_Bitmap_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4369 PyObject *resultobj;
4370 wxBitmap *arg1 = (wxBitmap *) 0 ;
4371 wxSize result;
4372 PyObject * obj0 = 0 ;
4373 char *kwnames[] = {
4374 (char *) "self", NULL
4375 };
4376
4377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetSize",kwnames,&obj0)) goto fail;
4378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4379 if (SWIG_arg_fail(1)) SWIG_fail;
4380 {
4381 PyThreadState* __tstate = wxPyBeginAllowThreads();
4382 result = wxBitmap_GetSize(arg1);
4383
4384 wxPyEndAllowThreads(__tstate);
4385 if (PyErr_Occurred()) SWIG_fail;
4386 }
4387 {
4388 wxSize * resultptr;
4389 resultptr = new wxSize((wxSize &)(result));
4390 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
4391 }
4392 return resultobj;
4393 fail:
4394 return NULL;
4395 }
4396
4397
4398 static PyObject *_wrap_Bitmap_ConvertToImage(PyObject *, PyObject *args, PyObject *kwargs) {
4399 PyObject *resultobj;
4400 wxBitmap *arg1 = (wxBitmap *) 0 ;
4401 SwigValueWrapper<wxImage > result;
4402 PyObject * obj0 = 0 ;
4403 char *kwnames[] = {
4404 (char *) "self", NULL
4405 };
4406
4407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_ConvertToImage",kwnames,&obj0)) goto fail;
4408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4409 if (SWIG_arg_fail(1)) SWIG_fail;
4410 {
4411 PyThreadState* __tstate = wxPyBeginAllowThreads();
4412 result = ((wxBitmap const *)arg1)->ConvertToImage();
4413
4414 wxPyEndAllowThreads(__tstate);
4415 if (PyErr_Occurred()) SWIG_fail;
4416 }
4417 {
4418 wxImage * resultptr;
4419 resultptr = new wxImage((wxImage &)(result));
4420 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
4421 }
4422 return resultobj;
4423 fail:
4424 return NULL;
4425 }
4426
4427
4428 static PyObject *_wrap_Bitmap_GetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4429 PyObject *resultobj;
4430 wxBitmap *arg1 = (wxBitmap *) 0 ;
4431 wxMask *result;
4432 PyObject * obj0 = 0 ;
4433 char *kwnames[] = {
4434 (char *) "self", NULL
4435 };
4436
4437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetMask",kwnames,&obj0)) goto fail;
4438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4439 if (SWIG_arg_fail(1)) SWIG_fail;
4440 {
4441 PyThreadState* __tstate = wxPyBeginAllowThreads();
4442 result = (wxMask *)((wxBitmap const *)arg1)->GetMask();
4443
4444 wxPyEndAllowThreads(__tstate);
4445 if (PyErr_Occurred()) SWIG_fail;
4446 }
4447 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 0);
4448 return resultobj;
4449 fail:
4450 return NULL;
4451 }
4452
4453
4454 static PyObject *_wrap_Bitmap_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4455 PyObject *resultobj;
4456 wxBitmap *arg1 = (wxBitmap *) 0 ;
4457 wxMask *arg2 = (wxMask *) 0 ;
4458 PyObject * obj0 = 0 ;
4459 PyObject * obj1 = 0 ;
4460 char *kwnames[] = {
4461 (char *) "self",(char *) "mask", NULL
4462 };
4463
4464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMask",kwnames,&obj0,&obj1)) goto fail;
4465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4466 if (SWIG_arg_fail(1)) SWIG_fail;
4467 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMask, SWIG_POINTER_EXCEPTION | 0);
4468 if (SWIG_arg_fail(2)) SWIG_fail;
4469 {
4470 PyThreadState* __tstate = wxPyBeginAllowThreads();
4471 (arg1)->SetMask(arg2);
4472
4473 wxPyEndAllowThreads(__tstate);
4474 if (PyErr_Occurred()) SWIG_fail;
4475 }
4476 Py_INCREF(Py_None); resultobj = Py_None;
4477 return resultobj;
4478 fail:
4479 return NULL;
4480 }
4481
4482
4483 static PyObject *_wrap_Bitmap_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
4484 PyObject *resultobj;
4485 wxBitmap *arg1 = (wxBitmap *) 0 ;
4486 wxColour *arg2 = 0 ;
4487 wxColour temp2 ;
4488 PyObject * obj0 = 0 ;
4489 PyObject * obj1 = 0 ;
4490 char *kwnames[] = {
4491 (char *) "self",(char *) "colour", NULL
4492 };
4493
4494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMaskColour",kwnames,&obj0,&obj1)) goto fail;
4495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4496 if (SWIG_arg_fail(1)) SWIG_fail;
4497 {
4498 arg2 = &temp2;
4499 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4500 }
4501 {
4502 PyThreadState* __tstate = wxPyBeginAllowThreads();
4503 wxBitmap_SetMaskColour(arg1,(wxColour const &)*arg2);
4504
4505 wxPyEndAllowThreads(__tstate);
4506 if (PyErr_Occurred()) SWIG_fail;
4507 }
4508 Py_INCREF(Py_None); resultobj = Py_None;
4509 return resultobj;
4510 fail:
4511 return NULL;
4512 }
4513
4514
4515 static PyObject *_wrap_Bitmap_GetSubBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4516 PyObject *resultobj;
4517 wxBitmap *arg1 = (wxBitmap *) 0 ;
4518 wxRect *arg2 = 0 ;
4519 SwigValueWrapper<wxBitmap > result;
4520 wxRect temp2 ;
4521 PyObject * obj0 = 0 ;
4522 PyObject * obj1 = 0 ;
4523 char *kwnames[] = {
4524 (char *) "self",(char *) "rect", NULL
4525 };
4526
4527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_GetSubBitmap",kwnames,&obj0,&obj1)) goto fail;
4528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4529 if (SWIG_arg_fail(1)) SWIG_fail;
4530 {
4531 arg2 = &temp2;
4532 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4533 }
4534 {
4535 PyThreadState* __tstate = wxPyBeginAllowThreads();
4536 result = ((wxBitmap const *)arg1)->GetSubBitmap((wxRect const &)*arg2);
4537
4538 wxPyEndAllowThreads(__tstate);
4539 if (PyErr_Occurred()) SWIG_fail;
4540 }
4541 {
4542 wxBitmap * resultptr;
4543 resultptr = new wxBitmap((wxBitmap &)(result));
4544 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
4545 }
4546 return resultobj;
4547 fail:
4548 return NULL;
4549 }
4550
4551
4552 static PyObject *_wrap_Bitmap_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
4553 PyObject *resultobj;
4554 wxBitmap *arg1 = (wxBitmap *) 0 ;
4555 wxString *arg2 = 0 ;
4556 wxBitmapType arg3 ;
4557 wxPalette *arg4 = (wxPalette *) NULL ;
4558 bool result;
4559 bool temp2 = false ;
4560 PyObject * obj0 = 0 ;
4561 PyObject * obj1 = 0 ;
4562 PyObject * obj2 = 0 ;
4563 PyObject * obj3 = 0 ;
4564 char *kwnames[] = {
4565 (char *) "self",(char *) "name",(char *) "type",(char *) "palette", NULL
4566 };
4567
4568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Bitmap_SaveFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4570 if (SWIG_arg_fail(1)) SWIG_fail;
4571 {
4572 arg2 = wxString_in_helper(obj1);
4573 if (arg2 == NULL) SWIG_fail;
4574 temp2 = true;
4575 }
4576 {
4577 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4578 if (SWIG_arg_fail(3)) SWIG_fail;
4579 }
4580 if (obj3) {
4581 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
4582 if (SWIG_arg_fail(4)) SWIG_fail;
4583 }
4584 {
4585 PyThreadState* __tstate = wxPyBeginAllowThreads();
4586 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxBitmapType )arg3,arg4);
4587
4588 wxPyEndAllowThreads(__tstate);
4589 if (PyErr_Occurred()) SWIG_fail;
4590 }
4591 {
4592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4593 }
4594 {
4595 if (temp2)
4596 delete arg2;
4597 }
4598 return resultobj;
4599 fail:
4600 {
4601 if (temp2)
4602 delete arg2;
4603 }
4604 return NULL;
4605 }
4606
4607
4608 static PyObject *_wrap_Bitmap_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
4609 PyObject *resultobj;
4610 wxBitmap *arg1 = (wxBitmap *) 0 ;
4611 wxString *arg2 = 0 ;
4612 wxBitmapType arg3 ;
4613 bool result;
4614 bool temp2 = false ;
4615 PyObject * obj0 = 0 ;
4616 PyObject * obj1 = 0 ;
4617 PyObject * obj2 = 0 ;
4618 char *kwnames[] = {
4619 (char *) "self",(char *) "name",(char *) "type", NULL
4620 };
4621
4622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Bitmap_LoadFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
4623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4624 if (SWIG_arg_fail(1)) SWIG_fail;
4625 {
4626 arg2 = wxString_in_helper(obj1);
4627 if (arg2 == NULL) SWIG_fail;
4628 temp2 = true;
4629 }
4630 {
4631 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4632 if (SWIG_arg_fail(3)) SWIG_fail;
4633 }
4634 {
4635 PyThreadState* __tstate = wxPyBeginAllowThreads();
4636 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxBitmapType )arg3);
4637
4638 wxPyEndAllowThreads(__tstate);
4639 if (PyErr_Occurred()) SWIG_fail;
4640 }
4641 {
4642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4643 }
4644 {
4645 if (temp2)
4646 delete arg2;
4647 }
4648 return resultobj;
4649 fail:
4650 {
4651 if (temp2)
4652 delete arg2;
4653 }
4654 return NULL;
4655 }
4656
4657
4658 static PyObject *_wrap_Bitmap_GetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
4659 PyObject *resultobj;
4660 wxBitmap *arg1 = (wxBitmap *) 0 ;
4661 wxPalette *result;
4662 PyObject * obj0 = 0 ;
4663 char *kwnames[] = {
4664 (char *) "self", NULL
4665 };
4666
4667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetPalette",kwnames,&obj0)) goto fail;
4668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4669 if (SWIG_arg_fail(1)) SWIG_fail;
4670 {
4671 PyThreadState* __tstate = wxPyBeginAllowThreads();
4672 result = (wxPalette *)((wxBitmap const *)arg1)->GetPalette();
4673
4674 wxPyEndAllowThreads(__tstate);
4675 if (PyErr_Occurred()) SWIG_fail;
4676 }
4677 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 0);
4678 return resultobj;
4679 fail:
4680 return NULL;
4681 }
4682
4683
4684 static PyObject *_wrap_Bitmap_CopyFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4685 PyObject *resultobj;
4686 wxBitmap *arg1 = (wxBitmap *) 0 ;
4687 wxIcon *arg2 = 0 ;
4688 bool result;
4689 PyObject * obj0 = 0 ;
4690 PyObject * obj1 = 0 ;
4691 char *kwnames[] = {
4692 (char *) "self",(char *) "icon", NULL
4693 };
4694
4695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_CopyFromIcon",kwnames,&obj0,&obj1)) goto fail;
4696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4697 if (SWIG_arg_fail(1)) SWIG_fail;
4698 {
4699 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4700 if (SWIG_arg_fail(2)) SWIG_fail;
4701 if (arg2 == NULL) {
4702 SWIG_null_ref("wxIcon");
4703 }
4704 if (SWIG_arg_fail(2)) SWIG_fail;
4705 }
4706 {
4707 PyThreadState* __tstate = wxPyBeginAllowThreads();
4708 result = (bool)(arg1)->CopyFromIcon((wxIcon const &)*arg2);
4709
4710 wxPyEndAllowThreads(__tstate);
4711 if (PyErr_Occurred()) SWIG_fail;
4712 }
4713 {
4714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4715 }
4716 return resultobj;
4717 fail:
4718 return NULL;
4719 }
4720
4721
4722 static PyObject *_wrap_Bitmap_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4723 PyObject *resultobj;
4724 wxBitmap *arg1 = (wxBitmap *) 0 ;
4725 int arg2 ;
4726 PyObject * obj0 = 0 ;
4727 PyObject * obj1 = 0 ;
4728 char *kwnames[] = {
4729 (char *) "self",(char *) "height", NULL
4730 };
4731
4732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetHeight",kwnames,&obj0,&obj1)) goto fail;
4733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4734 if (SWIG_arg_fail(1)) SWIG_fail;
4735 {
4736 arg2 = (int)(SWIG_As_int(obj1));
4737 if (SWIG_arg_fail(2)) SWIG_fail;
4738 }
4739 {
4740 PyThreadState* __tstate = wxPyBeginAllowThreads();
4741 (arg1)->SetHeight(arg2);
4742
4743 wxPyEndAllowThreads(__tstate);
4744 if (PyErr_Occurred()) SWIG_fail;
4745 }
4746 Py_INCREF(Py_None); resultobj = Py_None;
4747 return resultobj;
4748 fail:
4749 return NULL;
4750 }
4751
4752
4753 static PyObject *_wrap_Bitmap_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4754 PyObject *resultobj;
4755 wxBitmap *arg1 = (wxBitmap *) 0 ;
4756 int arg2 ;
4757 PyObject * obj0 = 0 ;
4758 PyObject * obj1 = 0 ;
4759 char *kwnames[] = {
4760 (char *) "self",(char *) "width", NULL
4761 };
4762
4763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetWidth",kwnames,&obj0,&obj1)) goto fail;
4764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4765 if (SWIG_arg_fail(1)) SWIG_fail;
4766 {
4767 arg2 = (int)(SWIG_As_int(obj1));
4768 if (SWIG_arg_fail(2)) SWIG_fail;
4769 }
4770 {
4771 PyThreadState* __tstate = wxPyBeginAllowThreads();
4772 (arg1)->SetWidth(arg2);
4773
4774 wxPyEndAllowThreads(__tstate);
4775 if (PyErr_Occurred()) SWIG_fail;
4776 }
4777 Py_INCREF(Py_None); resultobj = Py_None;
4778 return resultobj;
4779 fail:
4780 return NULL;
4781 }
4782
4783
4784 static PyObject *_wrap_Bitmap_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4785 PyObject *resultobj;
4786 wxBitmap *arg1 = (wxBitmap *) 0 ;
4787 int arg2 ;
4788 PyObject * obj0 = 0 ;
4789 PyObject * obj1 = 0 ;
4790 char *kwnames[] = {
4791 (char *) "self",(char *) "depth", NULL
4792 };
4793
4794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetDepth",kwnames,&obj0,&obj1)) goto fail;
4795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4796 if (SWIG_arg_fail(1)) SWIG_fail;
4797 {
4798 arg2 = (int)(SWIG_As_int(obj1));
4799 if (SWIG_arg_fail(2)) SWIG_fail;
4800 }
4801 {
4802 PyThreadState* __tstate = wxPyBeginAllowThreads();
4803 (arg1)->SetDepth(arg2);
4804
4805 wxPyEndAllowThreads(__tstate);
4806 if (PyErr_Occurred()) SWIG_fail;
4807 }
4808 Py_INCREF(Py_None); resultobj = Py_None;
4809 return resultobj;
4810 fail:
4811 return NULL;
4812 }
4813
4814
4815 static PyObject *_wrap_Bitmap_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4816 PyObject *resultobj;
4817 wxBitmap *arg1 = (wxBitmap *) 0 ;
4818 wxSize *arg2 = 0 ;
4819 wxSize temp2 ;
4820 PyObject * obj0 = 0 ;
4821 PyObject * obj1 = 0 ;
4822 char *kwnames[] = {
4823 (char *) "self",(char *) "size", NULL
4824 };
4825
4826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetSize",kwnames,&obj0,&obj1)) goto fail;
4827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4828 if (SWIG_arg_fail(1)) SWIG_fail;
4829 {
4830 arg2 = &temp2;
4831 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4832 }
4833 {
4834 PyThreadState* __tstate = wxPyBeginAllowThreads();
4835 wxBitmap_SetSize(arg1,(wxSize const &)*arg2);
4836
4837 wxPyEndAllowThreads(__tstate);
4838 if (PyErr_Occurred()) SWIG_fail;
4839 }
4840 Py_INCREF(Py_None); resultobj = Py_None;
4841 return resultobj;
4842 fail:
4843 return NULL;
4844 }
4845
4846
4847 static PyObject *_wrap_Bitmap___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4848 PyObject *resultobj;
4849 wxBitmap *arg1 = (wxBitmap *) 0 ;
4850 wxBitmap *arg2 = (wxBitmap *) 0 ;
4851 bool result;
4852 PyObject * obj0 = 0 ;
4853 PyObject * obj1 = 0 ;
4854 char *kwnames[] = {
4855 (char *) "self",(char *) "other", NULL
4856 };
4857
4858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___eq__",kwnames,&obj0,&obj1)) goto fail;
4859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4860 if (SWIG_arg_fail(1)) SWIG_fail;
4861 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4862 if (SWIG_arg_fail(2)) SWIG_fail;
4863 {
4864 PyThreadState* __tstate = wxPyBeginAllowThreads();
4865 result = (bool)wxBitmap___eq__(arg1,(wxBitmap const *)arg2);
4866
4867 wxPyEndAllowThreads(__tstate);
4868 if (PyErr_Occurred()) SWIG_fail;
4869 }
4870 {
4871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4872 }
4873 return resultobj;
4874 fail:
4875 return NULL;
4876 }
4877
4878
4879 static PyObject *_wrap_Bitmap___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4880 PyObject *resultobj;
4881 wxBitmap *arg1 = (wxBitmap *) 0 ;
4882 wxBitmap *arg2 = (wxBitmap *) 0 ;
4883 bool result;
4884 PyObject * obj0 = 0 ;
4885 PyObject * obj1 = 0 ;
4886 char *kwnames[] = {
4887 (char *) "self",(char *) "other", NULL
4888 };
4889
4890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___ne__",kwnames,&obj0,&obj1)) goto fail;
4891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4892 if (SWIG_arg_fail(1)) SWIG_fail;
4893 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4894 if (SWIG_arg_fail(2)) SWIG_fail;
4895 {
4896 PyThreadState* __tstate = wxPyBeginAllowThreads();
4897 result = (bool)wxBitmap___ne__(arg1,(wxBitmap const *)arg2);
4898
4899 wxPyEndAllowThreads(__tstate);
4900 if (PyErr_Occurred()) SWIG_fail;
4901 }
4902 {
4903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4904 }
4905 return resultobj;
4906 fail:
4907 return NULL;
4908 }
4909
4910
4911 static PyObject * Bitmap_swigregister(PyObject *, PyObject *args) {
4912 PyObject *obj;
4913 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4914 SWIG_TypeClientData(SWIGTYPE_p_wxBitmap, obj);
4915 Py_INCREF(obj);
4916 return Py_BuildValue((char *)"");
4917 }
4918 static PyObject *_wrap_new_Mask(PyObject *, PyObject *args, PyObject *kwargs) {
4919 PyObject *resultobj;
4920 wxBitmap *arg1 = 0 ;
4921 wxColour const &arg2_defvalue = wxNullColour ;
4922 wxColour *arg2 = (wxColour *) &arg2_defvalue ;
4923 wxMask *result;
4924 wxColour temp2 ;
4925 PyObject * obj0 = 0 ;
4926 PyObject * obj1 = 0 ;
4927 char *kwnames[] = {
4928 (char *) "bitmap",(char *) "colour", NULL
4929 };
4930
4931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Mask",kwnames,&obj0,&obj1)) goto fail;
4932 {
4933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4934 if (SWIG_arg_fail(1)) SWIG_fail;
4935 if (arg1 == NULL) {
4936 SWIG_null_ref("wxBitmap");
4937 }
4938 if (SWIG_arg_fail(1)) SWIG_fail;
4939 }
4940 if (obj1) {
4941 {
4942 arg2 = &temp2;
4943 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4944 }
4945 }
4946 {
4947 if (!wxPyCheckForApp()) SWIG_fail;
4948 PyThreadState* __tstate = wxPyBeginAllowThreads();
4949 result = (wxMask *)new_wxMask((wxBitmap const &)*arg1,(wxColour const &)*arg2);
4950
4951 wxPyEndAllowThreads(__tstate);
4952 if (PyErr_Occurred()) SWIG_fail;
4953 }
4954 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 1);
4955 return resultobj;
4956 fail:
4957 return NULL;
4958 }
4959
4960
4961 static PyObject * Mask_swigregister(PyObject *, PyObject *args) {
4962 PyObject *obj;
4963 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4964 SWIG_TypeClientData(SWIGTYPE_p_wxMask, obj);
4965 Py_INCREF(obj);
4966 return Py_BuildValue((char *)"");
4967 }
4968 static PyObject *_wrap_new_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
4969 PyObject *resultobj;
4970 wxString *arg1 = 0 ;
4971 wxBitmapType arg2 ;
4972 int arg3 = (int) -1 ;
4973 int arg4 = (int) -1 ;
4974 wxIcon *result;
4975 bool temp1 = false ;
4976 PyObject * obj0 = 0 ;
4977 PyObject * obj1 = 0 ;
4978 PyObject * obj2 = 0 ;
4979 PyObject * obj3 = 0 ;
4980 char *kwnames[] = {
4981 (char *) "name",(char *) "type",(char *) "desiredWidth",(char *) "desiredHeight", NULL
4982 };
4983
4984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Icon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4985 {
4986 arg1 = wxString_in_helper(obj0);
4987 if (arg1 == NULL) SWIG_fail;
4988 temp1 = true;
4989 }
4990 {
4991 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
4992 if (SWIG_arg_fail(2)) SWIG_fail;
4993 }
4994 if (obj2) {
4995 {
4996 arg3 = (int)(SWIG_As_int(obj2));
4997 if (SWIG_arg_fail(3)) SWIG_fail;
4998 }
4999 }
5000 if (obj3) {
5001 {
5002 arg4 = (int)(SWIG_As_int(obj3));
5003 if (SWIG_arg_fail(4)) SWIG_fail;
5004 }
5005 }
5006 {
5007 if (!wxPyCheckForApp()) SWIG_fail;
5008 PyThreadState* __tstate = wxPyBeginAllowThreads();
5009 result = (wxIcon *)new wxIcon((wxString const &)*arg1,(wxBitmapType )arg2,arg3,arg4);
5010
5011 wxPyEndAllowThreads(__tstate);
5012 if (PyErr_Occurred()) SWIG_fail;
5013 }
5014 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5015 {
5016 if (temp1)
5017 delete arg1;
5018 }
5019 return resultobj;
5020 fail:
5021 {
5022 if (temp1)
5023 delete arg1;
5024 }
5025 return NULL;
5026 }
5027
5028
5029 static PyObject *_wrap_delete_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
5030 PyObject *resultobj;
5031 wxIcon *arg1 = (wxIcon *) 0 ;
5032 PyObject * obj0 = 0 ;
5033 char *kwnames[] = {
5034 (char *) "self", NULL
5035 };
5036
5037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Icon",kwnames,&obj0)) goto fail;
5038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5039 if (SWIG_arg_fail(1)) SWIG_fail;
5040 {
5041 PyThreadState* __tstate = wxPyBeginAllowThreads();
5042 delete arg1;
5043
5044 wxPyEndAllowThreads(__tstate);
5045 if (PyErr_Occurred()) SWIG_fail;
5046 }
5047 Py_INCREF(Py_None); resultobj = Py_None;
5048 return resultobj;
5049 fail:
5050 return NULL;
5051 }
5052
5053
5054 static PyObject *_wrap_new_EmptyIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5055 PyObject *resultobj;
5056 wxIcon *result;
5057 char *kwnames[] = {
5058 NULL
5059 };
5060
5061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EmptyIcon",kwnames)) goto fail;
5062 {
5063 if (!wxPyCheckForApp()) SWIG_fail;
5064 PyThreadState* __tstate = wxPyBeginAllowThreads();
5065 result = (wxIcon *)new wxIcon();
5066
5067 wxPyEndAllowThreads(__tstate);
5068 if (PyErr_Occurred()) SWIG_fail;
5069 }
5070 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5071 return resultobj;
5072 fail:
5073 return NULL;
5074 }
5075
5076
5077 static PyObject *_wrap_new_IconFromLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5078 PyObject *resultobj;
5079 wxIconLocation *arg1 = 0 ;
5080 wxIcon *result;
5081 PyObject * obj0 = 0 ;
5082 char *kwnames[] = {
5083 (char *) "loc", NULL
5084 };
5085
5086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromLocation",kwnames,&obj0)) goto fail;
5087 {
5088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5089 if (SWIG_arg_fail(1)) SWIG_fail;
5090 if (arg1 == NULL) {
5091 SWIG_null_ref("wxIconLocation");
5092 }
5093 if (SWIG_arg_fail(1)) SWIG_fail;
5094 }
5095 {
5096 if (!wxPyCheckForApp()) SWIG_fail;
5097 PyThreadState* __tstate = wxPyBeginAllowThreads();
5098 result = (wxIcon *)new wxIcon((wxIconLocation const &)*arg1);
5099
5100 wxPyEndAllowThreads(__tstate);
5101 if (PyErr_Occurred()) SWIG_fail;
5102 }
5103 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5104 return resultobj;
5105 fail:
5106 return NULL;
5107 }
5108
5109
5110 static PyObject *_wrap_new_IconFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5111 PyObject *resultobj;
5112 wxBitmap *arg1 = 0 ;
5113 wxIcon *result;
5114 PyObject * obj0 = 0 ;
5115 char *kwnames[] = {
5116 (char *) "bmp", NULL
5117 };
5118
5119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromBitmap",kwnames,&obj0)) goto fail;
5120 {
5121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5122 if (SWIG_arg_fail(1)) SWIG_fail;
5123 if (arg1 == NULL) {
5124 SWIG_null_ref("wxBitmap");
5125 }
5126 if (SWIG_arg_fail(1)) SWIG_fail;
5127 }
5128 {
5129 if (!wxPyCheckForApp()) SWIG_fail;
5130 PyThreadState* __tstate = wxPyBeginAllowThreads();
5131 result = (wxIcon *)new_wxIcon((wxBitmap const &)*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_new_IconFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
5144 PyObject *resultobj;
5145 PyObject *arg1 = (PyObject *) 0 ;
5146 wxIcon *result;
5147 PyObject * obj0 = 0 ;
5148 char *kwnames[] = {
5149 (char *) "listOfStrings", NULL
5150 };
5151
5152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromXPMData",kwnames,&obj0)) goto fail;
5153 arg1 = obj0;
5154 {
5155 if (!wxPyCheckForApp()) SWIG_fail;
5156 PyThreadState* __tstate = wxPyBeginAllowThreads();
5157 result = (wxIcon *)new_wxIcon(arg1);
5158
5159 wxPyEndAllowThreads(__tstate);
5160 if (PyErr_Occurred()) SWIG_fail;
5161 }
5162 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5163 return resultobj;
5164 fail:
5165 return NULL;
5166 }
5167
5168
5169 static PyObject *_wrap_Icon_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
5170 PyObject *resultobj;
5171 wxIcon *arg1 = (wxIcon *) 0 ;
5172 bool result;
5173 PyObject * obj0 = 0 ;
5174 char *kwnames[] = {
5175 (char *) "self", NULL
5176 };
5177
5178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_Ok",kwnames,&obj0)) goto fail;
5179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5180 if (SWIG_arg_fail(1)) SWIG_fail;
5181 {
5182 PyThreadState* __tstate = wxPyBeginAllowThreads();
5183 result = (bool)(arg1)->Ok();
5184
5185 wxPyEndAllowThreads(__tstate);
5186 if (PyErr_Occurred()) SWIG_fail;
5187 }
5188 {
5189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5190 }
5191 return resultobj;
5192 fail:
5193 return NULL;
5194 }
5195
5196
5197 static PyObject *_wrap_Icon_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5198 PyObject *resultobj;
5199 wxIcon *arg1 = (wxIcon *) 0 ;
5200 int result;
5201 PyObject * obj0 = 0 ;
5202 char *kwnames[] = {
5203 (char *) "self", NULL
5204 };
5205
5206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetWidth",kwnames,&obj0)) goto fail;
5207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5208 if (SWIG_arg_fail(1)) SWIG_fail;
5209 {
5210 PyThreadState* __tstate = wxPyBeginAllowThreads();
5211 result = (int)(arg1)->GetWidth();
5212
5213 wxPyEndAllowThreads(__tstate);
5214 if (PyErr_Occurred()) SWIG_fail;
5215 }
5216 {
5217 resultobj = SWIG_From_int((int)(result));
5218 }
5219 return resultobj;
5220 fail:
5221 return NULL;
5222 }
5223
5224
5225 static PyObject *_wrap_Icon_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5226 PyObject *resultobj;
5227 wxIcon *arg1 = (wxIcon *) 0 ;
5228 int result;
5229 PyObject * obj0 = 0 ;
5230 char *kwnames[] = {
5231 (char *) "self", NULL
5232 };
5233
5234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetHeight",kwnames,&obj0)) goto fail;
5235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5236 if (SWIG_arg_fail(1)) SWIG_fail;
5237 {
5238 PyThreadState* __tstate = wxPyBeginAllowThreads();
5239 result = (int)(arg1)->GetHeight();
5240
5241 wxPyEndAllowThreads(__tstate);
5242 if (PyErr_Occurred()) SWIG_fail;
5243 }
5244 {
5245 resultobj = SWIG_From_int((int)(result));
5246 }
5247 return resultobj;
5248 fail:
5249 return NULL;
5250 }
5251
5252
5253 static PyObject *_wrap_Icon_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5254 PyObject *resultobj;
5255 wxIcon *arg1 = (wxIcon *) 0 ;
5256 int result;
5257 PyObject * obj0 = 0 ;
5258 char *kwnames[] = {
5259 (char *) "self", NULL
5260 };
5261
5262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetDepth",kwnames,&obj0)) goto fail;
5263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5264 if (SWIG_arg_fail(1)) SWIG_fail;
5265 {
5266 PyThreadState* __tstate = wxPyBeginAllowThreads();
5267 result = (int)(arg1)->GetDepth();
5268
5269 wxPyEndAllowThreads(__tstate);
5270 if (PyErr_Occurred()) SWIG_fail;
5271 }
5272 {
5273 resultobj = SWIG_From_int((int)(result));
5274 }
5275 return resultobj;
5276 fail:
5277 return NULL;
5278 }
5279
5280
5281 static PyObject *_wrap_Icon_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5282 PyObject *resultobj;
5283 wxIcon *arg1 = (wxIcon *) 0 ;
5284 int arg2 ;
5285 PyObject * obj0 = 0 ;
5286 PyObject * obj1 = 0 ;
5287 char *kwnames[] = {
5288 (char *) "self",(char *) "w", NULL
5289 };
5290
5291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5293 if (SWIG_arg_fail(1)) SWIG_fail;
5294 {
5295 arg2 = (int)(SWIG_As_int(obj1));
5296 if (SWIG_arg_fail(2)) SWIG_fail;
5297 }
5298 {
5299 PyThreadState* __tstate = wxPyBeginAllowThreads();
5300 (arg1)->SetWidth(arg2);
5301
5302 wxPyEndAllowThreads(__tstate);
5303 if (PyErr_Occurred()) SWIG_fail;
5304 }
5305 Py_INCREF(Py_None); resultobj = Py_None;
5306 return resultobj;
5307 fail:
5308 return NULL;
5309 }
5310
5311
5312 static PyObject *_wrap_Icon_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5313 PyObject *resultobj;
5314 wxIcon *arg1 = (wxIcon *) 0 ;
5315 int arg2 ;
5316 PyObject * obj0 = 0 ;
5317 PyObject * obj1 = 0 ;
5318 char *kwnames[] = {
5319 (char *) "self",(char *) "h", NULL
5320 };
5321
5322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5324 if (SWIG_arg_fail(1)) SWIG_fail;
5325 {
5326 arg2 = (int)(SWIG_As_int(obj1));
5327 if (SWIG_arg_fail(2)) SWIG_fail;
5328 }
5329 {
5330 PyThreadState* __tstate = wxPyBeginAllowThreads();
5331 (arg1)->SetHeight(arg2);
5332
5333 wxPyEndAllowThreads(__tstate);
5334 if (PyErr_Occurred()) SWIG_fail;
5335 }
5336 Py_INCREF(Py_None); resultobj = Py_None;
5337 return resultobj;
5338 fail:
5339 return NULL;
5340 }
5341
5342
5343 static PyObject *_wrap_Icon_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5344 PyObject *resultobj;
5345 wxIcon *arg1 = (wxIcon *) 0 ;
5346 int arg2 ;
5347 PyObject * obj0 = 0 ;
5348 PyObject * obj1 = 0 ;
5349 char *kwnames[] = {
5350 (char *) "self",(char *) "d", NULL
5351 };
5352
5353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetDepth",kwnames,&obj0,&obj1)) goto fail;
5354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5355 if (SWIG_arg_fail(1)) SWIG_fail;
5356 {
5357 arg2 = (int)(SWIG_As_int(obj1));
5358 if (SWIG_arg_fail(2)) SWIG_fail;
5359 }
5360 {
5361 PyThreadState* __tstate = wxPyBeginAllowThreads();
5362 (arg1)->SetDepth(arg2);
5363
5364 wxPyEndAllowThreads(__tstate);
5365 if (PyErr_Occurred()) SWIG_fail;
5366 }
5367 Py_INCREF(Py_None); resultobj = Py_None;
5368 return resultobj;
5369 fail:
5370 return NULL;
5371 }
5372
5373
5374 static PyObject *_wrap_Icon_CopyFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5375 PyObject *resultobj;
5376 wxIcon *arg1 = (wxIcon *) 0 ;
5377 wxBitmap *arg2 = 0 ;
5378 PyObject * obj0 = 0 ;
5379 PyObject * obj1 = 0 ;
5380 char *kwnames[] = {
5381 (char *) "self",(char *) "bmp", NULL
5382 };
5383
5384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_CopyFromBitmap",kwnames,&obj0,&obj1)) goto fail;
5385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5386 if (SWIG_arg_fail(1)) SWIG_fail;
5387 {
5388 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5389 if (SWIG_arg_fail(2)) SWIG_fail;
5390 if (arg2 == NULL) {
5391 SWIG_null_ref("wxBitmap");
5392 }
5393 if (SWIG_arg_fail(2)) SWIG_fail;
5394 }
5395 {
5396 PyThreadState* __tstate = wxPyBeginAllowThreads();
5397 (arg1)->CopyFromBitmap((wxBitmap const &)*arg2);
5398
5399 wxPyEndAllowThreads(__tstate);
5400 if (PyErr_Occurred()) SWIG_fail;
5401 }
5402 Py_INCREF(Py_None); resultobj = Py_None;
5403 return resultobj;
5404 fail:
5405 return NULL;
5406 }
5407
5408
5409 static PyObject * Icon_swigregister(PyObject *, PyObject *args) {
5410 PyObject *obj;
5411 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5412 SWIG_TypeClientData(SWIGTYPE_p_wxIcon, obj);
5413 Py_INCREF(obj);
5414 return Py_BuildValue((char *)"");
5415 }
5416 static PyObject *_wrap_new_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5417 PyObject *resultobj;
5418 wxString *arg1 = (wxString *) &wxPyEmptyString ;
5419 int arg2 = (int) 0 ;
5420 wxIconLocation *result;
5421 bool temp1 = false ;
5422 PyObject * obj0 = 0 ;
5423 PyObject * obj1 = 0 ;
5424 char *kwnames[] = {
5425 (char *) "filename",(char *) "num", NULL
5426 };
5427
5428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconLocation",kwnames,&obj0,&obj1)) goto fail;
5429 if (obj0) {
5430 {
5431 arg1 = wxString_in_helper(obj0);
5432 if (arg1 == NULL) SWIG_fail;
5433 temp1 = true;
5434 }
5435 }
5436 if (obj1) {
5437 {
5438 arg2 = (int)(SWIG_As_int(obj1));
5439 if (SWIG_arg_fail(2)) SWIG_fail;
5440 }
5441 }
5442 {
5443 PyThreadState* __tstate = wxPyBeginAllowThreads();
5444 result = (wxIconLocation *)new_wxIconLocation((wxString const *)arg1,arg2);
5445
5446 wxPyEndAllowThreads(__tstate);
5447 if (PyErr_Occurred()) SWIG_fail;
5448 }
5449 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconLocation, 1);
5450 {
5451 if (temp1)
5452 delete arg1;
5453 }
5454 return resultobj;
5455 fail:
5456 {
5457 if (temp1)
5458 delete arg1;
5459 }
5460 return NULL;
5461 }
5462
5463
5464 static PyObject *_wrap_delete_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5465 PyObject *resultobj;
5466 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5467 PyObject * obj0 = 0 ;
5468 char *kwnames[] = {
5469 (char *) "self", NULL
5470 };
5471
5472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconLocation",kwnames,&obj0)) goto fail;
5473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5474 if (SWIG_arg_fail(1)) SWIG_fail;
5475 {
5476 PyThreadState* __tstate = wxPyBeginAllowThreads();
5477 delete arg1;
5478
5479 wxPyEndAllowThreads(__tstate);
5480 if (PyErr_Occurred()) SWIG_fail;
5481 }
5482 Py_INCREF(Py_None); resultobj = Py_None;
5483 return resultobj;
5484 fail:
5485 return NULL;
5486 }
5487
5488
5489 static PyObject *_wrap_IconLocation_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
5490 PyObject *resultobj;
5491 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5492 bool result;
5493 PyObject * obj0 = 0 ;
5494 char *kwnames[] = {
5495 (char *) "self", NULL
5496 };
5497
5498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_IsOk",kwnames,&obj0)) goto fail;
5499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5500 if (SWIG_arg_fail(1)) SWIG_fail;
5501 {
5502 PyThreadState* __tstate = wxPyBeginAllowThreads();
5503 result = (bool)((wxIconLocation const *)arg1)->IsOk();
5504
5505 wxPyEndAllowThreads(__tstate);
5506 if (PyErr_Occurred()) SWIG_fail;
5507 }
5508 {
5509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5510 }
5511 return resultobj;
5512 fail:
5513 return NULL;
5514 }
5515
5516
5517 static PyObject *_wrap_IconLocation_SetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5518 PyObject *resultobj;
5519 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5520 wxString *arg2 = 0 ;
5521 bool temp2 = false ;
5522 PyObject * obj0 = 0 ;
5523 PyObject * obj1 = 0 ;
5524 char *kwnames[] = {
5525 (char *) "self",(char *) "filename", NULL
5526 };
5527
5528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetFileName",kwnames,&obj0,&obj1)) goto fail;
5529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5530 if (SWIG_arg_fail(1)) SWIG_fail;
5531 {
5532 arg2 = wxString_in_helper(obj1);
5533 if (arg2 == NULL) SWIG_fail;
5534 temp2 = true;
5535 }
5536 {
5537 PyThreadState* __tstate = wxPyBeginAllowThreads();
5538 (arg1)->SetFileName((wxString const &)*arg2);
5539
5540 wxPyEndAllowThreads(__tstate);
5541 if (PyErr_Occurred()) SWIG_fail;
5542 }
5543 Py_INCREF(Py_None); resultobj = Py_None;
5544 {
5545 if (temp2)
5546 delete arg2;
5547 }
5548 return resultobj;
5549 fail:
5550 {
5551 if (temp2)
5552 delete arg2;
5553 }
5554 return NULL;
5555 }
5556
5557
5558 static PyObject *_wrap_IconLocation_GetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5559 PyObject *resultobj;
5560 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5561 wxString *result;
5562 PyObject * obj0 = 0 ;
5563 char *kwnames[] = {
5564 (char *) "self", NULL
5565 };
5566
5567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetFileName",kwnames,&obj0)) goto fail;
5568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5569 if (SWIG_arg_fail(1)) SWIG_fail;
5570 {
5571 PyThreadState* __tstate = wxPyBeginAllowThreads();
5572 {
5573 wxString const &_result_ref = ((wxIconLocation const *)arg1)->GetFileName();
5574 result = (wxString *) &_result_ref;
5575 }
5576
5577 wxPyEndAllowThreads(__tstate);
5578 if (PyErr_Occurred()) SWIG_fail;
5579 }
5580 {
5581 #if wxUSE_UNICODE
5582 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
5583 #else
5584 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
5585 #endif
5586 }
5587 return resultobj;
5588 fail:
5589 return NULL;
5590 }
5591
5592
5593 static PyObject *_wrap_IconLocation_SetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5594 PyObject *resultobj;
5595 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5596 int arg2 ;
5597 PyObject * obj0 = 0 ;
5598 PyObject * obj1 = 0 ;
5599 char *kwnames[] = {
5600 (char *) "self",(char *) "num", NULL
5601 };
5602
5603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetIndex",kwnames,&obj0,&obj1)) goto fail;
5604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5605 if (SWIG_arg_fail(1)) SWIG_fail;
5606 {
5607 arg2 = (int)(SWIG_As_int(obj1));
5608 if (SWIG_arg_fail(2)) SWIG_fail;
5609 }
5610 {
5611 PyThreadState* __tstate = wxPyBeginAllowThreads();
5612 wxIconLocation_SetIndex(arg1,arg2);
5613
5614 wxPyEndAllowThreads(__tstate);
5615 if (PyErr_Occurred()) SWIG_fail;
5616 }
5617 Py_INCREF(Py_None); resultobj = Py_None;
5618 return resultobj;
5619 fail:
5620 return NULL;
5621 }
5622
5623
5624 static PyObject *_wrap_IconLocation_GetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5625 PyObject *resultobj;
5626 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5627 int result;
5628 PyObject * obj0 = 0 ;
5629 char *kwnames[] = {
5630 (char *) "self", NULL
5631 };
5632
5633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetIndex",kwnames,&obj0)) goto fail;
5634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5635 if (SWIG_arg_fail(1)) SWIG_fail;
5636 {
5637 PyThreadState* __tstate = wxPyBeginAllowThreads();
5638 result = (int)wxIconLocation_GetIndex(arg1);
5639
5640 wxPyEndAllowThreads(__tstate);
5641 if (PyErr_Occurred()) SWIG_fail;
5642 }
5643 {
5644 resultobj = SWIG_From_int((int)(result));
5645 }
5646 return resultobj;
5647 fail:
5648 return NULL;
5649 }
5650
5651
5652 static PyObject * IconLocation_swigregister(PyObject *, PyObject *args) {
5653 PyObject *obj;
5654 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5655 SWIG_TypeClientData(SWIGTYPE_p_wxIconLocation, obj);
5656 Py_INCREF(obj);
5657 return Py_BuildValue((char *)"");
5658 }
5659 static PyObject *_wrap_new_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
5660 PyObject *resultobj;
5661 wxIconBundle *result;
5662 char *kwnames[] = {
5663 NULL
5664 };
5665
5666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IconBundle",kwnames)) goto fail;
5667 {
5668 PyThreadState* __tstate = wxPyBeginAllowThreads();
5669 result = (wxIconBundle *)new wxIconBundle();
5670
5671 wxPyEndAllowThreads(__tstate);
5672 if (PyErr_Occurred()) SWIG_fail;
5673 }
5674 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5675 return resultobj;
5676 fail:
5677 return NULL;
5678 }
5679
5680
5681 static PyObject *_wrap_new_IconBundleFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
5682 PyObject *resultobj;
5683 wxString *arg1 = 0 ;
5684 long arg2 ;
5685 wxIconBundle *result;
5686 bool temp1 = false ;
5687 PyObject * obj0 = 0 ;
5688 PyObject * obj1 = 0 ;
5689 char *kwnames[] = {
5690 (char *) "file",(char *) "type", NULL
5691 };
5692
5693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_IconBundleFromFile",kwnames,&obj0,&obj1)) goto fail;
5694 {
5695 arg1 = wxString_in_helper(obj0);
5696 if (arg1 == NULL) SWIG_fail;
5697 temp1 = true;
5698 }
5699 {
5700 arg2 = (long)(SWIG_As_long(obj1));
5701 if (SWIG_arg_fail(2)) SWIG_fail;
5702 }
5703 {
5704 PyThreadState* __tstate = wxPyBeginAllowThreads();
5705 result = (wxIconBundle *)new wxIconBundle((wxString const &)*arg1,arg2);
5706
5707 wxPyEndAllowThreads(__tstate);
5708 if (PyErr_Occurred()) SWIG_fail;
5709 }
5710 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5711 {
5712 if (temp1)
5713 delete arg1;
5714 }
5715 return resultobj;
5716 fail:
5717 {
5718 if (temp1)
5719 delete arg1;
5720 }
5721 return NULL;
5722 }
5723
5724
5725 static PyObject *_wrap_new_IconBundleFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5726 PyObject *resultobj;
5727 wxIcon *arg1 = 0 ;
5728 wxIconBundle *result;
5729 PyObject * obj0 = 0 ;
5730 char *kwnames[] = {
5731 (char *) "icon", NULL
5732 };
5733
5734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconBundleFromIcon",kwnames,&obj0)) goto fail;
5735 {
5736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5737 if (SWIG_arg_fail(1)) SWIG_fail;
5738 if (arg1 == NULL) {
5739 SWIG_null_ref("wxIcon");
5740 }
5741 if (SWIG_arg_fail(1)) SWIG_fail;
5742 }
5743 {
5744 PyThreadState* __tstate = wxPyBeginAllowThreads();
5745 result = (wxIconBundle *)new wxIconBundle((wxIcon const &)*arg1);
5746
5747 wxPyEndAllowThreads(__tstate);
5748 if (PyErr_Occurred()) SWIG_fail;
5749 }
5750 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5751 return resultobj;
5752 fail:
5753 return NULL;
5754 }
5755
5756
5757 static PyObject *_wrap_delete_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
5758 PyObject *resultobj;
5759 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5760 PyObject * obj0 = 0 ;
5761 char *kwnames[] = {
5762 (char *) "self", NULL
5763 };
5764
5765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconBundle",kwnames,&obj0)) goto fail;
5766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5767 if (SWIG_arg_fail(1)) SWIG_fail;
5768 {
5769 PyThreadState* __tstate = wxPyBeginAllowThreads();
5770 delete arg1;
5771
5772 wxPyEndAllowThreads(__tstate);
5773 if (PyErr_Occurred()) SWIG_fail;
5774 }
5775 Py_INCREF(Py_None); resultobj = Py_None;
5776 return resultobj;
5777 fail:
5778 return NULL;
5779 }
5780
5781
5782 static PyObject *_wrap_IconBundle_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5783 PyObject *resultobj;
5784 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5785 wxIcon *arg2 = 0 ;
5786 PyObject * obj0 = 0 ;
5787 PyObject * obj1 = 0 ;
5788 char *kwnames[] = {
5789 (char *) "self",(char *) "icon", NULL
5790 };
5791
5792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_AddIcon",kwnames,&obj0,&obj1)) goto fail;
5793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5794 if (SWIG_arg_fail(1)) SWIG_fail;
5795 {
5796 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5797 if (SWIG_arg_fail(2)) SWIG_fail;
5798 if (arg2 == NULL) {
5799 SWIG_null_ref("wxIcon");
5800 }
5801 if (SWIG_arg_fail(2)) SWIG_fail;
5802 }
5803 {
5804 PyThreadState* __tstate = wxPyBeginAllowThreads();
5805 (arg1)->AddIcon((wxIcon const &)*arg2);
5806
5807 wxPyEndAllowThreads(__tstate);
5808 if (PyErr_Occurred()) SWIG_fail;
5809 }
5810 Py_INCREF(Py_None); resultobj = Py_None;
5811 return resultobj;
5812 fail:
5813 return NULL;
5814 }
5815
5816
5817 static PyObject *_wrap_IconBundle_AddIconFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
5818 PyObject *resultobj;
5819 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5820 wxString *arg2 = 0 ;
5821 long arg3 ;
5822 bool temp2 = false ;
5823 PyObject * obj0 = 0 ;
5824 PyObject * obj1 = 0 ;
5825 PyObject * obj2 = 0 ;
5826 char *kwnames[] = {
5827 (char *) "self",(char *) "file",(char *) "type", NULL
5828 };
5829
5830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IconBundle_AddIconFromFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
5831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5832 if (SWIG_arg_fail(1)) SWIG_fail;
5833 {
5834 arg2 = wxString_in_helper(obj1);
5835 if (arg2 == NULL) SWIG_fail;
5836 temp2 = true;
5837 }
5838 {
5839 arg3 = (long)(SWIG_As_long(obj2));
5840 if (SWIG_arg_fail(3)) SWIG_fail;
5841 }
5842 {
5843 PyThreadState* __tstate = wxPyBeginAllowThreads();
5844 (arg1)->AddIcon((wxString const &)*arg2,arg3);
5845
5846 wxPyEndAllowThreads(__tstate);
5847 if (PyErr_Occurred()) SWIG_fail;
5848 }
5849 Py_INCREF(Py_None); resultobj = Py_None;
5850 {
5851 if (temp2)
5852 delete arg2;
5853 }
5854 return resultobj;
5855 fail:
5856 {
5857 if (temp2)
5858 delete arg2;
5859 }
5860 return NULL;
5861 }
5862
5863
5864 static PyObject *_wrap_IconBundle_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5865 PyObject *resultobj;
5866 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5867 wxSize *arg2 = 0 ;
5868 wxIcon *result;
5869 wxSize temp2 ;
5870 PyObject * obj0 = 0 ;
5871 PyObject * obj1 = 0 ;
5872 char *kwnames[] = {
5873 (char *) "self",(char *) "size", NULL
5874 };
5875
5876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_GetIcon",kwnames,&obj0,&obj1)) goto fail;
5877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5878 if (SWIG_arg_fail(1)) SWIG_fail;
5879 {
5880 arg2 = &temp2;
5881 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5882 }
5883 {
5884 PyThreadState* __tstate = wxPyBeginAllowThreads();
5885 {
5886 wxIcon const &_result_ref = ((wxIconBundle const *)arg1)->GetIcon((wxSize const &)*arg2);
5887 result = (wxIcon *) &_result_ref;
5888 }
5889
5890 wxPyEndAllowThreads(__tstate);
5891 if (PyErr_Occurred()) SWIG_fail;
5892 }
5893 {
5894 wxIcon* resultptr = new wxIcon(*result);
5895 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxIcon, 1);
5896 }
5897 return resultobj;
5898 fail:
5899 return NULL;
5900 }
5901
5902
5903 static PyObject * IconBundle_swigregister(PyObject *, PyObject *args) {
5904 PyObject *obj;
5905 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5906 SWIG_TypeClientData(SWIGTYPE_p_wxIconBundle, obj);
5907 Py_INCREF(obj);
5908 return Py_BuildValue((char *)"");
5909 }
5910 static PyObject *_wrap_new_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
5911 PyObject *resultobj;
5912 wxString *arg1 = 0 ;
5913 long arg2 ;
5914 int arg3 = (int) 0 ;
5915 int arg4 = (int) 0 ;
5916 wxCursor *result;
5917 bool temp1 = false ;
5918 PyObject * obj0 = 0 ;
5919 PyObject * obj1 = 0 ;
5920 PyObject * obj2 = 0 ;
5921 PyObject * obj3 = 0 ;
5922 char *kwnames[] = {
5923 (char *) "cursorName",(char *) "type",(char *) "hotSpotX",(char *) "hotSpotY", NULL
5924 };
5925
5926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Cursor",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5927 {
5928 arg1 = wxString_in_helper(obj0);
5929 if (arg1 == NULL) SWIG_fail;
5930 temp1 = true;
5931 }
5932 {
5933 arg2 = (long)(SWIG_As_long(obj1));
5934 if (SWIG_arg_fail(2)) SWIG_fail;
5935 }
5936 if (obj2) {
5937 {
5938 arg3 = (int)(SWIG_As_int(obj2));
5939 if (SWIG_arg_fail(3)) SWIG_fail;
5940 }
5941 }
5942 if (obj3) {
5943 {
5944 arg4 = (int)(SWIG_As_int(obj3));
5945 if (SWIG_arg_fail(4)) SWIG_fail;
5946 }
5947 }
5948 {
5949 if (!wxPyCheckForApp()) SWIG_fail;
5950 PyThreadState* __tstate = wxPyBeginAllowThreads();
5951 result = (wxCursor *)new_wxCursor((wxString const &)*arg1,arg2,arg3,arg4);
5952
5953 wxPyEndAllowThreads(__tstate);
5954 if (PyErr_Occurred()) SWIG_fail;
5955 }
5956 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
5957 {
5958 if (temp1)
5959 delete arg1;
5960 }
5961 return resultobj;
5962 fail:
5963 {
5964 if (temp1)
5965 delete arg1;
5966 }
5967 return NULL;
5968 }
5969
5970
5971 static PyObject *_wrap_delete_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
5972 PyObject *resultobj;
5973 wxCursor *arg1 = (wxCursor *) 0 ;
5974 PyObject * obj0 = 0 ;
5975 char *kwnames[] = {
5976 (char *) "self", NULL
5977 };
5978
5979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Cursor",kwnames,&obj0)) goto fail;
5980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5981 if (SWIG_arg_fail(1)) SWIG_fail;
5982 {
5983 PyThreadState* __tstate = wxPyBeginAllowThreads();
5984 delete arg1;
5985
5986 wxPyEndAllowThreads(__tstate);
5987 if (PyErr_Occurred()) SWIG_fail;
5988 }
5989 Py_INCREF(Py_None); resultobj = Py_None;
5990 return resultobj;
5991 fail:
5992 return NULL;
5993 }
5994
5995
5996 static PyObject *_wrap_new_StockCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5997 PyObject *resultobj;
5998 int arg1 ;
5999 wxCursor *result;
6000 PyObject * obj0 = 0 ;
6001 char *kwnames[] = {
6002 (char *) "id", NULL
6003 };
6004
6005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_StockCursor",kwnames,&obj0)) goto fail;
6006 {
6007 arg1 = (int)(SWIG_As_int(obj0));
6008 if (SWIG_arg_fail(1)) SWIG_fail;
6009 }
6010 {
6011 if (!wxPyCheckForApp()) SWIG_fail;
6012 PyThreadState* __tstate = wxPyBeginAllowThreads();
6013 result = (wxCursor *)new wxCursor(arg1);
6014
6015 wxPyEndAllowThreads(__tstate);
6016 if (PyErr_Occurred()) SWIG_fail;
6017 }
6018 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6019 return resultobj;
6020 fail:
6021 return NULL;
6022 }
6023
6024
6025 static PyObject *_wrap_new_CursorFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
6026 PyObject *resultobj;
6027 wxImage *arg1 = 0 ;
6028 wxCursor *result;
6029 PyObject * obj0 = 0 ;
6030 char *kwnames[] = {
6031 (char *) "image", NULL
6032 };
6033
6034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CursorFromImage",kwnames,&obj0)) goto fail;
6035 {
6036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
6037 if (SWIG_arg_fail(1)) SWIG_fail;
6038 if (arg1 == NULL) {
6039 SWIG_null_ref("wxImage");
6040 }
6041 if (SWIG_arg_fail(1)) SWIG_fail;
6042 }
6043 {
6044 if (!wxPyCheckForApp()) SWIG_fail;
6045 PyThreadState* __tstate = wxPyBeginAllowThreads();
6046 result = (wxCursor *)new wxCursor((wxImage const &)*arg1);
6047
6048 wxPyEndAllowThreads(__tstate);
6049 if (PyErr_Occurred()) SWIG_fail;
6050 }
6051 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6052 return resultobj;
6053 fail:
6054 return NULL;
6055 }
6056
6057
6058 static PyObject *_wrap_Cursor_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
6059 PyObject *resultobj;
6060 wxCursor *arg1 = (wxCursor *) 0 ;
6061 bool result;
6062 PyObject * obj0 = 0 ;
6063 char *kwnames[] = {
6064 (char *) "self", NULL
6065 };
6066
6067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_Ok",kwnames,&obj0)) goto fail;
6068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6069 if (SWIG_arg_fail(1)) SWIG_fail;
6070 {
6071 PyThreadState* __tstate = wxPyBeginAllowThreads();
6072 result = (bool)(arg1)->Ok();
6073
6074 wxPyEndAllowThreads(__tstate);
6075 if (PyErr_Occurred()) SWIG_fail;
6076 }
6077 {
6078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6079 }
6080 return resultobj;
6081 fail:
6082 return NULL;
6083 }
6084
6085
6086 static PyObject * Cursor_swigregister(PyObject *, PyObject *args) {
6087 PyObject *obj;
6088 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6089 SWIG_TypeClientData(SWIGTYPE_p_wxCursor, obj);
6090 Py_INCREF(obj);
6091 return Py_BuildValue((char *)"");
6092 }
6093 static PyObject *_wrap_new_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6094 PyObject *resultobj;
6095 int arg1 = (int) 0 ;
6096 int arg2 = (int) 0 ;
6097 int arg3 = (int) 0 ;
6098 int arg4 = (int) 0 ;
6099 wxRegion *result;
6100 PyObject * obj0 = 0 ;
6101 PyObject * obj1 = 0 ;
6102 PyObject * obj2 = 0 ;
6103 PyObject * obj3 = 0 ;
6104 char *kwnames[] = {
6105 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6106 };
6107
6108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Region",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6109 if (obj0) {
6110 {
6111 arg1 = (int)(SWIG_As_int(obj0));
6112 if (SWIG_arg_fail(1)) SWIG_fail;
6113 }
6114 }
6115 if (obj1) {
6116 {
6117 arg2 = (int)(SWIG_As_int(obj1));
6118 if (SWIG_arg_fail(2)) SWIG_fail;
6119 }
6120 }
6121 if (obj2) {
6122 {
6123 arg3 = (int)(SWIG_As_int(obj2));
6124 if (SWIG_arg_fail(3)) SWIG_fail;
6125 }
6126 }
6127 if (obj3) {
6128 {
6129 arg4 = (int)(SWIG_As_int(obj3));
6130 if (SWIG_arg_fail(4)) SWIG_fail;
6131 }
6132 }
6133 {
6134 if (!wxPyCheckForApp()) SWIG_fail;
6135 PyThreadState* __tstate = wxPyBeginAllowThreads();
6136 result = (wxRegion *)new wxRegion(arg1,arg2,arg3,arg4);
6137
6138 wxPyEndAllowThreads(__tstate);
6139 if (PyErr_Occurred()) SWIG_fail;
6140 }
6141 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6142 return resultobj;
6143 fail:
6144 return NULL;
6145 }
6146
6147
6148 static PyObject *_wrap_new_RegionFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
6149 PyObject *resultobj;
6150 wxBitmap *arg1 = 0 ;
6151 wxRegion *result;
6152 PyObject * obj0 = 0 ;
6153 char *kwnames[] = {
6154 (char *) "bmp", NULL
6155 };
6156
6157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionFromBitmap",kwnames,&obj0)) goto fail;
6158 {
6159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6160 if (SWIG_arg_fail(1)) SWIG_fail;
6161 if (arg1 == NULL) {
6162 SWIG_null_ref("wxBitmap");
6163 }
6164 if (SWIG_arg_fail(1)) SWIG_fail;
6165 }
6166 {
6167 if (!wxPyCheckForApp()) SWIG_fail;
6168 PyThreadState* __tstate = wxPyBeginAllowThreads();
6169 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1);
6170
6171 wxPyEndAllowThreads(__tstate);
6172 if (PyErr_Occurred()) SWIG_fail;
6173 }
6174 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6175 return resultobj;
6176 fail:
6177 return NULL;
6178 }
6179
6180
6181 static PyObject *_wrap_new_RegionFromBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
6182 PyObject *resultobj;
6183 wxBitmap *arg1 = 0 ;
6184 wxColour *arg2 = 0 ;
6185 int arg3 = (int) 0 ;
6186 wxRegion *result;
6187 wxColour temp2 ;
6188 PyObject * obj0 = 0 ;
6189 PyObject * obj1 = 0 ;
6190 PyObject * obj2 = 0 ;
6191 char *kwnames[] = {
6192 (char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
6193 };
6194
6195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_RegionFromBitmapColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
6196 {
6197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6198 if (SWIG_arg_fail(1)) SWIG_fail;
6199 if (arg1 == NULL) {
6200 SWIG_null_ref("wxBitmap");
6201 }
6202 if (SWIG_arg_fail(1)) SWIG_fail;
6203 }
6204 {
6205 arg2 = &temp2;
6206 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6207 }
6208 if (obj2) {
6209 {
6210 arg3 = (int)(SWIG_As_int(obj2));
6211 if (SWIG_arg_fail(3)) SWIG_fail;
6212 }
6213 }
6214 {
6215 if (!wxPyCheckForApp()) SWIG_fail;
6216 PyThreadState* __tstate = wxPyBeginAllowThreads();
6217 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1,(wxColour const &)*arg2,arg3);
6218
6219 wxPyEndAllowThreads(__tstate);
6220 if (PyErr_Occurred()) SWIG_fail;
6221 }
6222 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6223 return resultobj;
6224 fail:
6225 return NULL;
6226 }
6227
6228
6229 static PyObject *_wrap_new_RegionFromPoints(PyObject *, PyObject *args, PyObject *kwargs) {
6230 PyObject *resultobj;
6231 int arg1 ;
6232 wxPoint *arg2 = (wxPoint *) 0 ;
6233 int arg3 = (int) wxWINDING_RULE ;
6234 wxRegion *result;
6235 PyObject * obj0 = 0 ;
6236 PyObject * obj1 = 0 ;
6237 char *kwnames[] = {
6238 (char *) "points",(char *) "fillStyle", NULL
6239 };
6240
6241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_RegionFromPoints",kwnames,&obj0,&obj1)) goto fail;
6242 {
6243 arg2 = wxPoint_LIST_helper(obj0, &arg1);
6244 if (arg2 == NULL) SWIG_fail;
6245 }
6246 if (obj1) {
6247 {
6248 arg3 = (int)(SWIG_As_int(obj1));
6249 if (SWIG_arg_fail(3)) SWIG_fail;
6250 }
6251 }
6252 {
6253 if (!wxPyCheckForApp()) SWIG_fail;
6254 PyThreadState* __tstate = wxPyBeginAllowThreads();
6255 result = (wxRegion *)new wxRegion(arg1,arg2,arg3);
6256
6257 wxPyEndAllowThreads(__tstate);
6258 if (PyErr_Occurred()) SWIG_fail;
6259 }
6260 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6261 {
6262 if (arg2) delete [] arg2;
6263 }
6264 return resultobj;
6265 fail:
6266 {
6267 if (arg2) delete [] arg2;
6268 }
6269 return NULL;
6270 }
6271
6272
6273 static PyObject *_wrap_delete_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6274 PyObject *resultobj;
6275 wxRegion *arg1 = (wxRegion *) 0 ;
6276 PyObject * obj0 = 0 ;
6277 char *kwnames[] = {
6278 (char *) "self", NULL
6279 };
6280
6281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Region",kwnames,&obj0)) goto fail;
6282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6283 if (SWIG_arg_fail(1)) SWIG_fail;
6284 {
6285 PyThreadState* __tstate = wxPyBeginAllowThreads();
6286 delete arg1;
6287
6288 wxPyEndAllowThreads(__tstate);
6289 if (PyErr_Occurred()) SWIG_fail;
6290 }
6291 Py_INCREF(Py_None); resultobj = Py_None;
6292 return resultobj;
6293 fail:
6294 return NULL;
6295 }
6296
6297
6298 static PyObject *_wrap_Region_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
6299 PyObject *resultobj;
6300 wxRegion *arg1 = (wxRegion *) 0 ;
6301 PyObject * obj0 = 0 ;
6302 char *kwnames[] = {
6303 (char *) "self", NULL
6304 };
6305
6306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_Clear",kwnames,&obj0)) goto fail;
6307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6308 if (SWIG_arg_fail(1)) SWIG_fail;
6309 {
6310 PyThreadState* __tstate = wxPyBeginAllowThreads();
6311 (arg1)->Clear();
6312
6313 wxPyEndAllowThreads(__tstate);
6314 if (PyErr_Occurred()) SWIG_fail;
6315 }
6316 Py_INCREF(Py_None); resultobj = Py_None;
6317 return resultobj;
6318 fail:
6319 return NULL;
6320 }
6321
6322
6323 static PyObject *_wrap_Region_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
6324 PyObject *resultobj;
6325 wxRegion *arg1 = (wxRegion *) 0 ;
6326 int arg2 ;
6327 int arg3 ;
6328 bool result;
6329 PyObject * obj0 = 0 ;
6330 PyObject * obj1 = 0 ;
6331 PyObject * obj2 = 0 ;
6332 char *kwnames[] = {
6333 (char *) "self",(char *) "x",(char *) "y", NULL
6334 };
6335
6336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Offset",kwnames,&obj0,&obj1,&obj2)) goto fail;
6337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6338 if (SWIG_arg_fail(1)) SWIG_fail;
6339 {
6340 arg2 = (int)(SWIG_As_int(obj1));
6341 if (SWIG_arg_fail(2)) SWIG_fail;
6342 }
6343 {
6344 arg3 = (int)(SWIG_As_int(obj2));
6345 if (SWIG_arg_fail(3)) SWIG_fail;
6346 }
6347 {
6348 PyThreadState* __tstate = wxPyBeginAllowThreads();
6349 result = (bool)(arg1)->Offset(arg2,arg3);
6350
6351 wxPyEndAllowThreads(__tstate);
6352 if (PyErr_Occurred()) SWIG_fail;
6353 }
6354 {
6355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6356 }
6357 return resultobj;
6358 fail:
6359 return NULL;
6360 }
6361
6362
6363 static PyObject *_wrap_Region_Contains(PyObject *, PyObject *args, PyObject *kwargs) {
6364 PyObject *resultobj;
6365 wxRegion *arg1 = (wxRegion *) 0 ;
6366 int arg2 ;
6367 int arg3 ;
6368 wxRegionContain result;
6369 PyObject * obj0 = 0 ;
6370 PyObject * obj1 = 0 ;
6371 PyObject * obj2 = 0 ;
6372 char *kwnames[] = {
6373 (char *) "self",(char *) "x",(char *) "y", NULL
6374 };
6375
6376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Contains",kwnames,&obj0,&obj1,&obj2)) goto fail;
6377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6378 if (SWIG_arg_fail(1)) SWIG_fail;
6379 {
6380 arg2 = (int)(SWIG_As_int(obj1));
6381 if (SWIG_arg_fail(2)) SWIG_fail;
6382 }
6383 {
6384 arg3 = (int)(SWIG_As_int(obj2));
6385 if (SWIG_arg_fail(3)) SWIG_fail;
6386 }
6387 {
6388 PyThreadState* __tstate = wxPyBeginAllowThreads();
6389 result = (wxRegionContain)(arg1)->Contains(arg2,arg3);
6390
6391 wxPyEndAllowThreads(__tstate);
6392 if (PyErr_Occurred()) SWIG_fail;
6393 }
6394 resultobj = SWIG_From_int((result));
6395 return resultobj;
6396 fail:
6397 return NULL;
6398 }
6399
6400
6401 static PyObject *_wrap_Region_ContainsPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6402 PyObject *resultobj;
6403 wxRegion *arg1 = (wxRegion *) 0 ;
6404 wxPoint *arg2 = 0 ;
6405 wxRegionContain result;
6406 wxPoint temp2 ;
6407 PyObject * obj0 = 0 ;
6408 PyObject * obj1 = 0 ;
6409 char *kwnames[] = {
6410 (char *) "self",(char *) "pt", NULL
6411 };
6412
6413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsPoint",kwnames,&obj0,&obj1)) goto fail;
6414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6415 if (SWIG_arg_fail(1)) SWIG_fail;
6416 {
6417 arg2 = &temp2;
6418 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6419 }
6420 {
6421 PyThreadState* __tstate = wxPyBeginAllowThreads();
6422 result = (wxRegionContain)(arg1)->Contains((wxPoint const &)*arg2);
6423
6424 wxPyEndAllowThreads(__tstate);
6425 if (PyErr_Occurred()) SWIG_fail;
6426 }
6427 resultobj = SWIG_From_int((result));
6428 return resultobj;
6429 fail:
6430 return NULL;
6431 }
6432
6433
6434 static PyObject *_wrap_Region_ContainsRect(PyObject *, PyObject *args, PyObject *kwargs) {
6435 PyObject *resultobj;
6436 wxRegion *arg1 = (wxRegion *) 0 ;
6437 wxRect *arg2 = 0 ;
6438 wxRegionContain result;
6439 wxRect temp2 ;
6440 PyObject * obj0 = 0 ;
6441 PyObject * obj1 = 0 ;
6442 char *kwnames[] = {
6443 (char *) "self",(char *) "rect", NULL
6444 };
6445
6446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsRect",kwnames,&obj0,&obj1)) goto fail;
6447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6448 if (SWIG_arg_fail(1)) SWIG_fail;
6449 {
6450 arg2 = &temp2;
6451 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6452 }
6453 {
6454 PyThreadState* __tstate = wxPyBeginAllowThreads();
6455 result = (wxRegionContain)(arg1)->Contains((wxRect const &)*arg2);
6456
6457 wxPyEndAllowThreads(__tstate);
6458 if (PyErr_Occurred()) SWIG_fail;
6459 }
6460 resultobj = SWIG_From_int((result));
6461 return resultobj;
6462 fail:
6463 return NULL;
6464 }
6465
6466
6467 static PyObject *_wrap_Region_ContainsRectDim(PyObject *, PyObject *args, PyObject *kwargs) {
6468 PyObject *resultobj;
6469 wxRegion *arg1 = (wxRegion *) 0 ;
6470 int arg2 ;
6471 int arg3 ;
6472 int arg4 ;
6473 int arg5 ;
6474 wxRegionContain result;
6475 PyObject * obj0 = 0 ;
6476 PyObject * obj1 = 0 ;
6477 PyObject * obj2 = 0 ;
6478 PyObject * obj3 = 0 ;
6479 PyObject * obj4 = 0 ;
6480 char *kwnames[] = {
6481 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
6482 };
6483
6484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_ContainsRectDim",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6486 if (SWIG_arg_fail(1)) SWIG_fail;
6487 {
6488 arg2 = (int)(SWIG_As_int(obj1));
6489 if (SWIG_arg_fail(2)) SWIG_fail;
6490 }
6491 {
6492 arg3 = (int)(SWIG_As_int(obj2));
6493 if (SWIG_arg_fail(3)) SWIG_fail;
6494 }
6495 {
6496 arg4 = (int)(SWIG_As_int(obj3));
6497 if (SWIG_arg_fail(4)) SWIG_fail;
6498 }
6499 {
6500 arg5 = (int)(SWIG_As_int(obj4));
6501 if (SWIG_arg_fail(5)) SWIG_fail;
6502 }
6503 {
6504 PyThreadState* __tstate = wxPyBeginAllowThreads();
6505 result = (wxRegionContain)(arg1)->Contains(arg2,arg3,arg4,arg5);
6506
6507 wxPyEndAllowThreads(__tstate);
6508 if (PyErr_Occurred()) SWIG_fail;
6509 }
6510 resultobj = SWIG_From_int((result));
6511 return resultobj;
6512 fail:
6513 return NULL;
6514 }
6515
6516
6517 static PyObject *_wrap_Region_GetBox(PyObject *, PyObject *args, PyObject *kwargs) {
6518 PyObject *resultobj;
6519 wxRegion *arg1 = (wxRegion *) 0 ;
6520 wxRect result;
6521 PyObject * obj0 = 0 ;
6522 char *kwnames[] = {
6523 (char *) "self", NULL
6524 };
6525
6526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_GetBox",kwnames,&obj0)) goto fail;
6527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6528 if (SWIG_arg_fail(1)) SWIG_fail;
6529 {
6530 PyThreadState* __tstate = wxPyBeginAllowThreads();
6531 result = (arg1)->GetBox();
6532
6533 wxPyEndAllowThreads(__tstate);
6534 if (PyErr_Occurred()) SWIG_fail;
6535 }
6536 {
6537 wxRect * resultptr;
6538 resultptr = new wxRect((wxRect &)(result));
6539 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6540 }
6541 return resultobj;
6542 fail:
6543 return NULL;
6544 }
6545
6546
6547 static PyObject *_wrap_Region_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
6548 PyObject *resultobj;
6549 wxRegion *arg1 = (wxRegion *) 0 ;
6550 int arg2 ;
6551 int arg3 ;
6552 int arg4 ;
6553 int arg5 ;
6554 bool result;
6555 PyObject * obj0 = 0 ;
6556 PyObject * obj1 = 0 ;
6557 PyObject * obj2 = 0 ;
6558 PyObject * obj3 = 0 ;
6559 PyObject * obj4 = 0 ;
6560 char *kwnames[] = {
6561 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6562 };
6563
6564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Intersect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6566 if (SWIG_arg_fail(1)) SWIG_fail;
6567 {
6568 arg2 = (int)(SWIG_As_int(obj1));
6569 if (SWIG_arg_fail(2)) SWIG_fail;
6570 }
6571 {
6572 arg3 = (int)(SWIG_As_int(obj2));
6573 if (SWIG_arg_fail(3)) SWIG_fail;
6574 }
6575 {
6576 arg4 = (int)(SWIG_As_int(obj3));
6577 if (SWIG_arg_fail(4)) SWIG_fail;
6578 }
6579 {
6580 arg5 = (int)(SWIG_As_int(obj4));
6581 if (SWIG_arg_fail(5)) SWIG_fail;
6582 }
6583 {
6584 PyThreadState* __tstate = wxPyBeginAllowThreads();
6585 result = (bool)(arg1)->Intersect(arg2,arg3,arg4,arg5);
6586
6587 wxPyEndAllowThreads(__tstate);
6588 if (PyErr_Occurred()) SWIG_fail;
6589 }
6590 {
6591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6592 }
6593 return resultobj;
6594 fail:
6595 return NULL;
6596 }
6597
6598
6599 static PyObject *_wrap_Region_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6600 PyObject *resultobj;
6601 wxRegion *arg1 = (wxRegion *) 0 ;
6602 wxRect *arg2 = 0 ;
6603 bool result;
6604 wxRect temp2 ;
6605 PyObject * obj0 = 0 ;
6606 PyObject * obj1 = 0 ;
6607 char *kwnames[] = {
6608 (char *) "self",(char *) "rect", NULL
6609 };
6610
6611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6613 if (SWIG_arg_fail(1)) SWIG_fail;
6614 {
6615 arg2 = &temp2;
6616 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6617 }
6618 {
6619 PyThreadState* __tstate = wxPyBeginAllowThreads();
6620 result = (bool)(arg1)->Intersect((wxRect const &)*arg2);
6621
6622 wxPyEndAllowThreads(__tstate);
6623 if (PyErr_Occurred()) SWIG_fail;
6624 }
6625 {
6626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6627 }
6628 return resultobj;
6629 fail:
6630 return NULL;
6631 }
6632
6633
6634 static PyObject *_wrap_Region_IntersectRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6635 PyObject *resultobj;
6636 wxRegion *arg1 = (wxRegion *) 0 ;
6637 wxRegion *arg2 = 0 ;
6638 bool result;
6639 PyObject * obj0 = 0 ;
6640 PyObject * obj1 = 0 ;
6641 char *kwnames[] = {
6642 (char *) "self",(char *) "region", NULL
6643 };
6644
6645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRegion",kwnames,&obj0,&obj1)) goto fail;
6646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6647 if (SWIG_arg_fail(1)) SWIG_fail;
6648 {
6649 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6650 if (SWIG_arg_fail(2)) SWIG_fail;
6651 if (arg2 == NULL) {
6652 SWIG_null_ref("wxRegion");
6653 }
6654 if (SWIG_arg_fail(2)) SWIG_fail;
6655 }
6656 {
6657 PyThreadState* __tstate = wxPyBeginAllowThreads();
6658 result = (bool)(arg1)->Intersect((wxRegion const &)*arg2);
6659
6660 wxPyEndAllowThreads(__tstate);
6661 if (PyErr_Occurred()) SWIG_fail;
6662 }
6663 {
6664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6665 }
6666 return resultobj;
6667 fail:
6668 return NULL;
6669 }
6670
6671
6672 static PyObject *_wrap_Region_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
6673 PyObject *resultobj;
6674 wxRegion *arg1 = (wxRegion *) 0 ;
6675 bool result;
6676 PyObject * obj0 = 0 ;
6677 char *kwnames[] = {
6678 (char *) "self", NULL
6679 };
6680
6681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_IsEmpty",kwnames,&obj0)) goto fail;
6682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6683 if (SWIG_arg_fail(1)) SWIG_fail;
6684 {
6685 PyThreadState* __tstate = wxPyBeginAllowThreads();
6686 result = (bool)(arg1)->IsEmpty();
6687
6688 wxPyEndAllowThreads(__tstate);
6689 if (PyErr_Occurred()) SWIG_fail;
6690 }
6691 {
6692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6693 }
6694 return resultobj;
6695 fail:
6696 return NULL;
6697 }
6698
6699
6700 static PyObject *_wrap_Region_Union(PyObject *, PyObject *args, PyObject *kwargs) {
6701 PyObject *resultobj;
6702 wxRegion *arg1 = (wxRegion *) 0 ;
6703 int arg2 ;
6704 int arg3 ;
6705 int arg4 ;
6706 int arg5 ;
6707 bool result;
6708 PyObject * obj0 = 0 ;
6709 PyObject * obj1 = 0 ;
6710 PyObject * obj2 = 0 ;
6711 PyObject * obj3 = 0 ;
6712 PyObject * obj4 = 0 ;
6713 char *kwnames[] = {
6714 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6715 };
6716
6717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Union",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6719 if (SWIG_arg_fail(1)) SWIG_fail;
6720 {
6721 arg2 = (int)(SWIG_As_int(obj1));
6722 if (SWIG_arg_fail(2)) SWIG_fail;
6723 }
6724 {
6725 arg3 = (int)(SWIG_As_int(obj2));
6726 if (SWIG_arg_fail(3)) SWIG_fail;
6727 }
6728 {
6729 arg4 = (int)(SWIG_As_int(obj3));
6730 if (SWIG_arg_fail(4)) SWIG_fail;
6731 }
6732 {
6733 arg5 = (int)(SWIG_As_int(obj4));
6734 if (SWIG_arg_fail(5)) SWIG_fail;
6735 }
6736 {
6737 PyThreadState* __tstate = wxPyBeginAllowThreads();
6738 result = (bool)(arg1)->Union(arg2,arg3,arg4,arg5);
6739
6740 wxPyEndAllowThreads(__tstate);
6741 if (PyErr_Occurred()) SWIG_fail;
6742 }
6743 {
6744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6745 }
6746 return resultobj;
6747 fail:
6748 return NULL;
6749 }
6750
6751
6752 static PyObject *_wrap_Region_UnionRect(PyObject *, PyObject *args, PyObject *kwargs) {
6753 PyObject *resultobj;
6754 wxRegion *arg1 = (wxRegion *) 0 ;
6755 wxRect *arg2 = 0 ;
6756 bool result;
6757 wxRect temp2 ;
6758 PyObject * obj0 = 0 ;
6759 PyObject * obj1 = 0 ;
6760 char *kwnames[] = {
6761 (char *) "self",(char *) "rect", NULL
6762 };
6763
6764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRect",kwnames,&obj0,&obj1)) goto fail;
6765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6766 if (SWIG_arg_fail(1)) SWIG_fail;
6767 {
6768 arg2 = &temp2;
6769 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6770 }
6771 {
6772 PyThreadState* __tstate = wxPyBeginAllowThreads();
6773 result = (bool)(arg1)->Union((wxRect const &)*arg2);
6774
6775 wxPyEndAllowThreads(__tstate);
6776 if (PyErr_Occurred()) SWIG_fail;
6777 }
6778 {
6779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6780 }
6781 return resultobj;
6782 fail:
6783 return NULL;
6784 }
6785
6786
6787 static PyObject *_wrap_Region_UnionRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6788 PyObject *resultobj;
6789 wxRegion *arg1 = (wxRegion *) 0 ;
6790 wxRegion *arg2 = 0 ;
6791 bool result;
6792 PyObject * obj0 = 0 ;
6793 PyObject * obj1 = 0 ;
6794 char *kwnames[] = {
6795 (char *) "self",(char *) "region", NULL
6796 };
6797
6798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRegion",kwnames,&obj0,&obj1)) goto fail;
6799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6800 if (SWIG_arg_fail(1)) SWIG_fail;
6801 {
6802 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6803 if (SWIG_arg_fail(2)) SWIG_fail;
6804 if (arg2 == NULL) {
6805 SWIG_null_ref("wxRegion");
6806 }
6807 if (SWIG_arg_fail(2)) SWIG_fail;
6808 }
6809 {
6810 PyThreadState* __tstate = wxPyBeginAllowThreads();
6811 result = (bool)(arg1)->Union((wxRegion const &)*arg2);
6812
6813 wxPyEndAllowThreads(__tstate);
6814 if (PyErr_Occurred()) SWIG_fail;
6815 }
6816 {
6817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6818 }
6819 return resultobj;
6820 fail:
6821 return NULL;
6822 }
6823
6824
6825 static PyObject *_wrap_Region_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
6826 PyObject *resultobj;
6827 wxRegion *arg1 = (wxRegion *) 0 ;
6828 int arg2 ;
6829 int arg3 ;
6830 int arg4 ;
6831 int arg5 ;
6832 bool result;
6833 PyObject * obj0 = 0 ;
6834 PyObject * obj1 = 0 ;
6835 PyObject * obj2 = 0 ;
6836 PyObject * obj3 = 0 ;
6837 PyObject * obj4 = 0 ;
6838 char *kwnames[] = {
6839 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6840 };
6841
6842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Subtract",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6844 if (SWIG_arg_fail(1)) SWIG_fail;
6845 {
6846 arg2 = (int)(SWIG_As_int(obj1));
6847 if (SWIG_arg_fail(2)) SWIG_fail;
6848 }
6849 {
6850 arg3 = (int)(SWIG_As_int(obj2));
6851 if (SWIG_arg_fail(3)) SWIG_fail;
6852 }
6853 {
6854 arg4 = (int)(SWIG_As_int(obj3));
6855 if (SWIG_arg_fail(4)) SWIG_fail;
6856 }
6857 {
6858 arg5 = (int)(SWIG_As_int(obj4));
6859 if (SWIG_arg_fail(5)) SWIG_fail;
6860 }
6861 {
6862 PyThreadState* __tstate = wxPyBeginAllowThreads();
6863 result = (bool)(arg1)->Subtract(arg2,arg3,arg4,arg5);
6864
6865 wxPyEndAllowThreads(__tstate);
6866 if (PyErr_Occurred()) SWIG_fail;
6867 }
6868 {
6869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6870 }
6871 return resultobj;
6872 fail:
6873 return NULL;
6874 }
6875
6876
6877 static PyObject *_wrap_Region_SubtractRect(PyObject *, PyObject *args, PyObject *kwargs) {
6878 PyObject *resultobj;
6879 wxRegion *arg1 = (wxRegion *) 0 ;
6880 wxRect *arg2 = 0 ;
6881 bool result;
6882 wxRect temp2 ;
6883 PyObject * obj0 = 0 ;
6884 PyObject * obj1 = 0 ;
6885 char *kwnames[] = {
6886 (char *) "self",(char *) "rect", NULL
6887 };
6888
6889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRect",kwnames,&obj0,&obj1)) goto fail;
6890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6891 if (SWIG_arg_fail(1)) SWIG_fail;
6892 {
6893 arg2 = &temp2;
6894 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6895 }
6896 {
6897 PyThreadState* __tstate = wxPyBeginAllowThreads();
6898 result = (bool)(arg1)->Subtract((wxRect const &)*arg2);
6899
6900 wxPyEndAllowThreads(__tstate);
6901 if (PyErr_Occurred()) SWIG_fail;
6902 }
6903 {
6904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6905 }
6906 return resultobj;
6907 fail:
6908 return NULL;
6909 }
6910
6911
6912 static PyObject *_wrap_Region_SubtractRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6913 PyObject *resultobj;
6914 wxRegion *arg1 = (wxRegion *) 0 ;
6915 wxRegion *arg2 = 0 ;
6916 bool result;
6917 PyObject * obj0 = 0 ;
6918 PyObject * obj1 = 0 ;
6919 char *kwnames[] = {
6920 (char *) "self",(char *) "region", NULL
6921 };
6922
6923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRegion",kwnames,&obj0,&obj1)) goto fail;
6924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6925 if (SWIG_arg_fail(1)) SWIG_fail;
6926 {
6927 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6928 if (SWIG_arg_fail(2)) SWIG_fail;
6929 if (arg2 == NULL) {
6930 SWIG_null_ref("wxRegion");
6931 }
6932 if (SWIG_arg_fail(2)) SWIG_fail;
6933 }
6934 {
6935 PyThreadState* __tstate = wxPyBeginAllowThreads();
6936 result = (bool)(arg1)->Subtract((wxRegion const &)*arg2);
6937
6938 wxPyEndAllowThreads(__tstate);
6939 if (PyErr_Occurred()) SWIG_fail;
6940 }
6941 {
6942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6943 }
6944 return resultobj;
6945 fail:
6946 return NULL;
6947 }
6948
6949
6950 static PyObject *_wrap_Region_Xor(PyObject *, PyObject *args, PyObject *kwargs) {
6951 PyObject *resultobj;
6952 wxRegion *arg1 = (wxRegion *) 0 ;
6953 int arg2 ;
6954 int arg3 ;
6955 int arg4 ;
6956 int arg5 ;
6957 bool result;
6958 PyObject * obj0 = 0 ;
6959 PyObject * obj1 = 0 ;
6960 PyObject * obj2 = 0 ;
6961 PyObject * obj3 = 0 ;
6962 PyObject * obj4 = 0 ;
6963 char *kwnames[] = {
6964 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6965 };
6966
6967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Xor",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6969 if (SWIG_arg_fail(1)) SWIG_fail;
6970 {
6971 arg2 = (int)(SWIG_As_int(obj1));
6972 if (SWIG_arg_fail(2)) SWIG_fail;
6973 }
6974 {
6975 arg3 = (int)(SWIG_As_int(obj2));
6976 if (SWIG_arg_fail(3)) SWIG_fail;
6977 }
6978 {
6979 arg4 = (int)(SWIG_As_int(obj3));
6980 if (SWIG_arg_fail(4)) SWIG_fail;
6981 }
6982 {
6983 arg5 = (int)(SWIG_As_int(obj4));
6984 if (SWIG_arg_fail(5)) SWIG_fail;
6985 }
6986 {
6987 PyThreadState* __tstate = wxPyBeginAllowThreads();
6988 result = (bool)(arg1)->Xor(arg2,arg3,arg4,arg5);
6989
6990 wxPyEndAllowThreads(__tstate);
6991 if (PyErr_Occurred()) SWIG_fail;
6992 }
6993 {
6994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6995 }
6996 return resultobj;
6997 fail:
6998 return NULL;
6999 }
7000
7001
7002 static PyObject *_wrap_Region_XorRect(PyObject *, PyObject *args, PyObject *kwargs) {
7003 PyObject *resultobj;
7004 wxRegion *arg1 = (wxRegion *) 0 ;
7005 wxRect *arg2 = 0 ;
7006 bool result;
7007 wxRect temp2 ;
7008 PyObject * obj0 = 0 ;
7009 PyObject * obj1 = 0 ;
7010 char *kwnames[] = {
7011 (char *) "self",(char *) "rect", NULL
7012 };
7013
7014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRect",kwnames,&obj0,&obj1)) goto fail;
7015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7016 if (SWIG_arg_fail(1)) SWIG_fail;
7017 {
7018 arg2 = &temp2;
7019 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7020 }
7021 {
7022 PyThreadState* __tstate = wxPyBeginAllowThreads();
7023 result = (bool)(arg1)->Xor((wxRect const &)*arg2);
7024
7025 wxPyEndAllowThreads(__tstate);
7026 if (PyErr_Occurred()) SWIG_fail;
7027 }
7028 {
7029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7030 }
7031 return resultobj;
7032 fail:
7033 return NULL;
7034 }
7035
7036
7037 static PyObject *_wrap_Region_XorRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7038 PyObject *resultobj;
7039 wxRegion *arg1 = (wxRegion *) 0 ;
7040 wxRegion *arg2 = 0 ;
7041 bool result;
7042 PyObject * obj0 = 0 ;
7043 PyObject * obj1 = 0 ;
7044 char *kwnames[] = {
7045 (char *) "self",(char *) "region", NULL
7046 };
7047
7048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRegion",kwnames,&obj0,&obj1)) goto fail;
7049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7050 if (SWIG_arg_fail(1)) SWIG_fail;
7051 {
7052 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7053 if (SWIG_arg_fail(2)) SWIG_fail;
7054 if (arg2 == NULL) {
7055 SWIG_null_ref("wxRegion");
7056 }
7057 if (SWIG_arg_fail(2)) SWIG_fail;
7058 }
7059 {
7060 PyThreadState* __tstate = wxPyBeginAllowThreads();
7061 result = (bool)(arg1)->Xor((wxRegion const &)*arg2);
7062
7063 wxPyEndAllowThreads(__tstate);
7064 if (PyErr_Occurred()) SWIG_fail;
7065 }
7066 {
7067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7068 }
7069 return resultobj;
7070 fail:
7071 return NULL;
7072 }
7073
7074
7075 static PyObject *_wrap_Region_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7076 PyObject *resultobj;
7077 wxRegion *arg1 = (wxRegion *) 0 ;
7078 SwigValueWrapper<wxBitmap > result;
7079 PyObject * obj0 = 0 ;
7080 char *kwnames[] = {
7081 (char *) "self", NULL
7082 };
7083
7084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_ConvertToBitmap",kwnames,&obj0)) goto fail;
7085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7086 if (SWIG_arg_fail(1)) SWIG_fail;
7087 {
7088 PyThreadState* __tstate = wxPyBeginAllowThreads();
7089 result = (arg1)->ConvertToBitmap();
7090
7091 wxPyEndAllowThreads(__tstate);
7092 if (PyErr_Occurred()) SWIG_fail;
7093 }
7094 {
7095 wxBitmap * resultptr;
7096 resultptr = new wxBitmap((wxBitmap &)(result));
7097 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
7098 }
7099 return resultobj;
7100 fail:
7101 return NULL;
7102 }
7103
7104
7105 static PyObject *_wrap_Region_UnionBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7106 PyObject *resultobj;
7107 wxRegion *arg1 = (wxRegion *) 0 ;
7108 wxBitmap *arg2 = 0 ;
7109 bool result;
7110 PyObject * obj0 = 0 ;
7111 PyObject * obj1 = 0 ;
7112 char *kwnames[] = {
7113 (char *) "self",(char *) "bmp", NULL
7114 };
7115
7116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionBitmap",kwnames,&obj0,&obj1)) goto fail;
7117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7118 if (SWIG_arg_fail(1)) SWIG_fail;
7119 {
7120 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7121 if (SWIG_arg_fail(2)) SWIG_fail;
7122 if (arg2 == NULL) {
7123 SWIG_null_ref("wxBitmap");
7124 }
7125 if (SWIG_arg_fail(2)) SWIG_fail;
7126 }
7127 {
7128 PyThreadState* __tstate = wxPyBeginAllowThreads();
7129 result = (bool)(arg1)->Union((wxBitmap const &)*arg2);
7130
7131 wxPyEndAllowThreads(__tstate);
7132 if (PyErr_Occurred()) SWIG_fail;
7133 }
7134 {
7135 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7136 }
7137 return resultobj;
7138 fail:
7139 return NULL;
7140 }
7141
7142
7143 static PyObject *_wrap_Region_UnionBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
7144 PyObject *resultobj;
7145 wxRegion *arg1 = (wxRegion *) 0 ;
7146 wxBitmap *arg2 = 0 ;
7147 wxColour *arg3 = 0 ;
7148 int arg4 = (int) 0 ;
7149 bool result;
7150 wxColour temp3 ;
7151 PyObject * obj0 = 0 ;
7152 PyObject * obj1 = 0 ;
7153 PyObject * obj2 = 0 ;
7154 PyObject * obj3 = 0 ;
7155 char *kwnames[] = {
7156 (char *) "self",(char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
7157 };
7158
7159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Region_UnionBitmapColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7161 if (SWIG_arg_fail(1)) SWIG_fail;
7162 {
7163 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7164 if (SWIG_arg_fail(2)) SWIG_fail;
7165 if (arg2 == NULL) {
7166 SWIG_null_ref("wxBitmap");
7167 }
7168 if (SWIG_arg_fail(2)) SWIG_fail;
7169 }
7170 {
7171 arg3 = &temp3;
7172 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
7173 }
7174 if (obj3) {
7175 {
7176 arg4 = (int)(SWIG_As_int(obj3));
7177 if (SWIG_arg_fail(4)) SWIG_fail;
7178 }
7179 }
7180 {
7181 PyThreadState* __tstate = wxPyBeginAllowThreads();
7182 result = (bool)(arg1)->Union((wxBitmap const &)*arg2,(wxColour const &)*arg3,arg4);
7183
7184 wxPyEndAllowThreads(__tstate);
7185 if (PyErr_Occurred()) SWIG_fail;
7186 }
7187 {
7188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7189 }
7190 return resultobj;
7191 fail:
7192 return NULL;
7193 }
7194
7195
7196 static PyObject * Region_swigregister(PyObject *, PyObject *args) {
7197 PyObject *obj;
7198 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7199 SWIG_TypeClientData(SWIGTYPE_p_wxRegion, obj);
7200 Py_INCREF(obj);
7201 return Py_BuildValue((char *)"");
7202 }
7203 static PyObject *_wrap_new_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7204 PyObject *resultobj;
7205 wxRegion *arg1 = 0 ;
7206 wxRegionIterator *result;
7207 PyObject * obj0 = 0 ;
7208 char *kwnames[] = {
7209 (char *) "region", NULL
7210 };
7211
7212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionIterator",kwnames,&obj0)) goto fail;
7213 {
7214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7215 if (SWIG_arg_fail(1)) SWIG_fail;
7216 if (arg1 == NULL) {
7217 SWIG_null_ref("wxRegion");
7218 }
7219 if (SWIG_arg_fail(1)) SWIG_fail;
7220 }
7221 {
7222 if (!wxPyCheckForApp()) SWIG_fail;
7223 PyThreadState* __tstate = wxPyBeginAllowThreads();
7224 result = (wxRegionIterator *)new wxRegionIterator((wxRegion const &)*arg1);
7225
7226 wxPyEndAllowThreads(__tstate);
7227 if (PyErr_Occurred()) SWIG_fail;
7228 }
7229 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegionIterator, 1);
7230 return resultobj;
7231 fail:
7232 return NULL;
7233 }
7234
7235
7236 static PyObject *_wrap_delete_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7237 PyObject *resultobj;
7238 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7239 PyObject * obj0 = 0 ;
7240 char *kwnames[] = {
7241 (char *) "self", NULL
7242 };
7243
7244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RegionIterator",kwnames,&obj0)) goto fail;
7245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7246 if (SWIG_arg_fail(1)) SWIG_fail;
7247 {
7248 PyThreadState* __tstate = wxPyBeginAllowThreads();
7249 delete arg1;
7250
7251 wxPyEndAllowThreads(__tstate);
7252 if (PyErr_Occurred()) SWIG_fail;
7253 }
7254 Py_INCREF(Py_None); resultobj = Py_None;
7255 return resultobj;
7256 fail:
7257 return NULL;
7258 }
7259
7260
7261 static PyObject *_wrap_RegionIterator_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
7262 PyObject *resultobj;
7263 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7264 int result;
7265 PyObject * obj0 = 0 ;
7266 char *kwnames[] = {
7267 (char *) "self", NULL
7268 };
7269
7270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetX",kwnames,&obj0)) goto fail;
7271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7272 if (SWIG_arg_fail(1)) SWIG_fail;
7273 {
7274 PyThreadState* __tstate = wxPyBeginAllowThreads();
7275 result = (int)(arg1)->GetX();
7276
7277 wxPyEndAllowThreads(__tstate);
7278 if (PyErr_Occurred()) SWIG_fail;
7279 }
7280 {
7281 resultobj = SWIG_From_int((int)(result));
7282 }
7283 return resultobj;
7284 fail:
7285 return NULL;
7286 }
7287
7288
7289 static PyObject *_wrap_RegionIterator_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
7290 PyObject *resultobj;
7291 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7292 int result;
7293 PyObject * obj0 = 0 ;
7294 char *kwnames[] = {
7295 (char *) "self", NULL
7296 };
7297
7298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetY",kwnames,&obj0)) goto fail;
7299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7300 if (SWIG_arg_fail(1)) SWIG_fail;
7301 {
7302 PyThreadState* __tstate = wxPyBeginAllowThreads();
7303 result = (int)(arg1)->GetY();
7304
7305 wxPyEndAllowThreads(__tstate);
7306 if (PyErr_Occurred()) SWIG_fail;
7307 }
7308 {
7309 resultobj = SWIG_From_int((int)(result));
7310 }
7311 return resultobj;
7312 fail:
7313 return NULL;
7314 }
7315
7316
7317 static PyObject *_wrap_RegionIterator_GetW(PyObject *, PyObject *args, PyObject *kwargs) {
7318 PyObject *resultobj;
7319 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7320 int result;
7321 PyObject * obj0 = 0 ;
7322 char *kwnames[] = {
7323 (char *) "self", NULL
7324 };
7325
7326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetW",kwnames,&obj0)) goto fail;
7327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7328 if (SWIG_arg_fail(1)) SWIG_fail;
7329 {
7330 PyThreadState* __tstate = wxPyBeginAllowThreads();
7331 result = (int)(arg1)->GetW();
7332
7333 wxPyEndAllowThreads(__tstate);
7334 if (PyErr_Occurred()) SWIG_fail;
7335 }
7336 {
7337 resultobj = SWIG_From_int((int)(result));
7338 }
7339 return resultobj;
7340 fail:
7341 return NULL;
7342 }
7343
7344
7345 static PyObject *_wrap_RegionIterator_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
7346 PyObject *resultobj;
7347 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7348 int result;
7349 PyObject * obj0 = 0 ;
7350 char *kwnames[] = {
7351 (char *) "self", NULL
7352 };
7353
7354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetWidth",kwnames,&obj0)) goto fail;
7355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7356 if (SWIG_arg_fail(1)) SWIG_fail;
7357 {
7358 PyThreadState* __tstate = wxPyBeginAllowThreads();
7359 result = (int)(arg1)->GetWidth();
7360
7361 wxPyEndAllowThreads(__tstate);
7362 if (PyErr_Occurred()) SWIG_fail;
7363 }
7364 {
7365 resultobj = SWIG_From_int((int)(result));
7366 }
7367 return resultobj;
7368 fail:
7369 return NULL;
7370 }
7371
7372
7373 static PyObject *_wrap_RegionIterator_GetH(PyObject *, PyObject *args, PyObject *kwargs) {
7374 PyObject *resultobj;
7375 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7376 int result;
7377 PyObject * obj0 = 0 ;
7378 char *kwnames[] = {
7379 (char *) "self", NULL
7380 };
7381
7382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetH",kwnames,&obj0)) goto fail;
7383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7384 if (SWIG_arg_fail(1)) SWIG_fail;
7385 {
7386 PyThreadState* __tstate = wxPyBeginAllowThreads();
7387 result = (int)(arg1)->GetH();
7388
7389 wxPyEndAllowThreads(__tstate);
7390 if (PyErr_Occurred()) SWIG_fail;
7391 }
7392 {
7393 resultobj = SWIG_From_int((int)(result));
7394 }
7395 return resultobj;
7396 fail:
7397 return NULL;
7398 }
7399
7400
7401 static PyObject *_wrap_RegionIterator_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
7402 PyObject *resultobj;
7403 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7404 int result;
7405 PyObject * obj0 = 0 ;
7406 char *kwnames[] = {
7407 (char *) "self", NULL
7408 };
7409
7410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetHeight",kwnames,&obj0)) goto fail;
7411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7412 if (SWIG_arg_fail(1)) SWIG_fail;
7413 {
7414 PyThreadState* __tstate = wxPyBeginAllowThreads();
7415 result = (int)(arg1)->GetHeight();
7416
7417 wxPyEndAllowThreads(__tstate);
7418 if (PyErr_Occurred()) SWIG_fail;
7419 }
7420 {
7421 resultobj = SWIG_From_int((int)(result));
7422 }
7423 return resultobj;
7424 fail:
7425 return NULL;
7426 }
7427
7428
7429 static PyObject *_wrap_RegionIterator_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
7430 PyObject *resultobj;
7431 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7432 wxRect result;
7433 PyObject * obj0 = 0 ;
7434 char *kwnames[] = {
7435 (char *) "self", NULL
7436 };
7437
7438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetRect",kwnames,&obj0)) goto fail;
7439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7440 if (SWIG_arg_fail(1)) SWIG_fail;
7441 {
7442 PyThreadState* __tstate = wxPyBeginAllowThreads();
7443 result = (arg1)->GetRect();
7444
7445 wxPyEndAllowThreads(__tstate);
7446 if (PyErr_Occurred()) SWIG_fail;
7447 }
7448 {
7449 wxRect * resultptr;
7450 resultptr = new wxRect((wxRect &)(result));
7451 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
7452 }
7453 return resultobj;
7454 fail:
7455 return NULL;
7456 }
7457
7458
7459 static PyObject *_wrap_RegionIterator_HaveRects(PyObject *, PyObject *args, PyObject *kwargs) {
7460 PyObject *resultobj;
7461 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7462 bool result;
7463 PyObject * obj0 = 0 ;
7464 char *kwnames[] = {
7465 (char *) "self", NULL
7466 };
7467
7468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_HaveRects",kwnames,&obj0)) goto fail;
7469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7470 if (SWIG_arg_fail(1)) SWIG_fail;
7471 {
7472 PyThreadState* __tstate = wxPyBeginAllowThreads();
7473 result = (bool)(arg1)->HaveRects();
7474
7475 wxPyEndAllowThreads(__tstate);
7476 if (PyErr_Occurred()) SWIG_fail;
7477 }
7478 {
7479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7480 }
7481 return resultobj;
7482 fail:
7483 return NULL;
7484 }
7485
7486
7487 static PyObject *_wrap_RegionIterator_Reset(PyObject *, PyObject *args, PyObject *kwargs) {
7488 PyObject *resultobj;
7489 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7490 PyObject * obj0 = 0 ;
7491 char *kwnames[] = {
7492 (char *) "self", NULL
7493 };
7494
7495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Reset",kwnames,&obj0)) goto fail;
7496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7497 if (SWIG_arg_fail(1)) SWIG_fail;
7498 {
7499 PyThreadState* __tstate = wxPyBeginAllowThreads();
7500 (arg1)->Reset();
7501
7502 wxPyEndAllowThreads(__tstate);
7503 if (PyErr_Occurred()) SWIG_fail;
7504 }
7505 Py_INCREF(Py_None); resultobj = Py_None;
7506 return resultobj;
7507 fail:
7508 return NULL;
7509 }
7510
7511
7512 static PyObject *_wrap_RegionIterator_Next(PyObject *, PyObject *args, PyObject *kwargs) {
7513 PyObject *resultobj;
7514 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7515 PyObject * obj0 = 0 ;
7516 char *kwnames[] = {
7517 (char *) "self", NULL
7518 };
7519
7520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Next",kwnames,&obj0)) goto fail;
7521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7522 if (SWIG_arg_fail(1)) SWIG_fail;
7523 {
7524 PyThreadState* __tstate = wxPyBeginAllowThreads();
7525 wxRegionIterator_Next(arg1);
7526
7527 wxPyEndAllowThreads(__tstate);
7528 if (PyErr_Occurred()) SWIG_fail;
7529 }
7530 Py_INCREF(Py_None); resultobj = Py_None;
7531 return resultobj;
7532 fail:
7533 return NULL;
7534 }
7535
7536
7537 static PyObject *_wrap_RegionIterator___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
7538 PyObject *resultobj;
7539 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7540 bool result;
7541 PyObject * obj0 = 0 ;
7542 char *kwnames[] = {
7543 (char *) "self", NULL
7544 };
7545
7546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator___nonzero__",kwnames,&obj0)) goto fail;
7547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7548 if (SWIG_arg_fail(1)) SWIG_fail;
7549 {
7550 PyThreadState* __tstate = wxPyBeginAllowThreads();
7551 result = (bool)wxRegionIterator___nonzero__(arg1);
7552
7553 wxPyEndAllowThreads(__tstate);
7554 if (PyErr_Occurred()) SWIG_fail;
7555 }
7556 {
7557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7558 }
7559 return resultobj;
7560 fail:
7561 return NULL;
7562 }
7563
7564
7565 static PyObject * RegionIterator_swigregister(PyObject *, PyObject *args) {
7566 PyObject *obj;
7567 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7568 SWIG_TypeClientData(SWIGTYPE_p_wxRegionIterator, obj);
7569 Py_INCREF(obj);
7570 return Py_BuildValue((char *)"");
7571 }
7572 static PyObject *_wrap_new_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7573 PyObject *resultobj;
7574 wxNativeFontInfo *result;
7575 char *kwnames[] = {
7576 NULL
7577 };
7578
7579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeFontInfo",kwnames)) goto fail;
7580 {
7581 PyThreadState* __tstate = wxPyBeginAllowThreads();
7582 result = (wxNativeFontInfo *)new wxNativeFontInfo();
7583
7584 wxPyEndAllowThreads(__tstate);
7585 if (PyErr_Occurred()) SWIG_fail;
7586 }
7587 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 1);
7588 return resultobj;
7589 fail:
7590 return NULL;
7591 }
7592
7593
7594 static PyObject *_wrap_delete_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7595 PyObject *resultobj;
7596 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7597 PyObject * obj0 = 0 ;
7598 char *kwnames[] = {
7599 (char *) "self", NULL
7600 };
7601
7602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeFontInfo",kwnames,&obj0)) goto fail;
7603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7604 if (SWIG_arg_fail(1)) SWIG_fail;
7605 {
7606 PyThreadState* __tstate = wxPyBeginAllowThreads();
7607 delete arg1;
7608
7609 wxPyEndAllowThreads(__tstate);
7610 if (PyErr_Occurred()) SWIG_fail;
7611 }
7612 Py_INCREF(Py_None); resultobj = Py_None;
7613 return resultobj;
7614 fail:
7615 return NULL;
7616 }
7617
7618
7619 static PyObject *_wrap_NativeFontInfo_Init(PyObject *, PyObject *args, PyObject *kwargs) {
7620 PyObject *resultobj;
7621 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7622 PyObject * obj0 = 0 ;
7623 char *kwnames[] = {
7624 (char *) "self", NULL
7625 };
7626
7627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_Init",kwnames,&obj0)) goto fail;
7628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7629 if (SWIG_arg_fail(1)) SWIG_fail;
7630 {
7631 PyThreadState* __tstate = wxPyBeginAllowThreads();
7632 (arg1)->Init();
7633
7634 wxPyEndAllowThreads(__tstate);
7635 if (PyErr_Occurred()) SWIG_fail;
7636 }
7637 Py_INCREF(Py_None); resultobj = Py_None;
7638 return resultobj;
7639 fail:
7640 return NULL;
7641 }
7642
7643
7644 static PyObject *_wrap_NativeFontInfo_InitFromFont(PyObject *, PyObject *args, PyObject *kwargs) {
7645 PyObject *resultobj;
7646 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7647 wxFont *arg2 = 0 ;
7648 PyObject * obj0 = 0 ;
7649 PyObject * obj1 = 0 ;
7650 char *kwnames[] = {
7651 (char *) "self",(char *) "font", NULL
7652 };
7653
7654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_InitFromFont",kwnames,&obj0,&obj1)) goto fail;
7655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7656 if (SWIG_arg_fail(1)) SWIG_fail;
7657 {
7658 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
7659 if (SWIG_arg_fail(2)) SWIG_fail;
7660 if (arg2 == NULL) {
7661 SWIG_null_ref("wxFont");
7662 }
7663 if (SWIG_arg_fail(2)) SWIG_fail;
7664 }
7665 {
7666 PyThreadState* __tstate = wxPyBeginAllowThreads();
7667 (arg1)->InitFromFont((wxFont const &)*arg2);
7668
7669 wxPyEndAllowThreads(__tstate);
7670 if (PyErr_Occurred()) SWIG_fail;
7671 }
7672 Py_INCREF(Py_None); resultobj = Py_None;
7673 return resultobj;
7674 fail:
7675 return NULL;
7676 }
7677
7678
7679 static PyObject *_wrap_NativeFontInfo_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
7680 PyObject *resultobj;
7681 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7682 int result;
7683 PyObject * obj0 = 0 ;
7684 char *kwnames[] = {
7685 (char *) "self", NULL
7686 };
7687
7688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetPointSize",kwnames,&obj0)) goto fail;
7689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7690 if (SWIG_arg_fail(1)) SWIG_fail;
7691 {
7692 PyThreadState* __tstate = wxPyBeginAllowThreads();
7693 result = (int)((wxNativeFontInfo const *)arg1)->GetPointSize();
7694
7695 wxPyEndAllowThreads(__tstate);
7696 if (PyErr_Occurred()) SWIG_fail;
7697 }
7698 {
7699 resultobj = SWIG_From_int((int)(result));
7700 }
7701 return resultobj;
7702 fail:
7703 return NULL;
7704 }
7705
7706
7707 static PyObject *_wrap_NativeFontInfo_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
7708 PyObject *resultobj;
7709 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7710 wxFontStyle result;
7711 PyObject * obj0 = 0 ;
7712 char *kwnames[] = {
7713 (char *) "self", NULL
7714 };
7715
7716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetStyle",kwnames,&obj0)) goto fail;
7717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7718 if (SWIG_arg_fail(1)) SWIG_fail;
7719 {
7720 PyThreadState* __tstate = wxPyBeginAllowThreads();
7721 result = (wxFontStyle)((wxNativeFontInfo const *)arg1)->GetStyle();
7722
7723 wxPyEndAllowThreads(__tstate);
7724 if (PyErr_Occurred()) SWIG_fail;
7725 }
7726 resultobj = SWIG_From_int((result));
7727 return resultobj;
7728 fail:
7729 return NULL;
7730 }
7731
7732
7733 static PyObject *_wrap_NativeFontInfo_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
7734 PyObject *resultobj;
7735 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7736 wxFontWeight result;
7737 PyObject * obj0 = 0 ;
7738 char *kwnames[] = {
7739 (char *) "self", NULL
7740 };
7741
7742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetWeight",kwnames,&obj0)) goto fail;
7743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7744 if (SWIG_arg_fail(1)) SWIG_fail;
7745 {
7746 PyThreadState* __tstate = wxPyBeginAllowThreads();
7747 result = (wxFontWeight)((wxNativeFontInfo const *)arg1)->GetWeight();
7748
7749 wxPyEndAllowThreads(__tstate);
7750 if (PyErr_Occurred()) SWIG_fail;
7751 }
7752 resultobj = SWIG_From_int((result));
7753 return resultobj;
7754 fail:
7755 return NULL;
7756 }
7757
7758
7759 static PyObject *_wrap_NativeFontInfo_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
7760 PyObject *resultobj;
7761 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7762 bool result;
7763 PyObject * obj0 = 0 ;
7764 char *kwnames[] = {
7765 (char *) "self", NULL
7766 };
7767
7768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetUnderlined",kwnames,&obj0)) goto fail;
7769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7770 if (SWIG_arg_fail(1)) SWIG_fail;
7771 {
7772 PyThreadState* __tstate = wxPyBeginAllowThreads();
7773 result = (bool)((wxNativeFontInfo const *)arg1)->GetUnderlined();
7774
7775 wxPyEndAllowThreads(__tstate);
7776 if (PyErr_Occurred()) SWIG_fail;
7777 }
7778 {
7779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7780 }
7781 return resultobj;
7782 fail:
7783 return NULL;
7784 }
7785
7786
7787 static PyObject *_wrap_NativeFontInfo_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
7788 PyObject *resultobj;
7789 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7790 wxString result;
7791 PyObject * obj0 = 0 ;
7792 char *kwnames[] = {
7793 (char *) "self", NULL
7794 };
7795
7796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFaceName",kwnames,&obj0)) goto fail;
7797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7798 if (SWIG_arg_fail(1)) SWIG_fail;
7799 {
7800 PyThreadState* __tstate = wxPyBeginAllowThreads();
7801 result = ((wxNativeFontInfo const *)arg1)->GetFaceName();
7802
7803 wxPyEndAllowThreads(__tstate);
7804 if (PyErr_Occurred()) SWIG_fail;
7805 }
7806 {
7807 #if wxUSE_UNICODE
7808 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7809 #else
7810 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7811 #endif
7812 }
7813 return resultobj;
7814 fail:
7815 return NULL;
7816 }
7817
7818
7819 static PyObject *_wrap_NativeFontInfo_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
7820 PyObject *resultobj;
7821 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7822 wxFontFamily result;
7823 PyObject * obj0 = 0 ;
7824 char *kwnames[] = {
7825 (char *) "self", NULL
7826 };
7827
7828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFamily",kwnames,&obj0)) goto fail;
7829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7830 if (SWIG_arg_fail(1)) SWIG_fail;
7831 {
7832 PyThreadState* __tstate = wxPyBeginAllowThreads();
7833 result = (wxFontFamily)((wxNativeFontInfo const *)arg1)->GetFamily();
7834
7835 wxPyEndAllowThreads(__tstate);
7836 if (PyErr_Occurred()) SWIG_fail;
7837 }
7838 resultobj = SWIG_From_int((result));
7839 return resultobj;
7840 fail:
7841 return NULL;
7842 }
7843
7844
7845 static PyObject *_wrap_NativeFontInfo_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
7846 PyObject *resultobj;
7847 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7848 wxFontEncoding result;
7849 PyObject * obj0 = 0 ;
7850 char *kwnames[] = {
7851 (char *) "self", NULL
7852 };
7853
7854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetEncoding",kwnames,&obj0)) goto fail;
7855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7856 if (SWIG_arg_fail(1)) SWIG_fail;
7857 {
7858 PyThreadState* __tstate = wxPyBeginAllowThreads();
7859 result = (wxFontEncoding)((wxNativeFontInfo const *)arg1)->GetEncoding();
7860
7861 wxPyEndAllowThreads(__tstate);
7862 if (PyErr_Occurred()) SWIG_fail;
7863 }
7864 resultobj = SWIG_From_int((result));
7865 return resultobj;
7866 fail:
7867 return NULL;
7868 }
7869
7870
7871 static PyObject *_wrap_NativeFontInfo_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
7872 PyObject *resultobj;
7873 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7874 int arg2 ;
7875 PyObject * obj0 = 0 ;
7876 PyObject * obj1 = 0 ;
7877 char *kwnames[] = {
7878 (char *) "self",(char *) "pointsize", NULL
7879 };
7880
7881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
7882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7883 if (SWIG_arg_fail(1)) SWIG_fail;
7884 {
7885 arg2 = (int)(SWIG_As_int(obj1));
7886 if (SWIG_arg_fail(2)) SWIG_fail;
7887 }
7888 {
7889 PyThreadState* __tstate = wxPyBeginAllowThreads();
7890 (arg1)->SetPointSize(arg2);
7891
7892 wxPyEndAllowThreads(__tstate);
7893 if (PyErr_Occurred()) SWIG_fail;
7894 }
7895 Py_INCREF(Py_None); resultobj = Py_None;
7896 return resultobj;
7897 fail:
7898 return NULL;
7899 }
7900
7901
7902 static PyObject *_wrap_NativeFontInfo_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
7903 PyObject *resultobj;
7904 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7905 wxFontStyle arg2 ;
7906 PyObject * obj0 = 0 ;
7907 PyObject * obj1 = 0 ;
7908 char *kwnames[] = {
7909 (char *) "self",(char *) "style", NULL
7910 };
7911
7912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetStyle",kwnames,&obj0,&obj1)) goto fail;
7913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7914 if (SWIG_arg_fail(1)) SWIG_fail;
7915 {
7916 arg2 = (wxFontStyle)(SWIG_As_int(obj1));
7917 if (SWIG_arg_fail(2)) SWIG_fail;
7918 }
7919 {
7920 PyThreadState* __tstate = wxPyBeginAllowThreads();
7921 (arg1)->SetStyle((wxFontStyle )arg2);
7922
7923 wxPyEndAllowThreads(__tstate);
7924 if (PyErr_Occurred()) SWIG_fail;
7925 }
7926 Py_INCREF(Py_None); resultobj = Py_None;
7927 return resultobj;
7928 fail:
7929 return NULL;
7930 }
7931
7932
7933 static PyObject *_wrap_NativeFontInfo_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
7934 PyObject *resultobj;
7935 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7936 wxFontWeight arg2 ;
7937 PyObject * obj0 = 0 ;
7938 PyObject * obj1 = 0 ;
7939 char *kwnames[] = {
7940 (char *) "self",(char *) "weight", NULL
7941 };
7942
7943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetWeight",kwnames,&obj0,&obj1)) goto fail;
7944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7945 if (SWIG_arg_fail(1)) SWIG_fail;
7946 {
7947 arg2 = (wxFontWeight)(SWIG_As_int(obj1));
7948 if (SWIG_arg_fail(2)) SWIG_fail;
7949 }
7950 {
7951 PyThreadState* __tstate = wxPyBeginAllowThreads();
7952 (arg1)->SetWeight((wxFontWeight )arg2);
7953
7954 wxPyEndAllowThreads(__tstate);
7955 if (PyErr_Occurred()) SWIG_fail;
7956 }
7957 Py_INCREF(Py_None); resultobj = Py_None;
7958 return resultobj;
7959 fail:
7960 return NULL;
7961 }
7962
7963
7964 static PyObject *_wrap_NativeFontInfo_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
7965 PyObject *resultobj;
7966 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7967 bool arg2 ;
7968 PyObject * obj0 = 0 ;
7969 PyObject * obj1 = 0 ;
7970 char *kwnames[] = {
7971 (char *) "self",(char *) "underlined", NULL
7972 };
7973
7974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
7975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7976 if (SWIG_arg_fail(1)) SWIG_fail;
7977 {
7978 arg2 = (bool)(SWIG_As_bool(obj1));
7979 if (SWIG_arg_fail(2)) SWIG_fail;
7980 }
7981 {
7982 PyThreadState* __tstate = wxPyBeginAllowThreads();
7983 (arg1)->SetUnderlined(arg2);
7984
7985 wxPyEndAllowThreads(__tstate);
7986 if (PyErr_Occurred()) SWIG_fail;
7987 }
7988 Py_INCREF(Py_None); resultobj = Py_None;
7989 return resultobj;
7990 fail:
7991 return NULL;
7992 }
7993
7994
7995 static PyObject *_wrap_NativeFontInfo_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
7996 PyObject *resultobj;
7997 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7998 wxString arg2 ;
7999 PyObject * obj0 = 0 ;
8000 PyObject * obj1 = 0 ;
8001 char *kwnames[] = {
8002 (char *) "self",(char *) "facename", NULL
8003 };
8004
8005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
8006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8007 if (SWIG_arg_fail(1)) SWIG_fail;
8008 {
8009 wxString* sptr = wxString_in_helper(obj1);
8010 if (sptr == NULL) SWIG_fail;
8011 arg2 = *sptr;
8012 delete sptr;
8013 }
8014 {
8015 PyThreadState* __tstate = wxPyBeginAllowThreads();
8016 (arg1)->SetFaceName(arg2);
8017
8018 wxPyEndAllowThreads(__tstate);
8019 if (PyErr_Occurred()) SWIG_fail;
8020 }
8021 Py_INCREF(Py_None); resultobj = Py_None;
8022 return resultobj;
8023 fail:
8024 return NULL;
8025 }
8026
8027
8028 static PyObject *_wrap_NativeFontInfo_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
8029 PyObject *resultobj;
8030 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8031 wxFontFamily arg2 ;
8032 PyObject * obj0 = 0 ;
8033 PyObject * obj1 = 0 ;
8034 char *kwnames[] = {
8035 (char *) "self",(char *) "family", NULL
8036 };
8037
8038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFamily",kwnames,&obj0,&obj1)) goto fail;
8039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8040 if (SWIG_arg_fail(1)) SWIG_fail;
8041 {
8042 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
8043 if (SWIG_arg_fail(2)) SWIG_fail;
8044 }
8045 {
8046 PyThreadState* __tstate = wxPyBeginAllowThreads();
8047 (arg1)->SetFamily((wxFontFamily )arg2);
8048
8049 wxPyEndAllowThreads(__tstate);
8050 if (PyErr_Occurred()) SWIG_fail;
8051 }
8052 Py_INCREF(Py_None); resultobj = Py_None;
8053 return resultobj;
8054 fail:
8055 return NULL;
8056 }
8057
8058
8059 static PyObject *_wrap_NativeFontInfo_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8060 PyObject *resultobj;
8061 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8062 wxFontEncoding arg2 ;
8063 PyObject * obj0 = 0 ;
8064 PyObject * obj1 = 0 ;
8065 char *kwnames[] = {
8066 (char *) "self",(char *) "encoding", NULL
8067 };
8068
8069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
8070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8071 if (SWIG_arg_fail(1)) SWIG_fail;
8072 {
8073 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8074 if (SWIG_arg_fail(2)) SWIG_fail;
8075 }
8076 {
8077 PyThreadState* __tstate = wxPyBeginAllowThreads();
8078 (arg1)->SetEncoding((wxFontEncoding )arg2);
8079
8080 wxPyEndAllowThreads(__tstate);
8081 if (PyErr_Occurred()) SWIG_fail;
8082 }
8083 Py_INCREF(Py_None); resultobj = Py_None;
8084 return resultobj;
8085 fail:
8086 return NULL;
8087 }
8088
8089
8090 static PyObject *_wrap_NativeFontInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
8091 PyObject *resultobj;
8092 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8093 wxString *arg2 = 0 ;
8094 bool result;
8095 bool temp2 = false ;
8096 PyObject * obj0 = 0 ;
8097 PyObject * obj1 = 0 ;
8098 char *kwnames[] = {
8099 (char *) "self",(char *) "s", NULL
8100 };
8101
8102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
8103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8104 if (SWIG_arg_fail(1)) SWIG_fail;
8105 {
8106 arg2 = wxString_in_helper(obj1);
8107 if (arg2 == NULL) SWIG_fail;
8108 temp2 = true;
8109 }
8110 {
8111 PyThreadState* __tstate = wxPyBeginAllowThreads();
8112 result = (bool)(arg1)->FromString((wxString const &)*arg2);
8113
8114 wxPyEndAllowThreads(__tstate);
8115 if (PyErr_Occurred()) SWIG_fail;
8116 }
8117 {
8118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8119 }
8120 {
8121 if (temp2)
8122 delete arg2;
8123 }
8124 return resultobj;
8125 fail:
8126 {
8127 if (temp2)
8128 delete arg2;
8129 }
8130 return NULL;
8131 }
8132
8133
8134 static PyObject *_wrap_NativeFontInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
8135 PyObject *resultobj;
8136 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8137 wxString result;
8138 PyObject * obj0 = 0 ;
8139 char *kwnames[] = {
8140 (char *) "self", NULL
8141 };
8142
8143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToString",kwnames,&obj0)) goto fail;
8144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8145 if (SWIG_arg_fail(1)) SWIG_fail;
8146 {
8147 PyThreadState* __tstate = wxPyBeginAllowThreads();
8148 result = ((wxNativeFontInfo const *)arg1)->ToString();
8149
8150 wxPyEndAllowThreads(__tstate);
8151 if (PyErr_Occurred()) SWIG_fail;
8152 }
8153 {
8154 #if wxUSE_UNICODE
8155 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8156 #else
8157 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8158 #endif
8159 }
8160 return resultobj;
8161 fail:
8162 return NULL;
8163 }
8164
8165
8166 static PyObject *_wrap_NativeFontInfo___str__(PyObject *, PyObject *args, PyObject *kwargs) {
8167 PyObject *resultobj;
8168 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8169 wxString result;
8170 PyObject * obj0 = 0 ;
8171 char *kwnames[] = {
8172 (char *) "self", NULL
8173 };
8174
8175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo___str__",kwnames,&obj0)) goto fail;
8176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8177 if (SWIG_arg_fail(1)) SWIG_fail;
8178 {
8179 PyThreadState* __tstate = wxPyBeginAllowThreads();
8180 result = wxNativeFontInfo___str__(arg1);
8181
8182 wxPyEndAllowThreads(__tstate);
8183 if (PyErr_Occurred()) SWIG_fail;
8184 }
8185 {
8186 #if wxUSE_UNICODE
8187 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8188 #else
8189 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8190 #endif
8191 }
8192 return resultobj;
8193 fail:
8194 return NULL;
8195 }
8196
8197
8198 static PyObject *_wrap_NativeFontInfo_FromUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8199 PyObject *resultobj;
8200 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8201 wxString *arg2 = 0 ;
8202 bool result;
8203 bool temp2 = false ;
8204 PyObject * obj0 = 0 ;
8205 PyObject * obj1 = 0 ;
8206 char *kwnames[] = {
8207 (char *) "self",(char *) "s", NULL
8208 };
8209
8210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromUserString",kwnames,&obj0,&obj1)) goto fail;
8211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8212 if (SWIG_arg_fail(1)) SWIG_fail;
8213 {
8214 arg2 = wxString_in_helper(obj1);
8215 if (arg2 == NULL) SWIG_fail;
8216 temp2 = true;
8217 }
8218 {
8219 PyThreadState* __tstate = wxPyBeginAllowThreads();
8220 result = (bool)(arg1)->FromUserString((wxString const &)*arg2);
8221
8222 wxPyEndAllowThreads(__tstate);
8223 if (PyErr_Occurred()) SWIG_fail;
8224 }
8225 {
8226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8227 }
8228 {
8229 if (temp2)
8230 delete arg2;
8231 }
8232 return resultobj;
8233 fail:
8234 {
8235 if (temp2)
8236 delete arg2;
8237 }
8238 return NULL;
8239 }
8240
8241
8242 static PyObject *_wrap_NativeFontInfo_ToUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8243 PyObject *resultobj;
8244 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8245 wxString result;
8246 PyObject * obj0 = 0 ;
8247 char *kwnames[] = {
8248 (char *) "self", NULL
8249 };
8250
8251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToUserString",kwnames,&obj0)) goto fail;
8252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8253 if (SWIG_arg_fail(1)) SWIG_fail;
8254 {
8255 PyThreadState* __tstate = wxPyBeginAllowThreads();
8256 result = ((wxNativeFontInfo const *)arg1)->ToUserString();
8257
8258 wxPyEndAllowThreads(__tstate);
8259 if (PyErr_Occurred()) SWIG_fail;
8260 }
8261 {
8262 #if wxUSE_UNICODE
8263 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8264 #else
8265 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8266 #endif
8267 }
8268 return resultobj;
8269 fail:
8270 return NULL;
8271 }
8272
8273
8274 static PyObject * NativeFontInfo_swigregister(PyObject *, PyObject *args) {
8275 PyObject *obj;
8276 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8277 SWIG_TypeClientData(SWIGTYPE_p_wxNativeFontInfo, obj);
8278 Py_INCREF(obj);
8279 return Py_BuildValue((char *)"");
8280 }
8281 static PyObject *_wrap_NativeEncodingInfo_facename_set(PyObject *, PyObject *args, PyObject *kwargs) {
8282 PyObject *resultobj;
8283 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8284 wxString *arg2 = (wxString *) 0 ;
8285 bool temp2 = false ;
8286 PyObject * obj0 = 0 ;
8287 PyObject * obj1 = 0 ;
8288 char *kwnames[] = {
8289 (char *) "self",(char *) "facename", NULL
8290 };
8291
8292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_facename_set",kwnames,&obj0,&obj1)) goto fail;
8293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8294 if (SWIG_arg_fail(1)) SWIG_fail;
8295 {
8296 arg2 = wxString_in_helper(obj1);
8297 if (arg2 == NULL) SWIG_fail;
8298 temp2 = true;
8299 }
8300 if (arg1) (arg1)->facename = *arg2;
8301
8302 Py_INCREF(Py_None); resultobj = Py_None;
8303 {
8304 if (temp2)
8305 delete arg2;
8306 }
8307 return resultobj;
8308 fail:
8309 {
8310 if (temp2)
8311 delete arg2;
8312 }
8313 return NULL;
8314 }
8315
8316
8317 static PyObject *_wrap_NativeEncodingInfo_facename_get(PyObject *, PyObject *args, PyObject *kwargs) {
8318 PyObject *resultobj;
8319 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8320 wxString *result;
8321 PyObject * obj0 = 0 ;
8322 char *kwnames[] = {
8323 (char *) "self", NULL
8324 };
8325
8326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_facename_get",kwnames,&obj0)) goto fail;
8327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8328 if (SWIG_arg_fail(1)) SWIG_fail;
8329 result = (wxString *)& ((arg1)->facename);
8330
8331 {
8332 #if wxUSE_UNICODE
8333 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8334 #else
8335 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8336 #endif
8337 }
8338 return resultobj;
8339 fail:
8340 return NULL;
8341 }
8342
8343
8344 static PyObject *_wrap_NativeEncodingInfo_encoding_set(PyObject *, PyObject *args, PyObject *kwargs) {
8345 PyObject *resultobj;
8346 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8347 wxFontEncoding arg2 ;
8348 PyObject * obj0 = 0 ;
8349 PyObject * obj1 = 0 ;
8350 char *kwnames[] = {
8351 (char *) "self",(char *) "encoding", NULL
8352 };
8353
8354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_encoding_set",kwnames,&obj0,&obj1)) goto fail;
8355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8356 if (SWIG_arg_fail(1)) SWIG_fail;
8357 {
8358 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8359 if (SWIG_arg_fail(2)) SWIG_fail;
8360 }
8361 if (arg1) (arg1)->encoding = (wxFontEncoding )arg2;
8362
8363 Py_INCREF(Py_None); resultobj = Py_None;
8364 return resultobj;
8365 fail:
8366 return NULL;
8367 }
8368
8369
8370 static PyObject *_wrap_NativeEncodingInfo_encoding_get(PyObject *, PyObject *args, PyObject *kwargs) {
8371 PyObject *resultobj;
8372 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8373 wxFontEncoding result;
8374 PyObject * obj0 = 0 ;
8375 char *kwnames[] = {
8376 (char *) "self", NULL
8377 };
8378
8379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_encoding_get",kwnames,&obj0)) goto fail;
8380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8381 if (SWIG_arg_fail(1)) SWIG_fail;
8382 result = (wxFontEncoding) ((arg1)->encoding);
8383
8384 resultobj = SWIG_From_int((result));
8385 return resultobj;
8386 fail:
8387 return NULL;
8388 }
8389
8390
8391 static PyObject *_wrap_new_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8392 PyObject *resultobj;
8393 wxNativeEncodingInfo *result;
8394 char *kwnames[] = {
8395 NULL
8396 };
8397
8398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeEncodingInfo",kwnames)) goto fail;
8399 {
8400 PyThreadState* __tstate = wxPyBeginAllowThreads();
8401 result = (wxNativeEncodingInfo *)new wxNativeEncodingInfo();
8402
8403 wxPyEndAllowThreads(__tstate);
8404 if (PyErr_Occurred()) SWIG_fail;
8405 }
8406 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 1);
8407 return resultobj;
8408 fail:
8409 return NULL;
8410 }
8411
8412
8413 static PyObject *_wrap_delete_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8414 PyObject *resultobj;
8415 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8416 PyObject * obj0 = 0 ;
8417 char *kwnames[] = {
8418 (char *) "self", NULL
8419 };
8420
8421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeEncodingInfo",kwnames,&obj0)) goto fail;
8422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8423 if (SWIG_arg_fail(1)) SWIG_fail;
8424 {
8425 PyThreadState* __tstate = wxPyBeginAllowThreads();
8426 delete arg1;
8427
8428 wxPyEndAllowThreads(__tstate);
8429 if (PyErr_Occurred()) SWIG_fail;
8430 }
8431 Py_INCREF(Py_None); resultobj = Py_None;
8432 return resultobj;
8433 fail:
8434 return NULL;
8435 }
8436
8437
8438 static PyObject *_wrap_NativeEncodingInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
8439 PyObject *resultobj;
8440 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8441 wxString *arg2 = 0 ;
8442 bool result;
8443 bool temp2 = false ;
8444 PyObject * obj0 = 0 ;
8445 PyObject * obj1 = 0 ;
8446 char *kwnames[] = {
8447 (char *) "self",(char *) "s", NULL
8448 };
8449
8450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
8451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8452 if (SWIG_arg_fail(1)) SWIG_fail;
8453 {
8454 arg2 = wxString_in_helper(obj1);
8455 if (arg2 == NULL) SWIG_fail;
8456 temp2 = true;
8457 }
8458 {
8459 PyThreadState* __tstate = wxPyBeginAllowThreads();
8460 result = (bool)(arg1)->FromString((wxString const &)*arg2);
8461
8462 wxPyEndAllowThreads(__tstate);
8463 if (PyErr_Occurred()) SWIG_fail;
8464 }
8465 {
8466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8467 }
8468 {
8469 if (temp2)
8470 delete arg2;
8471 }
8472 return resultobj;
8473 fail:
8474 {
8475 if (temp2)
8476 delete arg2;
8477 }
8478 return NULL;
8479 }
8480
8481
8482 static PyObject *_wrap_NativeEncodingInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
8483 PyObject *resultobj;
8484 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8485 wxString result;
8486 PyObject * obj0 = 0 ;
8487 char *kwnames[] = {
8488 (char *) "self", NULL
8489 };
8490
8491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_ToString",kwnames,&obj0)) goto fail;
8492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8493 if (SWIG_arg_fail(1)) SWIG_fail;
8494 {
8495 PyThreadState* __tstate = wxPyBeginAllowThreads();
8496 result = ((wxNativeEncodingInfo const *)arg1)->ToString();
8497
8498 wxPyEndAllowThreads(__tstate);
8499 if (PyErr_Occurred()) SWIG_fail;
8500 }
8501 {
8502 #if wxUSE_UNICODE
8503 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8504 #else
8505 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8506 #endif
8507 }
8508 return resultobj;
8509 fail:
8510 return NULL;
8511 }
8512
8513
8514 static PyObject * NativeEncodingInfo_swigregister(PyObject *, PyObject *args) {
8515 PyObject *obj;
8516 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8517 SWIG_TypeClientData(SWIGTYPE_p_wxNativeEncodingInfo, obj);
8518 Py_INCREF(obj);
8519 return Py_BuildValue((char *)"");
8520 }
8521 static PyObject *_wrap_GetNativeFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8522 PyObject *resultobj;
8523 wxFontEncoding arg1 ;
8524 wxNativeEncodingInfo *result;
8525 PyObject * obj0 = 0 ;
8526 char *kwnames[] = {
8527 (char *) "encoding", NULL
8528 };
8529
8530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetNativeFontEncoding",kwnames,&obj0)) goto fail;
8531 {
8532 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8533 if (SWIG_arg_fail(1)) SWIG_fail;
8534 }
8535 {
8536 PyThreadState* __tstate = wxPyBeginAllowThreads();
8537 result = (wxNativeEncodingInfo *)wxGetNativeFontEncoding((wxFontEncoding )arg1);
8538
8539 wxPyEndAllowThreads(__tstate);
8540 if (PyErr_Occurred()) SWIG_fail;
8541 }
8542 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 0);
8543 return resultobj;
8544 fail:
8545 return NULL;
8546 }
8547
8548
8549 static PyObject *_wrap_TestFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8550 PyObject *resultobj;
8551 wxNativeEncodingInfo *arg1 = 0 ;
8552 bool result;
8553 PyObject * obj0 = 0 ;
8554 char *kwnames[] = {
8555 (char *) "info", NULL
8556 };
8557
8558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TestFontEncoding",kwnames,&obj0)) goto fail;
8559 {
8560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8561 if (SWIG_arg_fail(1)) SWIG_fail;
8562 if (arg1 == NULL) {
8563 SWIG_null_ref("wxNativeEncodingInfo");
8564 }
8565 if (SWIG_arg_fail(1)) SWIG_fail;
8566 }
8567 {
8568 PyThreadState* __tstate = wxPyBeginAllowThreads();
8569 result = (bool)wxTestFontEncoding((wxNativeEncodingInfo const &)*arg1);
8570
8571 wxPyEndAllowThreads(__tstate);
8572 if (PyErr_Occurred()) SWIG_fail;
8573 }
8574 {
8575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8576 }
8577 return resultobj;
8578 fail:
8579 return NULL;
8580 }
8581
8582
8583 static PyObject *_wrap_new_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
8584 PyObject *resultobj;
8585 wxFontMapper *result;
8586 char *kwnames[] = {
8587 NULL
8588 };
8589
8590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontMapper",kwnames)) goto fail;
8591 {
8592 PyThreadState* __tstate = wxPyBeginAllowThreads();
8593 result = (wxFontMapper *)new wxFontMapper();
8594
8595 wxPyEndAllowThreads(__tstate);
8596 if (PyErr_Occurred()) SWIG_fail;
8597 }
8598 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 1);
8599 return resultobj;
8600 fail:
8601 return NULL;
8602 }
8603
8604
8605 static PyObject *_wrap_delete_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
8606 PyObject *resultobj;
8607 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8608 PyObject * obj0 = 0 ;
8609 char *kwnames[] = {
8610 (char *) "self", NULL
8611 };
8612
8613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontMapper",kwnames,&obj0)) goto fail;
8614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8615 if (SWIG_arg_fail(1)) SWIG_fail;
8616 {
8617 PyThreadState* __tstate = wxPyBeginAllowThreads();
8618 delete arg1;
8619
8620 wxPyEndAllowThreads(__tstate);
8621 if (PyErr_Occurred()) SWIG_fail;
8622 }
8623 Py_INCREF(Py_None); resultobj = Py_None;
8624 return resultobj;
8625 fail:
8626 return NULL;
8627 }
8628
8629
8630 static PyObject *_wrap_FontMapper_Get(PyObject *, PyObject *args, PyObject *kwargs) {
8631 PyObject *resultobj;
8632 wxFontMapper *result;
8633 char *kwnames[] = {
8634 NULL
8635 };
8636
8637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_Get",kwnames)) goto fail;
8638 {
8639 PyThreadState* __tstate = wxPyBeginAllowThreads();
8640 result = (wxFontMapper *)wxFontMapper::Get();
8641
8642 wxPyEndAllowThreads(__tstate);
8643 if (PyErr_Occurred()) SWIG_fail;
8644 }
8645 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
8646 return resultobj;
8647 fail:
8648 return NULL;
8649 }
8650
8651
8652 static PyObject *_wrap_FontMapper_Set(PyObject *, PyObject *args, PyObject *kwargs) {
8653 PyObject *resultobj;
8654 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8655 wxFontMapper *result;
8656 PyObject * obj0 = 0 ;
8657 char *kwnames[] = {
8658 (char *) "mapper", NULL
8659 };
8660
8661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_Set",kwnames,&obj0)) goto fail;
8662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8663 if (SWIG_arg_fail(1)) SWIG_fail;
8664 {
8665 PyThreadState* __tstate = wxPyBeginAllowThreads();
8666 result = (wxFontMapper *)wxFontMapper::Set(arg1);
8667
8668 wxPyEndAllowThreads(__tstate);
8669 if (PyErr_Occurred()) SWIG_fail;
8670 }
8671 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
8672 return resultobj;
8673 fail:
8674 return NULL;
8675 }
8676
8677
8678 static PyObject *_wrap_FontMapper_CharsetToEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8679 PyObject *resultobj;
8680 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8681 wxString *arg2 = 0 ;
8682 bool arg3 = (bool) true ;
8683 wxFontEncoding result;
8684 bool temp2 = false ;
8685 PyObject * obj0 = 0 ;
8686 PyObject * obj1 = 0 ;
8687 PyObject * obj2 = 0 ;
8688 char *kwnames[] = {
8689 (char *) "self",(char *) "charset",(char *) "interactive", NULL
8690 };
8691
8692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_CharsetToEncoding",kwnames,&obj0,&obj1,&obj2)) goto fail;
8693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8694 if (SWIG_arg_fail(1)) SWIG_fail;
8695 {
8696 arg2 = wxString_in_helper(obj1);
8697 if (arg2 == NULL) SWIG_fail;
8698 temp2 = true;
8699 }
8700 if (obj2) {
8701 {
8702 arg3 = (bool)(SWIG_As_bool(obj2));
8703 if (SWIG_arg_fail(3)) SWIG_fail;
8704 }
8705 }
8706 {
8707 PyThreadState* __tstate = wxPyBeginAllowThreads();
8708 result = (wxFontEncoding)(arg1)->CharsetToEncoding((wxString const &)*arg2,arg3);
8709
8710 wxPyEndAllowThreads(__tstate);
8711 if (PyErr_Occurred()) SWIG_fail;
8712 }
8713 resultobj = SWIG_From_int((result));
8714 {
8715 if (temp2)
8716 delete arg2;
8717 }
8718 return resultobj;
8719 fail:
8720 {
8721 if (temp2)
8722 delete arg2;
8723 }
8724 return NULL;
8725 }
8726
8727
8728 static PyObject *_wrap_FontMapper_GetSupportedEncodingsCount(PyObject *, PyObject *args, PyObject *kwargs) {
8729 PyObject *resultobj;
8730 size_t result;
8731 char *kwnames[] = {
8732 NULL
8733 };
8734
8735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetSupportedEncodingsCount",kwnames)) goto fail;
8736 {
8737 PyThreadState* __tstate = wxPyBeginAllowThreads();
8738 result = (size_t)wxFontMapper::GetSupportedEncodingsCount();
8739
8740 wxPyEndAllowThreads(__tstate);
8741 if (PyErr_Occurred()) SWIG_fail;
8742 }
8743 {
8744 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
8745 }
8746 return resultobj;
8747 fail:
8748 return NULL;
8749 }
8750
8751
8752 static PyObject *_wrap_FontMapper_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8753 PyObject *resultobj;
8754 size_t arg1 ;
8755 wxFontEncoding result;
8756 PyObject * obj0 = 0 ;
8757 char *kwnames[] = {
8758 (char *) "n", NULL
8759 };
8760
8761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncoding",kwnames,&obj0)) goto fail;
8762 {
8763 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8764 if (SWIG_arg_fail(1)) SWIG_fail;
8765 }
8766 {
8767 PyThreadState* __tstate = wxPyBeginAllowThreads();
8768 result = (wxFontEncoding)wxFontMapper::GetEncoding(arg1);
8769
8770 wxPyEndAllowThreads(__tstate);
8771 if (PyErr_Occurred()) SWIG_fail;
8772 }
8773 resultobj = SWIG_From_int((result));
8774 return resultobj;
8775 fail:
8776 return NULL;
8777 }
8778
8779
8780 static PyObject *_wrap_FontMapper_GetEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
8781 PyObject *resultobj;
8782 wxFontEncoding arg1 ;
8783 wxString result;
8784 PyObject * obj0 = 0 ;
8785 char *kwnames[] = {
8786 (char *) "encoding", NULL
8787 };
8788
8789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingName",kwnames,&obj0)) goto fail;
8790 {
8791 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8792 if (SWIG_arg_fail(1)) SWIG_fail;
8793 }
8794 {
8795 PyThreadState* __tstate = wxPyBeginAllowThreads();
8796 result = wxFontMapper::GetEncodingName((wxFontEncoding )arg1);
8797
8798 wxPyEndAllowThreads(__tstate);
8799 if (PyErr_Occurred()) SWIG_fail;
8800 }
8801 {
8802 #if wxUSE_UNICODE
8803 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8804 #else
8805 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8806 #endif
8807 }
8808 return resultobj;
8809 fail:
8810 return NULL;
8811 }
8812
8813
8814 static PyObject *_wrap_FontMapper_GetEncodingDescription(PyObject *, PyObject *args, PyObject *kwargs) {
8815 PyObject *resultobj;
8816 wxFontEncoding arg1 ;
8817 wxString result;
8818 PyObject * obj0 = 0 ;
8819 char *kwnames[] = {
8820 (char *) "encoding", NULL
8821 };
8822
8823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingDescription",kwnames,&obj0)) goto fail;
8824 {
8825 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8826 if (SWIG_arg_fail(1)) SWIG_fail;
8827 }
8828 {
8829 PyThreadState* __tstate = wxPyBeginAllowThreads();
8830 result = wxFontMapper::GetEncodingDescription((wxFontEncoding )arg1);
8831
8832 wxPyEndAllowThreads(__tstate);
8833 if (PyErr_Occurred()) SWIG_fail;
8834 }
8835 {
8836 #if wxUSE_UNICODE
8837 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8838 #else
8839 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8840 #endif
8841 }
8842 return resultobj;
8843 fail:
8844 return NULL;
8845 }
8846
8847
8848 static PyObject *_wrap_FontMapper_GetEncodingFromName(PyObject *, PyObject *args, PyObject *kwargs) {
8849 PyObject *resultobj;
8850 wxString *arg1 = 0 ;
8851 wxFontEncoding result;
8852 bool temp1 = false ;
8853 PyObject * obj0 = 0 ;
8854 char *kwnames[] = {
8855 (char *) "name", NULL
8856 };
8857
8858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingFromName",kwnames,&obj0)) goto fail;
8859 {
8860 arg1 = wxString_in_helper(obj0);
8861 if (arg1 == NULL) SWIG_fail;
8862 temp1 = true;
8863 }
8864 {
8865 PyThreadState* __tstate = wxPyBeginAllowThreads();
8866 result = (wxFontEncoding)wxFontMapper::GetEncodingFromName((wxString const &)*arg1);
8867
8868 wxPyEndAllowThreads(__tstate);
8869 if (PyErr_Occurred()) SWIG_fail;
8870 }
8871 resultobj = SWIG_From_int((result));
8872 {
8873 if (temp1)
8874 delete arg1;
8875 }
8876 return resultobj;
8877 fail:
8878 {
8879 if (temp1)
8880 delete arg1;
8881 }
8882 return NULL;
8883 }
8884
8885
8886 static PyObject *_wrap_FontMapper_SetConfig(PyObject *, PyObject *args, PyObject *kwargs) {
8887 PyObject *resultobj;
8888 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8889 wxConfigBase *arg2 = (wxConfigBase *) 0 ;
8890 PyObject * obj0 = 0 ;
8891 PyObject * obj1 = 0 ;
8892 char *kwnames[] = {
8893 (char *) "self",(char *) "config", NULL
8894 };
8895
8896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfig",kwnames,&obj0,&obj1)) goto fail;
8897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8898 if (SWIG_arg_fail(1)) SWIG_fail;
8899 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
8900 if (SWIG_arg_fail(2)) SWIG_fail;
8901 {
8902 PyThreadState* __tstate = wxPyBeginAllowThreads();
8903 (arg1)->SetConfig(arg2);
8904
8905 wxPyEndAllowThreads(__tstate);
8906 if (PyErr_Occurred()) SWIG_fail;
8907 }
8908 Py_INCREF(Py_None); resultobj = Py_None;
8909 return resultobj;
8910 fail:
8911 return NULL;
8912 }
8913
8914
8915 static PyObject *_wrap_FontMapper_SetConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
8916 PyObject *resultobj;
8917 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8918 wxString *arg2 = 0 ;
8919 bool temp2 = false ;
8920 PyObject * obj0 = 0 ;
8921 PyObject * obj1 = 0 ;
8922 char *kwnames[] = {
8923 (char *) "self",(char *) "prefix", NULL
8924 };
8925
8926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfigPath",kwnames,&obj0,&obj1)) goto fail;
8927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8928 if (SWIG_arg_fail(1)) SWIG_fail;
8929 {
8930 arg2 = wxString_in_helper(obj1);
8931 if (arg2 == NULL) SWIG_fail;
8932 temp2 = true;
8933 }
8934 {
8935 PyThreadState* __tstate = wxPyBeginAllowThreads();
8936 (arg1)->SetConfigPath((wxString const &)*arg2);
8937
8938 wxPyEndAllowThreads(__tstate);
8939 if (PyErr_Occurred()) SWIG_fail;
8940 }
8941 Py_INCREF(Py_None); resultobj = Py_None;
8942 {
8943 if (temp2)
8944 delete arg2;
8945 }
8946 return resultobj;
8947 fail:
8948 {
8949 if (temp2)
8950 delete arg2;
8951 }
8952 return NULL;
8953 }
8954
8955
8956 static PyObject *_wrap_FontMapper_GetDefaultConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
8957 PyObject *resultobj;
8958 wxString result;
8959 char *kwnames[] = {
8960 NULL
8961 };
8962
8963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetDefaultConfigPath",kwnames)) goto fail;
8964 {
8965 PyThreadState* __tstate = wxPyBeginAllowThreads();
8966 result = wxFontMapper::GetDefaultConfigPath();
8967
8968 wxPyEndAllowThreads(__tstate);
8969 if (PyErr_Occurred()) SWIG_fail;
8970 }
8971 {
8972 #if wxUSE_UNICODE
8973 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8974 #else
8975 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8976 #endif
8977 }
8978 return resultobj;
8979 fail:
8980 return NULL;
8981 }
8982
8983
8984 static PyObject *_wrap_FontMapper_GetAltForEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8985 PyObject *resultobj;
8986 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8987 wxFontEncoding arg2 ;
8988 wxString const &arg3_defvalue = wxPyEmptyString ;
8989 wxString *arg3 = (wxString *) &arg3_defvalue ;
8990 bool arg4 = (bool) true ;
8991 PyObject *result;
8992 bool temp3 = false ;
8993 PyObject * obj0 = 0 ;
8994 PyObject * obj1 = 0 ;
8995 PyObject * obj2 = 0 ;
8996 PyObject * obj3 = 0 ;
8997 char *kwnames[] = {
8998 (char *) "self",(char *) "encoding",(char *) "facename",(char *) "interactive", NULL
8999 };
9000
9001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:FontMapper_GetAltForEncoding",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9003 if (SWIG_arg_fail(1)) SWIG_fail;
9004 {
9005 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9006 if (SWIG_arg_fail(2)) SWIG_fail;
9007 }
9008 if (obj2) {
9009 {
9010 arg3 = wxString_in_helper(obj2);
9011 if (arg3 == NULL) SWIG_fail;
9012 temp3 = true;
9013 }
9014 }
9015 if (obj3) {
9016 {
9017 arg4 = (bool)(SWIG_As_bool(obj3));
9018 if (SWIG_arg_fail(4)) SWIG_fail;
9019 }
9020 }
9021 {
9022 PyThreadState* __tstate = wxPyBeginAllowThreads();
9023 result = (PyObject *)wxFontMapper_GetAltForEncoding(arg1,(wxFontEncoding )arg2,(wxString const &)*arg3,arg4);
9024
9025 wxPyEndAllowThreads(__tstate);
9026 if (PyErr_Occurred()) SWIG_fail;
9027 }
9028 resultobj = result;
9029 {
9030 if (temp3)
9031 delete arg3;
9032 }
9033 return resultobj;
9034 fail:
9035 {
9036 if (temp3)
9037 delete arg3;
9038 }
9039 return NULL;
9040 }
9041
9042
9043 static PyObject *_wrap_FontMapper_IsEncodingAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
9044 PyObject *resultobj;
9045 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9046 wxFontEncoding arg2 ;
9047 wxString const &arg3_defvalue = wxPyEmptyString ;
9048 wxString *arg3 = (wxString *) &arg3_defvalue ;
9049 bool result;
9050 bool temp3 = false ;
9051 PyObject * obj0 = 0 ;
9052 PyObject * obj1 = 0 ;
9053 PyObject * obj2 = 0 ;
9054 char *kwnames[] = {
9055 (char *) "self",(char *) "encoding",(char *) "facename", NULL
9056 };
9057
9058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_IsEncodingAvailable",kwnames,&obj0,&obj1,&obj2)) goto fail;
9059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9060 if (SWIG_arg_fail(1)) SWIG_fail;
9061 {
9062 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9063 if (SWIG_arg_fail(2)) SWIG_fail;
9064 }
9065 if (obj2) {
9066 {
9067 arg3 = wxString_in_helper(obj2);
9068 if (arg3 == NULL) SWIG_fail;
9069 temp3 = true;
9070 }
9071 }
9072 {
9073 PyThreadState* __tstate = wxPyBeginAllowThreads();
9074 result = (bool)(arg1)->IsEncodingAvailable((wxFontEncoding )arg2,(wxString const &)*arg3);
9075
9076 wxPyEndAllowThreads(__tstate);
9077 if (PyErr_Occurred()) SWIG_fail;
9078 }
9079 {
9080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9081 }
9082 {
9083 if (temp3)
9084 delete arg3;
9085 }
9086 return resultobj;
9087 fail:
9088 {
9089 if (temp3)
9090 delete arg3;
9091 }
9092 return NULL;
9093 }
9094
9095
9096 static PyObject *_wrap_FontMapper_SetDialogParent(PyObject *, PyObject *args, PyObject *kwargs) {
9097 PyObject *resultobj;
9098 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9099 wxWindow *arg2 = (wxWindow *) 0 ;
9100 PyObject * obj0 = 0 ;
9101 PyObject * obj1 = 0 ;
9102 char *kwnames[] = {
9103 (char *) "self",(char *) "parent", NULL
9104 };
9105
9106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogParent",kwnames,&obj0,&obj1)) goto fail;
9107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9108 if (SWIG_arg_fail(1)) SWIG_fail;
9109 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
9110 if (SWIG_arg_fail(2)) SWIG_fail;
9111 {
9112 PyThreadState* __tstate = wxPyBeginAllowThreads();
9113 (arg1)->SetDialogParent(arg2);
9114
9115 wxPyEndAllowThreads(__tstate);
9116 if (PyErr_Occurred()) SWIG_fail;
9117 }
9118 Py_INCREF(Py_None); resultobj = Py_None;
9119 return resultobj;
9120 fail:
9121 return NULL;
9122 }
9123
9124
9125 static PyObject *_wrap_FontMapper_SetDialogTitle(PyObject *, PyObject *args, PyObject *kwargs) {
9126 PyObject *resultobj;
9127 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9128 wxString *arg2 = 0 ;
9129 bool temp2 = false ;
9130 PyObject * obj0 = 0 ;
9131 PyObject * obj1 = 0 ;
9132 char *kwnames[] = {
9133 (char *) "self",(char *) "title", NULL
9134 };
9135
9136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogTitle",kwnames,&obj0,&obj1)) goto fail;
9137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9138 if (SWIG_arg_fail(1)) SWIG_fail;
9139 {
9140 arg2 = wxString_in_helper(obj1);
9141 if (arg2 == NULL) SWIG_fail;
9142 temp2 = true;
9143 }
9144 {
9145 PyThreadState* __tstate = wxPyBeginAllowThreads();
9146 (arg1)->SetDialogTitle((wxString const &)*arg2);
9147
9148 wxPyEndAllowThreads(__tstate);
9149 if (PyErr_Occurred()) SWIG_fail;
9150 }
9151 Py_INCREF(Py_None); resultobj = Py_None;
9152 {
9153 if (temp2)
9154 delete arg2;
9155 }
9156 return resultobj;
9157 fail:
9158 {
9159 if (temp2)
9160 delete arg2;
9161 }
9162 return NULL;
9163 }
9164
9165
9166 static PyObject * FontMapper_swigregister(PyObject *, PyObject *args) {
9167 PyObject *obj;
9168 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9169 SWIG_TypeClientData(SWIGTYPE_p_wxFontMapper, obj);
9170 Py_INCREF(obj);
9171 return Py_BuildValue((char *)"");
9172 }
9173 static PyObject *_wrap_new_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9174 PyObject *resultobj;
9175 int arg1 ;
9176 int arg2 ;
9177 int arg3 ;
9178 int arg4 ;
9179 bool arg5 = (bool) false ;
9180 wxString const &arg6_defvalue = wxPyEmptyString ;
9181 wxString *arg6 = (wxString *) &arg6_defvalue ;
9182 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9183 wxFont *result;
9184 bool temp6 = false ;
9185 PyObject * obj0 = 0 ;
9186 PyObject * obj1 = 0 ;
9187 PyObject * obj2 = 0 ;
9188 PyObject * obj3 = 0 ;
9189 PyObject * obj4 = 0 ;
9190 PyObject * obj5 = 0 ;
9191 PyObject * obj6 = 0 ;
9192 char *kwnames[] = {
9193 (char *) "pointSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "face",(char *) "encoding", NULL
9194 };
9195
9196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_Font",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9197 {
9198 arg1 = (int)(SWIG_As_int(obj0));
9199 if (SWIG_arg_fail(1)) SWIG_fail;
9200 }
9201 {
9202 arg2 = (int)(SWIG_As_int(obj1));
9203 if (SWIG_arg_fail(2)) SWIG_fail;
9204 }
9205 {
9206 arg3 = (int)(SWIG_As_int(obj2));
9207 if (SWIG_arg_fail(3)) SWIG_fail;
9208 }
9209 {
9210 arg4 = (int)(SWIG_As_int(obj3));
9211 if (SWIG_arg_fail(4)) SWIG_fail;
9212 }
9213 if (obj4) {
9214 {
9215 arg5 = (bool)(SWIG_As_bool(obj4));
9216 if (SWIG_arg_fail(5)) SWIG_fail;
9217 }
9218 }
9219 if (obj5) {
9220 {
9221 arg6 = wxString_in_helper(obj5);
9222 if (arg6 == NULL) SWIG_fail;
9223 temp6 = true;
9224 }
9225 }
9226 if (obj6) {
9227 {
9228 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
9229 if (SWIG_arg_fail(7)) SWIG_fail;
9230 }
9231 }
9232 {
9233 if (!wxPyCheckForApp()) SWIG_fail;
9234 PyThreadState* __tstate = wxPyBeginAllowThreads();
9235 result = (wxFont *)new wxFont(arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
9236
9237 wxPyEndAllowThreads(__tstate);
9238 if (PyErr_Occurred()) SWIG_fail;
9239 }
9240 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9241 {
9242 if (temp6)
9243 delete arg6;
9244 }
9245 return resultobj;
9246 fail:
9247 {
9248 if (temp6)
9249 delete arg6;
9250 }
9251 return NULL;
9252 }
9253
9254
9255 static PyObject *_wrap_delete_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9256 PyObject *resultobj;
9257 wxFont *arg1 = (wxFont *) 0 ;
9258 PyObject * obj0 = 0 ;
9259 char *kwnames[] = {
9260 (char *) "self", NULL
9261 };
9262
9263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Font",kwnames,&obj0)) goto fail;
9264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9265 if (SWIG_arg_fail(1)) SWIG_fail;
9266 {
9267 PyThreadState* __tstate = wxPyBeginAllowThreads();
9268 delete arg1;
9269
9270 wxPyEndAllowThreads(__tstate);
9271 if (PyErr_Occurred()) SWIG_fail;
9272 }
9273 Py_INCREF(Py_None); resultobj = Py_None;
9274 return resultobj;
9275 fail:
9276 return NULL;
9277 }
9278
9279
9280 static PyObject *_wrap_new_FontFromNativeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9281 PyObject *resultobj;
9282 wxNativeFontInfo *arg1 = 0 ;
9283 wxFont *result;
9284 PyObject * obj0 = 0 ;
9285 char *kwnames[] = {
9286 (char *) "info", NULL
9287 };
9288
9289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfo",kwnames,&obj0)) goto fail;
9290 {
9291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
9292 if (SWIG_arg_fail(1)) SWIG_fail;
9293 if (arg1 == NULL) {
9294 SWIG_null_ref("wxNativeFontInfo");
9295 }
9296 if (SWIG_arg_fail(1)) SWIG_fail;
9297 }
9298 {
9299 if (!wxPyCheckForApp()) SWIG_fail;
9300 PyThreadState* __tstate = wxPyBeginAllowThreads();
9301 result = (wxFont *)new wxFont((wxNativeFontInfo const &)*arg1);
9302
9303 wxPyEndAllowThreads(__tstate);
9304 if (PyErr_Occurred()) SWIG_fail;
9305 }
9306 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9307 return resultobj;
9308 fail:
9309 return NULL;
9310 }
9311
9312
9313 static PyObject *_wrap_new_FontFromNativeInfoString(PyObject *, PyObject *args, PyObject *kwargs) {
9314 PyObject *resultobj;
9315 wxString *arg1 = 0 ;
9316 wxFont *result;
9317 bool temp1 = false ;
9318 PyObject * obj0 = 0 ;
9319 char *kwnames[] = {
9320 (char *) "info", NULL
9321 };
9322
9323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfoString",kwnames,&obj0)) goto fail;
9324 {
9325 arg1 = wxString_in_helper(obj0);
9326 if (arg1 == NULL) SWIG_fail;
9327 temp1 = true;
9328 }
9329 {
9330 if (!wxPyCheckForApp()) SWIG_fail;
9331 PyThreadState* __tstate = wxPyBeginAllowThreads();
9332 result = (wxFont *)new_wxFont((wxString const &)*arg1);
9333
9334 wxPyEndAllowThreads(__tstate);
9335 if (PyErr_Occurred()) SWIG_fail;
9336 }
9337 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9338 {
9339 if (temp1)
9340 delete arg1;
9341 }
9342 return resultobj;
9343 fail:
9344 {
9345 if (temp1)
9346 delete arg1;
9347 }
9348 return NULL;
9349 }
9350
9351
9352 static PyObject *_wrap_new_Font2(PyObject *, PyObject *args, PyObject *kwargs) {
9353 PyObject *resultobj;
9354 int arg1 ;
9355 wxFontFamily arg2 ;
9356 int arg3 = (int) wxFONTFLAG_DEFAULT ;
9357 wxString const &arg4_defvalue = wxPyEmptyString ;
9358 wxString *arg4 = (wxString *) &arg4_defvalue ;
9359 wxFontEncoding arg5 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9360 wxFont *result;
9361 bool temp4 = false ;
9362 PyObject * obj0 = 0 ;
9363 PyObject * obj1 = 0 ;
9364 PyObject * obj2 = 0 ;
9365 PyObject * obj3 = 0 ;
9366 PyObject * obj4 = 0 ;
9367 char *kwnames[] = {
9368 (char *) "pointSize",(char *) "family",(char *) "flags",(char *) "face",(char *) "encoding", NULL
9369 };
9370
9371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_Font2",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
9372 {
9373 arg1 = (int)(SWIG_As_int(obj0));
9374 if (SWIG_arg_fail(1)) SWIG_fail;
9375 }
9376 {
9377 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
9378 if (SWIG_arg_fail(2)) SWIG_fail;
9379 }
9380 if (obj2) {
9381 {
9382 arg3 = (int)(SWIG_As_int(obj2));
9383 if (SWIG_arg_fail(3)) SWIG_fail;
9384 }
9385 }
9386 if (obj3) {
9387 {
9388 arg4 = wxString_in_helper(obj3);
9389 if (arg4 == NULL) SWIG_fail;
9390 temp4 = true;
9391 }
9392 }
9393 if (obj4) {
9394 {
9395 arg5 = (wxFontEncoding)(SWIG_As_int(obj4));
9396 if (SWIG_arg_fail(5)) SWIG_fail;
9397 }
9398 }
9399 {
9400 if (!wxPyCheckForApp()) SWIG_fail;
9401 PyThreadState* __tstate = wxPyBeginAllowThreads();
9402 result = (wxFont *)new_wxFont(arg1,(wxFontFamily )arg2,arg3,(wxString const &)*arg4,(wxFontEncoding )arg5);
9403
9404 wxPyEndAllowThreads(__tstate);
9405 if (PyErr_Occurred()) SWIG_fail;
9406 }
9407 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9408 {
9409 if (temp4)
9410 delete arg4;
9411 }
9412 return resultobj;
9413 fail:
9414 {
9415 if (temp4)
9416 delete arg4;
9417 }
9418 return NULL;
9419 }
9420
9421
9422 static PyObject *_wrap_new_FontFromPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
9423 PyObject *resultobj;
9424 wxSize *arg1 = 0 ;
9425 int arg2 ;
9426 int arg3 ;
9427 int arg4 ;
9428 bool arg5 = (bool) false ;
9429 wxString const &arg6_defvalue = wxEmptyString ;
9430 wxString *arg6 = (wxString *) &arg6_defvalue ;
9431 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9432 wxFont *result;
9433 wxSize temp1 ;
9434 bool temp6 = false ;
9435 PyObject * obj0 = 0 ;
9436 PyObject * obj1 = 0 ;
9437 PyObject * obj2 = 0 ;
9438 PyObject * obj3 = 0 ;
9439 PyObject * obj4 = 0 ;
9440 PyObject * obj5 = 0 ;
9441 PyObject * obj6 = 0 ;
9442 char *kwnames[] = {
9443 (char *) "pixelSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underlined",(char *) "face",(char *) "encoding", NULL
9444 };
9445
9446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_FontFromPixelSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9447 {
9448 arg1 = &temp1;
9449 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
9450 }
9451 {
9452 arg2 = (int)(SWIG_As_int(obj1));
9453 if (SWIG_arg_fail(2)) SWIG_fail;
9454 }
9455 {
9456 arg3 = (int)(SWIG_As_int(obj2));
9457 if (SWIG_arg_fail(3)) SWIG_fail;
9458 }
9459 {
9460 arg4 = (int)(SWIG_As_int(obj3));
9461 if (SWIG_arg_fail(4)) SWIG_fail;
9462 }
9463 if (obj4) {
9464 {
9465 arg5 = (bool)(SWIG_As_bool(obj4));
9466 if (SWIG_arg_fail(5)) SWIG_fail;
9467 }
9468 }
9469 if (obj5) {
9470 {
9471 arg6 = wxString_in_helper(obj5);
9472 if (arg6 == NULL) SWIG_fail;
9473 temp6 = true;
9474 }
9475 }
9476 if (obj6) {
9477 {
9478 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
9479 if (SWIG_arg_fail(7)) SWIG_fail;
9480 }
9481 }
9482 {
9483 if (!wxPyCheckForApp()) SWIG_fail;
9484 PyThreadState* __tstate = wxPyBeginAllowThreads();
9485 result = (wxFont *)new_wxFont((wxSize const &)*arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
9486
9487 wxPyEndAllowThreads(__tstate);
9488 if (PyErr_Occurred()) SWIG_fail;
9489 }
9490 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9491 {
9492 if (temp6)
9493 delete arg6;
9494 }
9495 return resultobj;
9496 fail:
9497 {
9498 if (temp6)
9499 delete arg6;
9500 }
9501 return NULL;
9502 }
9503
9504
9505 static PyObject *_wrap_Font_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
9506 PyObject *resultobj;
9507 wxFont *arg1 = (wxFont *) 0 ;
9508 bool result;
9509 PyObject * obj0 = 0 ;
9510 char *kwnames[] = {
9511 (char *) "self", NULL
9512 };
9513
9514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_Ok",kwnames,&obj0)) goto fail;
9515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9516 if (SWIG_arg_fail(1)) SWIG_fail;
9517 {
9518 PyThreadState* __tstate = wxPyBeginAllowThreads();
9519 result = (bool)((wxFont const *)arg1)->Ok();
9520
9521 wxPyEndAllowThreads(__tstate);
9522 if (PyErr_Occurred()) SWIG_fail;
9523 }
9524 {
9525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9526 }
9527 return resultobj;
9528 fail:
9529 return NULL;
9530 }
9531
9532
9533 static PyObject *_wrap_Font___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
9534 PyObject *resultobj;
9535 wxFont *arg1 = (wxFont *) 0 ;
9536 wxFont *arg2 = (wxFont *) 0 ;
9537 bool result;
9538 PyObject * obj0 = 0 ;
9539 PyObject * obj1 = 0 ;
9540 char *kwnames[] = {
9541 (char *) "self",(char *) "other", NULL
9542 };
9543
9544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___eq__",kwnames,&obj0,&obj1)) goto fail;
9545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9546 if (SWIG_arg_fail(1)) SWIG_fail;
9547 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9548 if (SWIG_arg_fail(2)) SWIG_fail;
9549 {
9550 PyThreadState* __tstate = wxPyBeginAllowThreads();
9551 result = (bool)wxFont___eq__(arg1,(wxFont const *)arg2);
9552
9553 wxPyEndAllowThreads(__tstate);
9554 if (PyErr_Occurred()) SWIG_fail;
9555 }
9556 {
9557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9558 }
9559 return resultobj;
9560 fail:
9561 return NULL;
9562 }
9563
9564
9565 static PyObject *_wrap_Font___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
9566 PyObject *resultobj;
9567 wxFont *arg1 = (wxFont *) 0 ;
9568 wxFont *arg2 = (wxFont *) 0 ;
9569 bool result;
9570 PyObject * obj0 = 0 ;
9571 PyObject * obj1 = 0 ;
9572 char *kwnames[] = {
9573 (char *) "self",(char *) "other", NULL
9574 };
9575
9576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___ne__",kwnames,&obj0,&obj1)) goto fail;
9577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9578 if (SWIG_arg_fail(1)) SWIG_fail;
9579 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9580 if (SWIG_arg_fail(2)) SWIG_fail;
9581 {
9582 PyThreadState* __tstate = wxPyBeginAllowThreads();
9583 result = (bool)wxFont___ne__(arg1,(wxFont const *)arg2);
9584
9585 wxPyEndAllowThreads(__tstate);
9586 if (PyErr_Occurred()) SWIG_fail;
9587 }
9588 {
9589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9590 }
9591 return resultobj;
9592 fail:
9593 return NULL;
9594 }
9595
9596
9597 static PyObject *_wrap_Font_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
9598 PyObject *resultobj;
9599 wxFont *arg1 = (wxFont *) 0 ;
9600 int result;
9601 PyObject * obj0 = 0 ;
9602 char *kwnames[] = {
9603 (char *) "self", NULL
9604 };
9605
9606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPointSize",kwnames,&obj0)) goto fail;
9607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9608 if (SWIG_arg_fail(1)) SWIG_fail;
9609 {
9610 PyThreadState* __tstate = wxPyBeginAllowThreads();
9611 result = (int)((wxFont const *)arg1)->GetPointSize();
9612
9613 wxPyEndAllowThreads(__tstate);
9614 if (PyErr_Occurred()) SWIG_fail;
9615 }
9616 {
9617 resultobj = SWIG_From_int((int)(result));
9618 }
9619 return resultobj;
9620 fail:
9621 return NULL;
9622 }
9623
9624
9625 static PyObject *_wrap_Font_GetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
9626 PyObject *resultobj;
9627 wxFont *arg1 = (wxFont *) 0 ;
9628 wxSize result;
9629 PyObject * obj0 = 0 ;
9630 char *kwnames[] = {
9631 (char *) "self", NULL
9632 };
9633
9634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPixelSize",kwnames,&obj0)) goto fail;
9635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9636 if (SWIG_arg_fail(1)) SWIG_fail;
9637 {
9638 PyThreadState* __tstate = wxPyBeginAllowThreads();
9639 result = ((wxFont const *)arg1)->GetPixelSize();
9640
9641 wxPyEndAllowThreads(__tstate);
9642 if (PyErr_Occurred()) SWIG_fail;
9643 }
9644 {
9645 wxSize * resultptr;
9646 resultptr = new wxSize((wxSize &)(result));
9647 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
9648 }
9649 return resultobj;
9650 fail:
9651 return NULL;
9652 }
9653
9654
9655 static PyObject *_wrap_Font_IsUsingSizeInPixels(PyObject *, PyObject *args, PyObject *kwargs) {
9656 PyObject *resultobj;
9657 wxFont *arg1 = (wxFont *) 0 ;
9658 bool result;
9659 PyObject * obj0 = 0 ;
9660 char *kwnames[] = {
9661 (char *) "self", NULL
9662 };
9663
9664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsUsingSizeInPixels",kwnames,&obj0)) goto fail;
9665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9666 if (SWIG_arg_fail(1)) SWIG_fail;
9667 {
9668 PyThreadState* __tstate = wxPyBeginAllowThreads();
9669 result = (bool)((wxFont const *)arg1)->IsUsingSizeInPixels();
9670
9671 wxPyEndAllowThreads(__tstate);
9672 if (PyErr_Occurred()) SWIG_fail;
9673 }
9674 {
9675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9676 }
9677 return resultobj;
9678 fail:
9679 return NULL;
9680 }
9681
9682
9683 static PyObject *_wrap_Font_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
9684 PyObject *resultobj;
9685 wxFont *arg1 = (wxFont *) 0 ;
9686 int result;
9687 PyObject * obj0 = 0 ;
9688 char *kwnames[] = {
9689 (char *) "self", NULL
9690 };
9691
9692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamily",kwnames,&obj0)) goto fail;
9693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9694 if (SWIG_arg_fail(1)) SWIG_fail;
9695 {
9696 PyThreadState* __tstate = wxPyBeginAllowThreads();
9697 result = (int)((wxFont const *)arg1)->GetFamily();
9698
9699 wxPyEndAllowThreads(__tstate);
9700 if (PyErr_Occurred()) SWIG_fail;
9701 }
9702 {
9703 resultobj = SWIG_From_int((int)(result));
9704 }
9705 return resultobj;
9706 fail:
9707 return NULL;
9708 }
9709
9710
9711 static PyObject *_wrap_Font_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
9712 PyObject *resultobj;
9713 wxFont *arg1 = (wxFont *) 0 ;
9714 int result;
9715 PyObject * obj0 = 0 ;
9716 char *kwnames[] = {
9717 (char *) "self", NULL
9718 };
9719
9720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyle",kwnames,&obj0)) goto fail;
9721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9722 if (SWIG_arg_fail(1)) SWIG_fail;
9723 {
9724 PyThreadState* __tstate = wxPyBeginAllowThreads();
9725 result = (int)((wxFont const *)arg1)->GetStyle();
9726
9727 wxPyEndAllowThreads(__tstate);
9728 if (PyErr_Occurred()) SWIG_fail;
9729 }
9730 {
9731 resultobj = SWIG_From_int((int)(result));
9732 }
9733 return resultobj;
9734 fail:
9735 return NULL;
9736 }
9737
9738
9739 static PyObject *_wrap_Font_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
9740 PyObject *resultobj;
9741 wxFont *arg1 = (wxFont *) 0 ;
9742 int result;
9743 PyObject * obj0 = 0 ;
9744 char *kwnames[] = {
9745 (char *) "self", NULL
9746 };
9747
9748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeight",kwnames,&obj0)) goto fail;
9749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9750 if (SWIG_arg_fail(1)) SWIG_fail;
9751 {
9752 PyThreadState* __tstate = wxPyBeginAllowThreads();
9753 result = (int)((wxFont const *)arg1)->GetWeight();
9754
9755 wxPyEndAllowThreads(__tstate);
9756 if (PyErr_Occurred()) SWIG_fail;
9757 }
9758 {
9759 resultobj = SWIG_From_int((int)(result));
9760 }
9761 return resultobj;
9762 fail:
9763 return NULL;
9764 }
9765
9766
9767 static PyObject *_wrap_Font_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
9768 PyObject *resultobj;
9769 wxFont *arg1 = (wxFont *) 0 ;
9770 bool result;
9771 PyObject * obj0 = 0 ;
9772 char *kwnames[] = {
9773 (char *) "self", NULL
9774 };
9775
9776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetUnderlined",kwnames,&obj0)) goto fail;
9777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9778 if (SWIG_arg_fail(1)) SWIG_fail;
9779 {
9780 PyThreadState* __tstate = wxPyBeginAllowThreads();
9781 result = (bool)((wxFont const *)arg1)->GetUnderlined();
9782
9783 wxPyEndAllowThreads(__tstate);
9784 if (PyErr_Occurred()) SWIG_fail;
9785 }
9786 {
9787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9788 }
9789 return resultobj;
9790 fail:
9791 return NULL;
9792 }
9793
9794
9795 static PyObject *_wrap_Font_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
9796 PyObject *resultobj;
9797 wxFont *arg1 = (wxFont *) 0 ;
9798 wxString result;
9799 PyObject * obj0 = 0 ;
9800 char *kwnames[] = {
9801 (char *) "self", NULL
9802 };
9803
9804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFaceName",kwnames,&obj0)) goto fail;
9805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9806 if (SWIG_arg_fail(1)) SWIG_fail;
9807 {
9808 PyThreadState* __tstate = wxPyBeginAllowThreads();
9809 result = ((wxFont const *)arg1)->GetFaceName();
9810
9811 wxPyEndAllowThreads(__tstate);
9812 if (PyErr_Occurred()) SWIG_fail;
9813 }
9814 {
9815 #if wxUSE_UNICODE
9816 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9817 #else
9818 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9819 #endif
9820 }
9821 return resultobj;
9822 fail:
9823 return NULL;
9824 }
9825
9826
9827 static PyObject *_wrap_Font_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9828 PyObject *resultobj;
9829 wxFont *arg1 = (wxFont *) 0 ;
9830 wxFontEncoding result;
9831 PyObject * obj0 = 0 ;
9832 char *kwnames[] = {
9833 (char *) "self", NULL
9834 };
9835
9836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetEncoding",kwnames,&obj0)) goto fail;
9837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9838 if (SWIG_arg_fail(1)) SWIG_fail;
9839 {
9840 PyThreadState* __tstate = wxPyBeginAllowThreads();
9841 result = (wxFontEncoding)((wxFont const *)arg1)->GetEncoding();
9842
9843 wxPyEndAllowThreads(__tstate);
9844 if (PyErr_Occurred()) SWIG_fail;
9845 }
9846 resultobj = SWIG_From_int((result));
9847 return resultobj;
9848 fail:
9849 return NULL;
9850 }
9851
9852
9853 static PyObject *_wrap_Font_GetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9854 PyObject *resultobj;
9855 wxFont *arg1 = (wxFont *) 0 ;
9856 wxNativeFontInfo *result;
9857 PyObject * obj0 = 0 ;
9858 char *kwnames[] = {
9859 (char *) "self", NULL
9860 };
9861
9862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfo",kwnames,&obj0)) goto fail;
9863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9864 if (SWIG_arg_fail(1)) SWIG_fail;
9865 {
9866 PyThreadState* __tstate = wxPyBeginAllowThreads();
9867 result = (wxNativeFontInfo *)((wxFont const *)arg1)->GetNativeFontInfo();
9868
9869 wxPyEndAllowThreads(__tstate);
9870 if (PyErr_Occurred()) SWIG_fail;
9871 }
9872 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 0);
9873 return resultobj;
9874 fail:
9875 return NULL;
9876 }
9877
9878
9879 static PyObject *_wrap_Font_IsFixedWidth(PyObject *, PyObject *args, PyObject *kwargs) {
9880 PyObject *resultobj;
9881 wxFont *arg1 = (wxFont *) 0 ;
9882 bool result;
9883 PyObject * obj0 = 0 ;
9884 char *kwnames[] = {
9885 (char *) "self", NULL
9886 };
9887
9888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsFixedWidth",kwnames,&obj0)) goto fail;
9889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9890 if (SWIG_arg_fail(1)) SWIG_fail;
9891 {
9892 PyThreadState* __tstate = wxPyBeginAllowThreads();
9893 result = (bool)((wxFont const *)arg1)->IsFixedWidth();
9894
9895 wxPyEndAllowThreads(__tstate);
9896 if (PyErr_Occurred()) SWIG_fail;
9897 }
9898 {
9899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9900 }
9901 return resultobj;
9902 fail:
9903 return NULL;
9904 }
9905
9906
9907 static PyObject *_wrap_Font_GetNativeFontInfoDesc(PyObject *, PyObject *args, PyObject *kwargs) {
9908 PyObject *resultobj;
9909 wxFont *arg1 = (wxFont *) 0 ;
9910 wxString result;
9911 PyObject * obj0 = 0 ;
9912 char *kwnames[] = {
9913 (char *) "self", NULL
9914 };
9915
9916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoDesc",kwnames,&obj0)) goto fail;
9917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9918 if (SWIG_arg_fail(1)) SWIG_fail;
9919 {
9920 PyThreadState* __tstate = wxPyBeginAllowThreads();
9921 result = ((wxFont const *)arg1)->GetNativeFontInfoDesc();
9922
9923 wxPyEndAllowThreads(__tstate);
9924 if (PyErr_Occurred()) SWIG_fail;
9925 }
9926 {
9927 #if wxUSE_UNICODE
9928 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9929 #else
9930 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9931 #endif
9932 }
9933 return resultobj;
9934 fail:
9935 return NULL;
9936 }
9937
9938
9939 static PyObject *_wrap_Font_GetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
9940 PyObject *resultobj;
9941 wxFont *arg1 = (wxFont *) 0 ;
9942 wxString result;
9943 PyObject * obj0 = 0 ;
9944 char *kwnames[] = {
9945 (char *) "self", NULL
9946 };
9947
9948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoUserDesc",kwnames,&obj0)) goto fail;
9949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9950 if (SWIG_arg_fail(1)) SWIG_fail;
9951 {
9952 PyThreadState* __tstate = wxPyBeginAllowThreads();
9953 result = ((wxFont const *)arg1)->GetNativeFontInfoUserDesc();
9954
9955 wxPyEndAllowThreads(__tstate);
9956 if (PyErr_Occurred()) SWIG_fail;
9957 }
9958 {
9959 #if wxUSE_UNICODE
9960 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9961 #else
9962 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9963 #endif
9964 }
9965 return resultobj;
9966 fail:
9967 return NULL;
9968 }
9969
9970
9971 static PyObject *_wrap_Font_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
9972 PyObject *resultobj;
9973 wxFont *arg1 = (wxFont *) 0 ;
9974 int arg2 ;
9975 PyObject * obj0 = 0 ;
9976 PyObject * obj1 = 0 ;
9977 char *kwnames[] = {
9978 (char *) "self",(char *) "pointSize", NULL
9979 };
9980
9981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
9982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9983 if (SWIG_arg_fail(1)) SWIG_fail;
9984 {
9985 arg2 = (int)(SWIG_As_int(obj1));
9986 if (SWIG_arg_fail(2)) SWIG_fail;
9987 }
9988 {
9989 PyThreadState* __tstate = wxPyBeginAllowThreads();
9990 (arg1)->SetPointSize(arg2);
9991
9992 wxPyEndAllowThreads(__tstate);
9993 if (PyErr_Occurred()) SWIG_fail;
9994 }
9995 Py_INCREF(Py_None); resultobj = Py_None;
9996 return resultobj;
9997 fail:
9998 return NULL;
9999 }
10000
10001
10002 static PyObject *_wrap_Font_SetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
10003 PyObject *resultobj;
10004 wxFont *arg1 = (wxFont *) 0 ;
10005 wxSize *arg2 = 0 ;
10006 wxSize temp2 ;
10007 PyObject * obj0 = 0 ;
10008 PyObject * obj1 = 0 ;
10009 char *kwnames[] = {
10010 (char *) "self",(char *) "pixelSize", NULL
10011 };
10012
10013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPixelSize",kwnames,&obj0,&obj1)) goto fail;
10014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10015 if (SWIG_arg_fail(1)) SWIG_fail;
10016 {
10017 arg2 = &temp2;
10018 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
10019 }
10020 {
10021 PyThreadState* __tstate = wxPyBeginAllowThreads();
10022 (arg1)->SetPixelSize((wxSize const &)*arg2);
10023
10024 wxPyEndAllowThreads(__tstate);
10025 if (PyErr_Occurred()) SWIG_fail;
10026 }
10027 Py_INCREF(Py_None); resultobj = Py_None;
10028 return resultobj;
10029 fail:
10030 return NULL;
10031 }
10032
10033
10034 static PyObject *_wrap_Font_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
10035 PyObject *resultobj;
10036 wxFont *arg1 = (wxFont *) 0 ;
10037 int arg2 ;
10038 PyObject * obj0 = 0 ;
10039 PyObject * obj1 = 0 ;
10040 char *kwnames[] = {
10041 (char *) "self",(char *) "family", NULL
10042 };
10043
10044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFamily",kwnames,&obj0,&obj1)) goto fail;
10045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10046 if (SWIG_arg_fail(1)) SWIG_fail;
10047 {
10048 arg2 = (int)(SWIG_As_int(obj1));
10049 if (SWIG_arg_fail(2)) SWIG_fail;
10050 }
10051 {
10052 PyThreadState* __tstate = wxPyBeginAllowThreads();
10053 (arg1)->SetFamily(arg2);
10054
10055 wxPyEndAllowThreads(__tstate);
10056 if (PyErr_Occurred()) SWIG_fail;
10057 }
10058 Py_INCREF(Py_None); resultobj = Py_None;
10059 return resultobj;
10060 fail:
10061 return NULL;
10062 }
10063
10064
10065 static PyObject *_wrap_Font_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
10066 PyObject *resultobj;
10067 wxFont *arg1 = (wxFont *) 0 ;
10068 int arg2 ;
10069 PyObject * obj0 = 0 ;
10070 PyObject * obj1 = 0 ;
10071 char *kwnames[] = {
10072 (char *) "self",(char *) "style", NULL
10073 };
10074
10075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetStyle",kwnames,&obj0,&obj1)) goto fail;
10076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10077 if (SWIG_arg_fail(1)) SWIG_fail;
10078 {
10079 arg2 = (int)(SWIG_As_int(obj1));
10080 if (SWIG_arg_fail(2)) SWIG_fail;
10081 }
10082 {
10083 PyThreadState* __tstate = wxPyBeginAllowThreads();
10084 (arg1)->SetStyle(arg2);
10085
10086 wxPyEndAllowThreads(__tstate);
10087 if (PyErr_Occurred()) SWIG_fail;
10088 }
10089 Py_INCREF(Py_None); resultobj = Py_None;
10090 return resultobj;
10091 fail:
10092 return NULL;
10093 }
10094
10095
10096 static PyObject *_wrap_Font_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
10097 PyObject *resultobj;
10098 wxFont *arg1 = (wxFont *) 0 ;
10099 int arg2 ;
10100 PyObject * obj0 = 0 ;
10101 PyObject * obj1 = 0 ;
10102 char *kwnames[] = {
10103 (char *) "self",(char *) "weight", NULL
10104 };
10105
10106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetWeight",kwnames,&obj0,&obj1)) goto fail;
10107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10108 if (SWIG_arg_fail(1)) SWIG_fail;
10109 {
10110 arg2 = (int)(SWIG_As_int(obj1));
10111 if (SWIG_arg_fail(2)) SWIG_fail;
10112 }
10113 {
10114 PyThreadState* __tstate = wxPyBeginAllowThreads();
10115 (arg1)->SetWeight(arg2);
10116
10117 wxPyEndAllowThreads(__tstate);
10118 if (PyErr_Occurred()) SWIG_fail;
10119 }
10120 Py_INCREF(Py_None); resultobj = Py_None;
10121 return resultobj;
10122 fail:
10123 return NULL;
10124 }
10125
10126
10127 static PyObject *_wrap_Font_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
10128 PyObject *resultobj;
10129 wxFont *arg1 = (wxFont *) 0 ;
10130 wxString *arg2 = 0 ;
10131 bool temp2 = false ;
10132 PyObject * obj0 = 0 ;
10133 PyObject * obj1 = 0 ;
10134 char *kwnames[] = {
10135 (char *) "self",(char *) "faceName", NULL
10136 };
10137
10138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
10139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10140 if (SWIG_arg_fail(1)) SWIG_fail;
10141 {
10142 arg2 = wxString_in_helper(obj1);
10143 if (arg2 == NULL) SWIG_fail;
10144 temp2 = true;
10145 }
10146 {
10147 PyThreadState* __tstate = wxPyBeginAllowThreads();
10148 (arg1)->SetFaceName((wxString const &)*arg2);
10149
10150 wxPyEndAllowThreads(__tstate);
10151 if (PyErr_Occurred()) SWIG_fail;
10152 }
10153 Py_INCREF(Py_None); resultobj = Py_None;
10154 {
10155 if (temp2)
10156 delete arg2;
10157 }
10158 return resultobj;
10159 fail:
10160 {
10161 if (temp2)
10162 delete arg2;
10163 }
10164 return NULL;
10165 }
10166
10167
10168 static PyObject *_wrap_Font_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
10169 PyObject *resultobj;
10170 wxFont *arg1 = (wxFont *) 0 ;
10171 bool arg2 ;
10172 PyObject * obj0 = 0 ;
10173 PyObject * obj1 = 0 ;
10174 char *kwnames[] = {
10175 (char *) "self",(char *) "underlined", NULL
10176 };
10177
10178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
10179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10180 if (SWIG_arg_fail(1)) SWIG_fail;
10181 {
10182 arg2 = (bool)(SWIG_As_bool(obj1));
10183 if (SWIG_arg_fail(2)) SWIG_fail;
10184 }
10185 {
10186 PyThreadState* __tstate = wxPyBeginAllowThreads();
10187 (arg1)->SetUnderlined(arg2);
10188
10189 wxPyEndAllowThreads(__tstate);
10190 if (PyErr_Occurred()) SWIG_fail;
10191 }
10192 Py_INCREF(Py_None); resultobj = Py_None;
10193 return resultobj;
10194 fail:
10195 return NULL;
10196 }
10197
10198
10199 static PyObject *_wrap_Font_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10200 PyObject *resultobj;
10201 wxFont *arg1 = (wxFont *) 0 ;
10202 wxFontEncoding arg2 ;
10203 PyObject * obj0 = 0 ;
10204 PyObject * obj1 = 0 ;
10205 char *kwnames[] = {
10206 (char *) "self",(char *) "encoding", NULL
10207 };
10208
10209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
10210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10211 if (SWIG_arg_fail(1)) SWIG_fail;
10212 {
10213 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
10214 if (SWIG_arg_fail(2)) SWIG_fail;
10215 }
10216 {
10217 PyThreadState* __tstate = wxPyBeginAllowThreads();
10218 (arg1)->SetEncoding((wxFontEncoding )arg2);
10219
10220 wxPyEndAllowThreads(__tstate);
10221 if (PyErr_Occurred()) SWIG_fail;
10222 }
10223 Py_INCREF(Py_None); resultobj = Py_None;
10224 return resultobj;
10225 fail:
10226 return NULL;
10227 }
10228
10229
10230 static PyObject *_wrap_Font_SetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10231 PyObject *resultobj;
10232 wxFont *arg1 = (wxFont *) 0 ;
10233 wxNativeFontInfo *arg2 = 0 ;
10234 PyObject * obj0 = 0 ;
10235 PyObject * obj1 = 0 ;
10236 char *kwnames[] = {
10237 (char *) "self",(char *) "info", NULL
10238 };
10239
10240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfo",kwnames,&obj0,&obj1)) goto fail;
10241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10242 if (SWIG_arg_fail(1)) SWIG_fail;
10243 {
10244 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
10245 if (SWIG_arg_fail(2)) SWIG_fail;
10246 if (arg2 == NULL) {
10247 SWIG_null_ref("wxNativeFontInfo");
10248 }
10249 if (SWIG_arg_fail(2)) SWIG_fail;
10250 }
10251 {
10252 PyThreadState* __tstate = wxPyBeginAllowThreads();
10253 (arg1)->SetNativeFontInfo((wxNativeFontInfo const &)*arg2);
10254
10255 wxPyEndAllowThreads(__tstate);
10256 if (PyErr_Occurred()) SWIG_fail;
10257 }
10258 Py_INCREF(Py_None); resultobj = Py_None;
10259 return resultobj;
10260 fail:
10261 return NULL;
10262 }
10263
10264
10265 static PyObject *_wrap_Font_SetNativeFontInfoFromString(PyObject *, PyObject *args, PyObject *kwargs) {
10266 PyObject *resultobj;
10267 wxFont *arg1 = (wxFont *) 0 ;
10268 wxString *arg2 = 0 ;
10269 bool temp2 = false ;
10270 PyObject * obj0 = 0 ;
10271 PyObject * obj1 = 0 ;
10272 char *kwnames[] = {
10273 (char *) "self",(char *) "info", NULL
10274 };
10275
10276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoFromString",kwnames,&obj0,&obj1)) goto fail;
10277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10278 if (SWIG_arg_fail(1)) SWIG_fail;
10279 {
10280 arg2 = wxString_in_helper(obj1);
10281 if (arg2 == NULL) SWIG_fail;
10282 temp2 = true;
10283 }
10284 {
10285 PyThreadState* __tstate = wxPyBeginAllowThreads();
10286 (arg1)->SetNativeFontInfo((wxString const &)*arg2);
10287
10288 wxPyEndAllowThreads(__tstate);
10289 if (PyErr_Occurred()) SWIG_fail;
10290 }
10291 Py_INCREF(Py_None); resultobj = Py_None;
10292 {
10293 if (temp2)
10294 delete arg2;
10295 }
10296 return resultobj;
10297 fail:
10298 {
10299 if (temp2)
10300 delete arg2;
10301 }
10302 return NULL;
10303 }
10304
10305
10306 static PyObject *_wrap_Font_SetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10307 PyObject *resultobj;
10308 wxFont *arg1 = (wxFont *) 0 ;
10309 wxString *arg2 = 0 ;
10310 bool temp2 = false ;
10311 PyObject * obj0 = 0 ;
10312 PyObject * obj1 = 0 ;
10313 char *kwnames[] = {
10314 (char *) "self",(char *) "info", NULL
10315 };
10316
10317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoUserDesc",kwnames,&obj0,&obj1)) goto fail;
10318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10319 if (SWIG_arg_fail(1)) SWIG_fail;
10320 {
10321 arg2 = wxString_in_helper(obj1);
10322 if (arg2 == NULL) SWIG_fail;
10323 temp2 = true;
10324 }
10325 {
10326 PyThreadState* __tstate = wxPyBeginAllowThreads();
10327 (arg1)->SetNativeFontInfoUserDesc((wxString const &)*arg2);
10328
10329 wxPyEndAllowThreads(__tstate);
10330 if (PyErr_Occurred()) SWIG_fail;
10331 }
10332 Py_INCREF(Py_None); resultobj = Py_None;
10333 {
10334 if (temp2)
10335 delete arg2;
10336 }
10337 return resultobj;
10338 fail:
10339 {
10340 if (temp2)
10341 delete arg2;
10342 }
10343 return NULL;
10344 }
10345
10346
10347 static PyObject *_wrap_Font_GetFamilyString(PyObject *, PyObject *args, PyObject *kwargs) {
10348 PyObject *resultobj;
10349 wxFont *arg1 = (wxFont *) 0 ;
10350 wxString result;
10351 PyObject * obj0 = 0 ;
10352 char *kwnames[] = {
10353 (char *) "self", NULL
10354 };
10355
10356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamilyString",kwnames,&obj0)) goto fail;
10357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10358 if (SWIG_arg_fail(1)) SWIG_fail;
10359 {
10360 PyThreadState* __tstate = wxPyBeginAllowThreads();
10361 result = ((wxFont const *)arg1)->GetFamilyString();
10362
10363 wxPyEndAllowThreads(__tstate);
10364 if (PyErr_Occurred()) SWIG_fail;
10365 }
10366 {
10367 #if wxUSE_UNICODE
10368 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10369 #else
10370 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10371 #endif
10372 }
10373 return resultobj;
10374 fail:
10375 return NULL;
10376 }
10377
10378
10379 static PyObject *_wrap_Font_GetStyleString(PyObject *, PyObject *args, PyObject *kwargs) {
10380 PyObject *resultobj;
10381 wxFont *arg1 = (wxFont *) 0 ;
10382 wxString result;
10383 PyObject * obj0 = 0 ;
10384 char *kwnames[] = {
10385 (char *) "self", NULL
10386 };
10387
10388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyleString",kwnames,&obj0)) goto fail;
10389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10390 if (SWIG_arg_fail(1)) SWIG_fail;
10391 {
10392 PyThreadState* __tstate = wxPyBeginAllowThreads();
10393 result = ((wxFont const *)arg1)->GetStyleString();
10394
10395 wxPyEndAllowThreads(__tstate);
10396 if (PyErr_Occurred()) SWIG_fail;
10397 }
10398 {
10399 #if wxUSE_UNICODE
10400 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10401 #else
10402 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10403 #endif
10404 }
10405 return resultobj;
10406 fail:
10407 return NULL;
10408 }
10409
10410
10411 static PyObject *_wrap_Font_GetWeightString(PyObject *, PyObject *args, PyObject *kwargs) {
10412 PyObject *resultobj;
10413 wxFont *arg1 = (wxFont *) 0 ;
10414 wxString result;
10415 PyObject * obj0 = 0 ;
10416 char *kwnames[] = {
10417 (char *) "self", NULL
10418 };
10419
10420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeightString",kwnames,&obj0)) goto fail;
10421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10422 if (SWIG_arg_fail(1)) SWIG_fail;
10423 {
10424 PyThreadState* __tstate = wxPyBeginAllowThreads();
10425 result = ((wxFont const *)arg1)->GetWeightString();
10426
10427 wxPyEndAllowThreads(__tstate);
10428 if (PyErr_Occurred()) SWIG_fail;
10429 }
10430 {
10431 #if wxUSE_UNICODE
10432 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10433 #else
10434 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10435 #endif
10436 }
10437 return resultobj;
10438 fail:
10439 return NULL;
10440 }
10441
10442
10443 static PyObject *_wrap_Font_SetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
10444 PyObject *resultobj;
10445 wxFont *arg1 = (wxFont *) 0 ;
10446 bool arg2 = (bool) true ;
10447 PyObject * obj0 = 0 ;
10448 PyObject * obj1 = 0 ;
10449 char *kwnames[] = {
10450 (char *) "self",(char *) "no", NULL
10451 };
10452
10453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Font_SetNoAntiAliasing",kwnames,&obj0,&obj1)) goto fail;
10454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10455 if (SWIG_arg_fail(1)) SWIG_fail;
10456 if (obj1) {
10457 {
10458 arg2 = (bool)(SWIG_As_bool(obj1));
10459 if (SWIG_arg_fail(2)) SWIG_fail;
10460 }
10461 }
10462 {
10463 PyThreadState* __tstate = wxPyBeginAllowThreads();
10464 (arg1)->SetNoAntiAliasing(arg2);
10465
10466 wxPyEndAllowThreads(__tstate);
10467 if (PyErr_Occurred()) SWIG_fail;
10468 }
10469 Py_INCREF(Py_None); resultobj = Py_None;
10470 return resultobj;
10471 fail:
10472 return NULL;
10473 }
10474
10475
10476 static PyObject *_wrap_Font_GetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
10477 PyObject *resultobj;
10478 wxFont *arg1 = (wxFont *) 0 ;
10479 bool result;
10480 PyObject * obj0 = 0 ;
10481 char *kwnames[] = {
10482 (char *) "self", NULL
10483 };
10484
10485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNoAntiAliasing",kwnames,&obj0)) goto fail;
10486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10487 if (SWIG_arg_fail(1)) SWIG_fail;
10488 {
10489 PyThreadState* __tstate = wxPyBeginAllowThreads();
10490 result = (bool)((wxFont const *)arg1)->GetNoAntiAliasing();
10491
10492 wxPyEndAllowThreads(__tstate);
10493 if (PyErr_Occurred()) SWIG_fail;
10494 }
10495 {
10496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10497 }
10498 return resultobj;
10499 fail:
10500 return NULL;
10501 }
10502
10503
10504 static PyObject *_wrap_Font_GetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10505 PyObject *resultobj;
10506 wxFontEncoding result;
10507 char *kwnames[] = {
10508 NULL
10509 };
10510
10511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Font_GetDefaultEncoding",kwnames)) goto fail;
10512 {
10513 if (!wxPyCheckForApp()) SWIG_fail;
10514 PyThreadState* __tstate = wxPyBeginAllowThreads();
10515 result = (wxFontEncoding)wxFont::GetDefaultEncoding();
10516
10517 wxPyEndAllowThreads(__tstate);
10518 if (PyErr_Occurred()) SWIG_fail;
10519 }
10520 resultobj = SWIG_From_int((result));
10521 return resultobj;
10522 fail:
10523 return NULL;
10524 }
10525
10526
10527 static PyObject *_wrap_Font_SetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10528 PyObject *resultobj;
10529 wxFontEncoding arg1 ;
10530 PyObject * obj0 = 0 ;
10531 char *kwnames[] = {
10532 (char *) "encoding", NULL
10533 };
10534
10535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_SetDefaultEncoding",kwnames,&obj0)) goto fail;
10536 {
10537 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
10538 if (SWIG_arg_fail(1)) SWIG_fail;
10539 }
10540 {
10541 if (!wxPyCheckForApp()) SWIG_fail;
10542 PyThreadState* __tstate = wxPyBeginAllowThreads();
10543 wxFont::SetDefaultEncoding((wxFontEncoding )arg1);
10544
10545 wxPyEndAllowThreads(__tstate);
10546 if (PyErr_Occurred()) SWIG_fail;
10547 }
10548 Py_INCREF(Py_None); resultobj = Py_None;
10549 return resultobj;
10550 fail:
10551 return NULL;
10552 }
10553
10554
10555 static PyObject * Font_swigregister(PyObject *, PyObject *args) {
10556 PyObject *obj;
10557 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10558 SWIG_TypeClientData(SWIGTYPE_p_wxFont, obj);
10559 Py_INCREF(obj);
10560 return Py_BuildValue((char *)"");
10561 }
10562 static PyObject *_wrap_new_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
10563 PyObject *resultobj;
10564 wxPyFontEnumerator *result;
10565 char *kwnames[] = {
10566 NULL
10567 };
10568
10569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontEnumerator",kwnames)) goto fail;
10570 {
10571 if (!wxPyCheckForApp()) SWIG_fail;
10572 PyThreadState* __tstate = wxPyBeginAllowThreads();
10573 result = (wxPyFontEnumerator *)new wxPyFontEnumerator();
10574
10575 wxPyEndAllowThreads(__tstate);
10576 if (PyErr_Occurred()) SWIG_fail;
10577 }
10578 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFontEnumerator, 1);
10579 return resultobj;
10580 fail:
10581 return NULL;
10582 }
10583
10584
10585 static PyObject *_wrap_delete_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
10586 PyObject *resultobj;
10587 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10588 PyObject * obj0 = 0 ;
10589 char *kwnames[] = {
10590 (char *) "self", NULL
10591 };
10592
10593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontEnumerator",kwnames,&obj0)) goto fail;
10594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10595 if (SWIG_arg_fail(1)) SWIG_fail;
10596 {
10597 PyThreadState* __tstate = wxPyBeginAllowThreads();
10598 delete arg1;
10599
10600 wxPyEndAllowThreads(__tstate);
10601 if (PyErr_Occurred()) SWIG_fail;
10602 }
10603 Py_INCREF(Py_None); resultobj = Py_None;
10604 return resultobj;
10605 fail:
10606 return NULL;
10607 }
10608
10609
10610 static PyObject *_wrap_FontEnumerator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10611 PyObject *resultobj;
10612 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10613 PyObject *arg2 = (PyObject *) 0 ;
10614 PyObject *arg3 = (PyObject *) 0 ;
10615 bool arg4 ;
10616 PyObject * obj0 = 0 ;
10617 PyObject * obj1 = 0 ;
10618 PyObject * obj2 = 0 ;
10619 PyObject * obj3 = 0 ;
10620 char *kwnames[] = {
10621 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
10622 };
10623
10624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FontEnumerator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10626 if (SWIG_arg_fail(1)) SWIG_fail;
10627 arg2 = obj1;
10628 arg3 = obj2;
10629 {
10630 arg4 = (bool)(SWIG_As_bool(obj3));
10631 if (SWIG_arg_fail(4)) SWIG_fail;
10632 }
10633 {
10634 PyThreadState* __tstate = wxPyBeginAllowThreads();
10635 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
10636
10637 wxPyEndAllowThreads(__tstate);
10638 if (PyErr_Occurred()) SWIG_fail;
10639 }
10640 Py_INCREF(Py_None); resultobj = Py_None;
10641 return resultobj;
10642 fail:
10643 return NULL;
10644 }
10645
10646
10647 static PyObject *_wrap_FontEnumerator_EnumerateFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
10648 PyObject *resultobj;
10649 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10650 wxFontEncoding arg2 = (wxFontEncoding) wxFONTENCODING_SYSTEM ;
10651 bool arg3 = (bool) false ;
10652 bool result;
10653 PyObject * obj0 = 0 ;
10654 PyObject * obj1 = 0 ;
10655 PyObject * obj2 = 0 ;
10656 char *kwnames[] = {
10657 (char *) "self",(char *) "encoding",(char *) "fixedWidthOnly", NULL
10658 };
10659
10660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FontEnumerator_EnumerateFacenames",kwnames,&obj0,&obj1,&obj2)) goto fail;
10661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10662 if (SWIG_arg_fail(1)) SWIG_fail;
10663 if (obj1) {
10664 {
10665 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
10666 if (SWIG_arg_fail(2)) SWIG_fail;
10667 }
10668 }
10669 if (obj2) {
10670 {
10671 arg3 = (bool)(SWIG_As_bool(obj2));
10672 if (SWIG_arg_fail(3)) SWIG_fail;
10673 }
10674 }
10675 {
10676 PyThreadState* __tstate = wxPyBeginAllowThreads();
10677 result = (bool)(arg1)->EnumerateFacenames((wxFontEncoding )arg2,arg3);
10678
10679 wxPyEndAllowThreads(__tstate);
10680 if (PyErr_Occurred()) SWIG_fail;
10681 }
10682 {
10683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10684 }
10685 return resultobj;
10686 fail:
10687 return NULL;
10688 }
10689
10690
10691 static PyObject *_wrap_FontEnumerator_EnumerateEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
10692 PyObject *resultobj;
10693 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10694 wxString const &arg2_defvalue = wxPyEmptyString ;
10695 wxString *arg2 = (wxString *) &arg2_defvalue ;
10696 bool result;
10697 bool temp2 = false ;
10698 PyObject * obj0 = 0 ;
10699 PyObject * obj1 = 0 ;
10700 char *kwnames[] = {
10701 (char *) "self",(char *) "facename", NULL
10702 };
10703
10704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FontEnumerator_EnumerateEncodings",kwnames,&obj0,&obj1)) goto fail;
10705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10706 if (SWIG_arg_fail(1)) SWIG_fail;
10707 if (obj1) {
10708 {
10709 arg2 = wxString_in_helper(obj1);
10710 if (arg2 == NULL) SWIG_fail;
10711 temp2 = true;
10712 }
10713 }
10714 {
10715 PyThreadState* __tstate = wxPyBeginAllowThreads();
10716 result = (bool)(arg1)->EnumerateEncodings((wxString const &)*arg2);
10717
10718 wxPyEndAllowThreads(__tstate);
10719 if (PyErr_Occurred()) SWIG_fail;
10720 }
10721 {
10722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10723 }
10724 {
10725 if (temp2)
10726 delete arg2;
10727 }
10728 return resultobj;
10729 fail:
10730 {
10731 if (temp2)
10732 delete arg2;
10733 }
10734 return NULL;
10735 }
10736
10737
10738 static PyObject *_wrap_FontEnumerator_GetEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
10739 PyObject *resultobj;
10740 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10741 PyObject *result;
10742 PyObject * obj0 = 0 ;
10743 char *kwnames[] = {
10744 (char *) "self", NULL
10745 };
10746
10747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetEncodings",kwnames,&obj0)) goto fail;
10748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10749 if (SWIG_arg_fail(1)) SWIG_fail;
10750 {
10751 PyThreadState* __tstate = wxPyBeginAllowThreads();
10752 result = (PyObject *)wxPyFontEnumerator_GetEncodings(arg1);
10753
10754 wxPyEndAllowThreads(__tstate);
10755 if (PyErr_Occurred()) SWIG_fail;
10756 }
10757 resultobj = result;
10758 return resultobj;
10759 fail:
10760 return NULL;
10761 }
10762
10763
10764 static PyObject *_wrap_FontEnumerator_GetFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
10765 PyObject *resultobj;
10766 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10767 PyObject *result;
10768 PyObject * obj0 = 0 ;
10769 char *kwnames[] = {
10770 (char *) "self", NULL
10771 };
10772
10773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetFacenames",kwnames,&obj0)) goto fail;
10774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10775 if (SWIG_arg_fail(1)) SWIG_fail;
10776 {
10777 PyThreadState* __tstate = wxPyBeginAllowThreads();
10778 result = (PyObject *)wxPyFontEnumerator_GetFacenames(arg1);
10779
10780 wxPyEndAllowThreads(__tstate);
10781 if (PyErr_Occurred()) SWIG_fail;
10782 }
10783 resultobj = result;
10784 return resultobj;
10785 fail:
10786 return NULL;
10787 }
10788
10789
10790 static PyObject * FontEnumerator_swigregister(PyObject *, PyObject *args) {
10791 PyObject *obj;
10792 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10793 SWIG_TypeClientData(SWIGTYPE_p_wxPyFontEnumerator, obj);
10794 Py_INCREF(obj);
10795 return Py_BuildValue((char *)"");
10796 }
10797 static PyObject *_wrap_LanguageInfo_Language_set(PyObject *, PyObject *args, PyObject *kwargs) {
10798 PyObject *resultobj;
10799 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10800 int arg2 ;
10801 PyObject * obj0 = 0 ;
10802 PyObject * obj1 = 0 ;
10803 char *kwnames[] = {
10804 (char *) "self",(char *) "Language", NULL
10805 };
10806
10807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Language_set",kwnames,&obj0,&obj1)) goto fail;
10808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10809 if (SWIG_arg_fail(1)) SWIG_fail;
10810 {
10811 arg2 = (int)(SWIG_As_int(obj1));
10812 if (SWIG_arg_fail(2)) SWIG_fail;
10813 }
10814 if (arg1) (arg1)->Language = arg2;
10815
10816 Py_INCREF(Py_None); resultobj = Py_None;
10817 return resultobj;
10818 fail:
10819 return NULL;
10820 }
10821
10822
10823 static PyObject *_wrap_LanguageInfo_Language_get(PyObject *, PyObject *args, PyObject *kwargs) {
10824 PyObject *resultobj;
10825 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10826 int result;
10827 PyObject * obj0 = 0 ;
10828 char *kwnames[] = {
10829 (char *) "self", NULL
10830 };
10831
10832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Language_get",kwnames,&obj0)) goto fail;
10833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10834 if (SWIG_arg_fail(1)) SWIG_fail;
10835 result = (int) ((arg1)->Language);
10836
10837 {
10838 resultobj = SWIG_From_int((int)(result));
10839 }
10840 return resultobj;
10841 fail:
10842 return NULL;
10843 }
10844
10845
10846 static PyObject *_wrap_LanguageInfo_CanonicalName_set(PyObject *, PyObject *args, PyObject *kwargs) {
10847 PyObject *resultobj;
10848 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10849 wxString *arg2 = (wxString *) 0 ;
10850 bool temp2 = false ;
10851 PyObject * obj0 = 0 ;
10852 PyObject * obj1 = 0 ;
10853 char *kwnames[] = {
10854 (char *) "self",(char *) "CanonicalName", NULL
10855 };
10856
10857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_CanonicalName_set",kwnames,&obj0,&obj1)) goto fail;
10858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10859 if (SWIG_arg_fail(1)) SWIG_fail;
10860 {
10861 arg2 = wxString_in_helper(obj1);
10862 if (arg2 == NULL) SWIG_fail;
10863 temp2 = true;
10864 }
10865 if (arg1) (arg1)->CanonicalName = *arg2;
10866
10867 Py_INCREF(Py_None); resultobj = Py_None;
10868 {
10869 if (temp2)
10870 delete arg2;
10871 }
10872 return resultobj;
10873 fail:
10874 {
10875 if (temp2)
10876 delete arg2;
10877 }
10878 return NULL;
10879 }
10880
10881
10882 static PyObject *_wrap_LanguageInfo_CanonicalName_get(PyObject *, PyObject *args, PyObject *kwargs) {
10883 PyObject *resultobj;
10884 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10885 wxString *result;
10886 PyObject * obj0 = 0 ;
10887 char *kwnames[] = {
10888 (char *) "self", NULL
10889 };
10890
10891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_CanonicalName_get",kwnames,&obj0)) goto fail;
10892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10893 if (SWIG_arg_fail(1)) SWIG_fail;
10894 result = (wxString *)& ((arg1)->CanonicalName);
10895
10896 {
10897 #if wxUSE_UNICODE
10898 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10899 #else
10900 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10901 #endif
10902 }
10903 return resultobj;
10904 fail:
10905 return NULL;
10906 }
10907
10908
10909 static PyObject *_wrap_LanguageInfo_Description_set(PyObject *, PyObject *args, PyObject *kwargs) {
10910 PyObject *resultobj;
10911 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10912 wxString *arg2 = (wxString *) 0 ;
10913 bool temp2 = false ;
10914 PyObject * obj0 = 0 ;
10915 PyObject * obj1 = 0 ;
10916 char *kwnames[] = {
10917 (char *) "self",(char *) "Description", NULL
10918 };
10919
10920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Description_set",kwnames,&obj0,&obj1)) goto fail;
10921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10922 if (SWIG_arg_fail(1)) SWIG_fail;
10923 {
10924 arg2 = wxString_in_helper(obj1);
10925 if (arg2 == NULL) SWIG_fail;
10926 temp2 = true;
10927 }
10928 if (arg1) (arg1)->Description = *arg2;
10929
10930 Py_INCREF(Py_None); resultobj = Py_None;
10931 {
10932 if (temp2)
10933 delete arg2;
10934 }
10935 return resultobj;
10936 fail:
10937 {
10938 if (temp2)
10939 delete arg2;
10940 }
10941 return NULL;
10942 }
10943
10944
10945 static PyObject *_wrap_LanguageInfo_Description_get(PyObject *, PyObject *args, PyObject *kwargs) {
10946 PyObject *resultobj;
10947 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10948 wxString *result;
10949 PyObject * obj0 = 0 ;
10950 char *kwnames[] = {
10951 (char *) "self", NULL
10952 };
10953
10954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Description_get",kwnames,&obj0)) goto fail;
10955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10956 if (SWIG_arg_fail(1)) SWIG_fail;
10957 result = (wxString *)& ((arg1)->Description);
10958
10959 {
10960 #if wxUSE_UNICODE
10961 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10962 #else
10963 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10964 #endif
10965 }
10966 return resultobj;
10967 fail:
10968 return NULL;
10969 }
10970
10971
10972 static PyObject * LanguageInfo_swigregister(PyObject *, PyObject *args) {
10973 PyObject *obj;
10974 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10975 SWIG_TypeClientData(SWIGTYPE_p_wxLanguageInfo, obj);
10976 Py_INCREF(obj);
10977 return Py_BuildValue((char *)"");
10978 }
10979 static PyObject *_wrap_new_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
10980 PyObject *resultobj;
10981 int arg1 = (int) -1 ;
10982 int arg2 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
10983 wxLocale *result;
10984 PyObject * obj0 = 0 ;
10985 PyObject * obj1 = 0 ;
10986 char *kwnames[] = {
10987 (char *) "language",(char *) "flags", NULL
10988 };
10989
10990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Locale",kwnames,&obj0,&obj1)) goto fail;
10991 if (obj0) {
10992 {
10993 arg1 = (int)(SWIG_As_int(obj0));
10994 if (SWIG_arg_fail(1)) SWIG_fail;
10995 }
10996 }
10997 if (obj1) {
10998 {
10999 arg2 = (int)(SWIG_As_int(obj1));
11000 if (SWIG_arg_fail(2)) SWIG_fail;
11001 }
11002 }
11003 {
11004 PyThreadState* __tstate = wxPyBeginAllowThreads();
11005 result = (wxLocale *)new_wxLocale(arg1,arg2);
11006
11007 wxPyEndAllowThreads(__tstate);
11008 if (PyErr_Occurred()) SWIG_fail;
11009 }
11010 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 1);
11011 return resultobj;
11012 fail:
11013 return NULL;
11014 }
11015
11016
11017 static PyObject *_wrap_delete_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
11018 PyObject *resultobj;
11019 wxLocale *arg1 = (wxLocale *) 0 ;
11020 PyObject * obj0 = 0 ;
11021 char *kwnames[] = {
11022 (char *) "self", NULL
11023 };
11024
11025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Locale",kwnames,&obj0)) goto fail;
11026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11027 if (SWIG_arg_fail(1)) SWIG_fail;
11028 {
11029 PyThreadState* __tstate = wxPyBeginAllowThreads();
11030 delete arg1;
11031
11032 wxPyEndAllowThreads(__tstate);
11033 if (PyErr_Occurred()) SWIG_fail;
11034 }
11035 Py_INCREF(Py_None); resultobj = Py_None;
11036 return resultobj;
11037 fail:
11038 return NULL;
11039 }
11040
11041
11042 static PyObject *_wrap_Locale_Init1(PyObject *, PyObject *args, PyObject *kwargs) {
11043 PyObject *resultobj;
11044 wxLocale *arg1 = (wxLocale *) 0 ;
11045 wxString *arg2 = 0 ;
11046 wxString const &arg3_defvalue = wxPyEmptyString ;
11047 wxString *arg3 = (wxString *) &arg3_defvalue ;
11048 wxString const &arg4_defvalue = wxPyEmptyString ;
11049 wxString *arg4 = (wxString *) &arg4_defvalue ;
11050 bool arg5 = (bool) true ;
11051 bool arg6 = (bool) false ;
11052 bool result;
11053 bool temp2 = false ;
11054 bool temp3 = false ;
11055 bool temp4 = false ;
11056 PyObject * obj0 = 0 ;
11057 PyObject * obj1 = 0 ;
11058 PyObject * obj2 = 0 ;
11059 PyObject * obj3 = 0 ;
11060 PyObject * obj4 = 0 ;
11061 PyObject * obj5 = 0 ;
11062 char *kwnames[] = {
11063 (char *) "self",(char *) "szName",(char *) "szShort",(char *) "szLocale",(char *) "bLoadDefault",(char *) "bConvertEncoding", NULL
11064 };
11065
11066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Locale_Init1",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11068 if (SWIG_arg_fail(1)) SWIG_fail;
11069 {
11070 arg2 = wxString_in_helper(obj1);
11071 if (arg2 == NULL) SWIG_fail;
11072 temp2 = true;
11073 }
11074 if (obj2) {
11075 {
11076 arg3 = wxString_in_helper(obj2);
11077 if (arg3 == NULL) SWIG_fail;
11078 temp3 = true;
11079 }
11080 }
11081 if (obj3) {
11082 {
11083 arg4 = wxString_in_helper(obj3);
11084 if (arg4 == NULL) SWIG_fail;
11085 temp4 = true;
11086 }
11087 }
11088 if (obj4) {
11089 {
11090 arg5 = (bool)(SWIG_As_bool(obj4));
11091 if (SWIG_arg_fail(5)) SWIG_fail;
11092 }
11093 }
11094 if (obj5) {
11095 {
11096 arg6 = (bool)(SWIG_As_bool(obj5));
11097 if (SWIG_arg_fail(6)) SWIG_fail;
11098 }
11099 }
11100 {
11101 PyThreadState* __tstate = wxPyBeginAllowThreads();
11102 result = (bool)wxLocale_Init1(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
11103
11104 wxPyEndAllowThreads(__tstate);
11105 if (PyErr_Occurred()) SWIG_fail;
11106 }
11107 {
11108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11109 }
11110 {
11111 if (temp2)
11112 delete arg2;
11113 }
11114 {
11115 if (temp3)
11116 delete arg3;
11117 }
11118 {
11119 if (temp4)
11120 delete arg4;
11121 }
11122 return resultobj;
11123 fail:
11124 {
11125 if (temp2)
11126 delete arg2;
11127 }
11128 {
11129 if (temp3)
11130 delete arg3;
11131 }
11132 {
11133 if (temp4)
11134 delete arg4;
11135 }
11136 return NULL;
11137 }
11138
11139
11140 static PyObject *_wrap_Locale_Init2(PyObject *, PyObject *args, PyObject *kwargs) {
11141 PyObject *resultobj;
11142 wxLocale *arg1 = (wxLocale *) 0 ;
11143 int arg2 = (int) wxLANGUAGE_DEFAULT ;
11144 int arg3 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
11145 bool result;
11146 PyObject * obj0 = 0 ;
11147 PyObject * obj1 = 0 ;
11148 PyObject * obj2 = 0 ;
11149 char *kwnames[] = {
11150 (char *) "self",(char *) "language",(char *) "flags", NULL
11151 };
11152
11153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Locale_Init2",kwnames,&obj0,&obj1,&obj2)) goto fail;
11154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11155 if (SWIG_arg_fail(1)) SWIG_fail;
11156 if (obj1) {
11157 {
11158 arg2 = (int)(SWIG_As_int(obj1));
11159 if (SWIG_arg_fail(2)) SWIG_fail;
11160 }
11161 }
11162 if (obj2) {
11163 {
11164 arg3 = (int)(SWIG_As_int(obj2));
11165 if (SWIG_arg_fail(3)) SWIG_fail;
11166 }
11167 }
11168 {
11169 PyThreadState* __tstate = wxPyBeginAllowThreads();
11170 result = (bool)wxLocale_Init2(arg1,arg2,arg3);
11171
11172 wxPyEndAllowThreads(__tstate);
11173 if (PyErr_Occurred()) SWIG_fail;
11174 }
11175 {
11176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11177 }
11178 return resultobj;
11179 fail:
11180 return NULL;
11181 }
11182
11183
11184 static PyObject *_wrap_Locale_GetSystemLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11185 PyObject *resultobj;
11186 int result;
11187 char *kwnames[] = {
11188 NULL
11189 };
11190
11191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemLanguage",kwnames)) goto fail;
11192 {
11193 PyThreadState* __tstate = wxPyBeginAllowThreads();
11194 result = (int)wxLocale::GetSystemLanguage();
11195
11196 wxPyEndAllowThreads(__tstate);
11197 if (PyErr_Occurred()) SWIG_fail;
11198 }
11199 {
11200 resultobj = SWIG_From_int((int)(result));
11201 }
11202 return resultobj;
11203 fail:
11204 return NULL;
11205 }
11206
11207
11208 static PyObject *_wrap_Locale_GetSystemEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
11209 PyObject *resultobj;
11210 wxFontEncoding result;
11211 char *kwnames[] = {
11212 NULL
11213 };
11214
11215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncoding",kwnames)) goto fail;
11216 {
11217 PyThreadState* __tstate = wxPyBeginAllowThreads();
11218 result = (wxFontEncoding)wxLocale::GetSystemEncoding();
11219
11220 wxPyEndAllowThreads(__tstate);
11221 if (PyErr_Occurred()) SWIG_fail;
11222 }
11223 resultobj = SWIG_From_int((result));
11224 return resultobj;
11225 fail:
11226 return NULL;
11227 }
11228
11229
11230 static PyObject *_wrap_Locale_GetSystemEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
11231 PyObject *resultobj;
11232 wxString result;
11233 char *kwnames[] = {
11234 NULL
11235 };
11236
11237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncodingName",kwnames)) goto fail;
11238 {
11239 PyThreadState* __tstate = wxPyBeginAllowThreads();
11240 result = wxLocale::GetSystemEncodingName();
11241
11242 wxPyEndAllowThreads(__tstate);
11243 if (PyErr_Occurred()) SWIG_fail;
11244 }
11245 {
11246 #if wxUSE_UNICODE
11247 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11248 #else
11249 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11250 #endif
11251 }
11252 return resultobj;
11253 fail:
11254 return NULL;
11255 }
11256
11257
11258 static PyObject *_wrap_Locale_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11259 PyObject *resultobj;
11260 wxLocale *arg1 = (wxLocale *) 0 ;
11261 bool result;
11262 PyObject * obj0 = 0 ;
11263 char *kwnames[] = {
11264 (char *) "self", NULL
11265 };
11266
11267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_IsOk",kwnames,&obj0)) goto fail;
11268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11269 if (SWIG_arg_fail(1)) SWIG_fail;
11270 {
11271 PyThreadState* __tstate = wxPyBeginAllowThreads();
11272 result = (bool)((wxLocale const *)arg1)->IsOk();
11273
11274 wxPyEndAllowThreads(__tstate);
11275 if (PyErr_Occurred()) SWIG_fail;
11276 }
11277 {
11278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11279 }
11280 return resultobj;
11281 fail:
11282 return NULL;
11283 }
11284
11285
11286 static PyObject *_wrap_Locale_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
11287 PyObject *resultobj;
11288 wxLocale *arg1 = (wxLocale *) 0 ;
11289 wxString result;
11290 PyObject * obj0 = 0 ;
11291 char *kwnames[] = {
11292 (char *) "self", NULL
11293 };
11294
11295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLocale",kwnames,&obj0)) goto fail;
11296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11297 if (SWIG_arg_fail(1)) SWIG_fail;
11298 {
11299 PyThreadState* __tstate = wxPyBeginAllowThreads();
11300 result = ((wxLocale const *)arg1)->GetLocale();
11301
11302 wxPyEndAllowThreads(__tstate);
11303 if (PyErr_Occurred()) SWIG_fail;
11304 }
11305 {
11306 #if wxUSE_UNICODE
11307 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11308 #else
11309 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11310 #endif
11311 }
11312 return resultobj;
11313 fail:
11314 return NULL;
11315 }
11316
11317
11318 static PyObject *_wrap_Locale_GetLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11319 PyObject *resultobj;
11320 wxLocale *arg1 = (wxLocale *) 0 ;
11321 int result;
11322 PyObject * obj0 = 0 ;
11323 char *kwnames[] = {
11324 (char *) "self", NULL
11325 };
11326
11327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguage",kwnames,&obj0)) goto fail;
11328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11329 if (SWIG_arg_fail(1)) SWIG_fail;
11330 {
11331 PyThreadState* __tstate = wxPyBeginAllowThreads();
11332 result = (int)((wxLocale const *)arg1)->GetLanguage();
11333
11334 wxPyEndAllowThreads(__tstate);
11335 if (PyErr_Occurred()) SWIG_fail;
11336 }
11337 {
11338 resultobj = SWIG_From_int((int)(result));
11339 }
11340 return resultobj;
11341 fail:
11342 return NULL;
11343 }
11344
11345
11346 static PyObject *_wrap_Locale_GetSysName(PyObject *, PyObject *args, PyObject *kwargs) {
11347 PyObject *resultobj;
11348 wxLocale *arg1 = (wxLocale *) 0 ;
11349 wxString result;
11350 PyObject * obj0 = 0 ;
11351 char *kwnames[] = {
11352 (char *) "self", NULL
11353 };
11354
11355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetSysName",kwnames,&obj0)) goto fail;
11356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11357 if (SWIG_arg_fail(1)) SWIG_fail;
11358 {
11359 PyThreadState* __tstate = wxPyBeginAllowThreads();
11360 result = ((wxLocale const *)arg1)->GetSysName();
11361
11362 wxPyEndAllowThreads(__tstate);
11363 if (PyErr_Occurred()) SWIG_fail;
11364 }
11365 {
11366 #if wxUSE_UNICODE
11367 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11368 #else
11369 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11370 #endif
11371 }
11372 return resultobj;
11373 fail:
11374 return NULL;
11375 }
11376
11377
11378 static PyObject *_wrap_Locale_GetCanonicalName(PyObject *, PyObject *args, PyObject *kwargs) {
11379 PyObject *resultobj;
11380 wxLocale *arg1 = (wxLocale *) 0 ;
11381 wxString result;
11382 PyObject * obj0 = 0 ;
11383 char *kwnames[] = {
11384 (char *) "self", NULL
11385 };
11386
11387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetCanonicalName",kwnames,&obj0)) goto fail;
11388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11389 if (SWIG_arg_fail(1)) SWIG_fail;
11390 {
11391 PyThreadState* __tstate = wxPyBeginAllowThreads();
11392 result = ((wxLocale const *)arg1)->GetCanonicalName();
11393
11394 wxPyEndAllowThreads(__tstate);
11395 if (PyErr_Occurred()) SWIG_fail;
11396 }
11397 {
11398 #if wxUSE_UNICODE
11399 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11400 #else
11401 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11402 #endif
11403 }
11404 return resultobj;
11405 fail:
11406 return NULL;
11407 }
11408
11409
11410 static PyObject *_wrap_Locale_AddCatalogLookupPathPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
11411 PyObject *resultobj;
11412 wxString *arg1 = 0 ;
11413 bool temp1 = false ;
11414 PyObject * obj0 = 0 ;
11415 char *kwnames[] = {
11416 (char *) "prefix", NULL
11417 };
11418
11419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddCatalogLookupPathPrefix",kwnames,&obj0)) goto fail;
11420 {
11421 arg1 = wxString_in_helper(obj0);
11422 if (arg1 == NULL) SWIG_fail;
11423 temp1 = true;
11424 }
11425 {
11426 PyThreadState* __tstate = wxPyBeginAllowThreads();
11427 wxLocale::AddCatalogLookupPathPrefix((wxString const &)*arg1);
11428
11429 wxPyEndAllowThreads(__tstate);
11430 if (PyErr_Occurred()) SWIG_fail;
11431 }
11432 Py_INCREF(Py_None); resultobj = Py_None;
11433 {
11434 if (temp1)
11435 delete arg1;
11436 }
11437 return resultobj;
11438 fail:
11439 {
11440 if (temp1)
11441 delete arg1;
11442 }
11443 return NULL;
11444 }
11445
11446
11447 static PyObject *_wrap_Locale_AddCatalog(PyObject *, PyObject *args, PyObject *kwargs) {
11448 PyObject *resultobj;
11449 wxLocale *arg1 = (wxLocale *) 0 ;
11450 wxString *arg2 = 0 ;
11451 bool result;
11452 bool temp2 = false ;
11453 PyObject * obj0 = 0 ;
11454 PyObject * obj1 = 0 ;
11455 char *kwnames[] = {
11456 (char *) "self",(char *) "szDomain", NULL
11457 };
11458
11459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_AddCatalog",kwnames,&obj0,&obj1)) goto fail;
11460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11461 if (SWIG_arg_fail(1)) SWIG_fail;
11462 {
11463 arg2 = wxString_in_helper(obj1);
11464 if (arg2 == NULL) SWIG_fail;
11465 temp2 = true;
11466 }
11467 {
11468 PyThreadState* __tstate = wxPyBeginAllowThreads();
11469 result = (bool)(arg1)->AddCatalog((wxString const &)*arg2);
11470
11471 wxPyEndAllowThreads(__tstate);
11472 if (PyErr_Occurred()) SWIG_fail;
11473 }
11474 {
11475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11476 }
11477 {
11478 if (temp2)
11479 delete arg2;
11480 }
11481 return resultobj;
11482 fail:
11483 {
11484 if (temp2)
11485 delete arg2;
11486 }
11487 return NULL;
11488 }
11489
11490
11491 static PyObject *_wrap_Locale_IsLoaded(PyObject *, PyObject *args, PyObject *kwargs) {
11492 PyObject *resultobj;
11493 wxLocale *arg1 = (wxLocale *) 0 ;
11494 wxString *arg2 = 0 ;
11495 bool result;
11496 bool temp2 = false ;
11497 PyObject * obj0 = 0 ;
11498 PyObject * obj1 = 0 ;
11499 char *kwnames[] = {
11500 (char *) "self",(char *) "szDomain", NULL
11501 };
11502
11503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_IsLoaded",kwnames,&obj0,&obj1)) goto fail;
11504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11505 if (SWIG_arg_fail(1)) SWIG_fail;
11506 {
11507 arg2 = wxString_in_helper(obj1);
11508 if (arg2 == NULL) SWIG_fail;
11509 temp2 = true;
11510 }
11511 {
11512 PyThreadState* __tstate = wxPyBeginAllowThreads();
11513 result = (bool)((wxLocale const *)arg1)->IsLoaded((wxString const &)*arg2);
11514
11515 wxPyEndAllowThreads(__tstate);
11516 if (PyErr_Occurred()) SWIG_fail;
11517 }
11518 {
11519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11520 }
11521 {
11522 if (temp2)
11523 delete arg2;
11524 }
11525 return resultobj;
11526 fail:
11527 {
11528 if (temp2)
11529 delete arg2;
11530 }
11531 return NULL;
11532 }
11533
11534
11535 static PyObject *_wrap_Locale_GetLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11536 PyObject *resultobj;
11537 int arg1 ;
11538 wxLanguageInfo *result;
11539 PyObject * obj0 = 0 ;
11540 char *kwnames[] = {
11541 (char *) "lang", NULL
11542 };
11543
11544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageInfo",kwnames,&obj0)) goto fail;
11545 {
11546 arg1 = (int)(SWIG_As_int(obj0));
11547 if (SWIG_arg_fail(1)) SWIG_fail;
11548 }
11549 {
11550 PyThreadState* __tstate = wxPyBeginAllowThreads();
11551 result = (wxLanguageInfo *)wxLocale::GetLanguageInfo(arg1);
11552
11553 wxPyEndAllowThreads(__tstate);
11554 if (PyErr_Occurred()) SWIG_fail;
11555 }
11556 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
11557 return resultobj;
11558 fail:
11559 return NULL;
11560 }
11561
11562
11563 static PyObject *_wrap_Locale_GetLanguageName(PyObject *, PyObject *args, PyObject *kwargs) {
11564 PyObject *resultobj;
11565 int arg1 ;
11566 wxString result;
11567 PyObject * obj0 = 0 ;
11568 char *kwnames[] = {
11569 (char *) "lang", NULL
11570 };
11571
11572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageName",kwnames,&obj0)) goto fail;
11573 {
11574 arg1 = (int)(SWIG_As_int(obj0));
11575 if (SWIG_arg_fail(1)) SWIG_fail;
11576 }
11577 {
11578 PyThreadState* __tstate = wxPyBeginAllowThreads();
11579 result = wxLocale::GetLanguageName(arg1);
11580
11581 wxPyEndAllowThreads(__tstate);
11582 if (PyErr_Occurred()) SWIG_fail;
11583 }
11584 {
11585 #if wxUSE_UNICODE
11586 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11587 #else
11588 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11589 #endif
11590 }
11591 return resultobj;
11592 fail:
11593 return NULL;
11594 }
11595
11596
11597 static PyObject *_wrap_Locale_FindLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11598 PyObject *resultobj;
11599 wxString *arg1 = 0 ;
11600 wxLanguageInfo *result;
11601 bool temp1 = false ;
11602 PyObject * obj0 = 0 ;
11603 char *kwnames[] = {
11604 (char *) "locale", NULL
11605 };
11606
11607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_FindLanguageInfo",kwnames,&obj0)) goto fail;
11608 {
11609 arg1 = wxString_in_helper(obj0);
11610 if (arg1 == NULL) SWIG_fail;
11611 temp1 = true;
11612 }
11613 {
11614 PyThreadState* __tstate = wxPyBeginAllowThreads();
11615 result = (wxLanguageInfo *)wxLocale::FindLanguageInfo((wxString const &)*arg1);
11616
11617 wxPyEndAllowThreads(__tstate);
11618 if (PyErr_Occurred()) SWIG_fail;
11619 }
11620 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
11621 {
11622 if (temp1)
11623 delete arg1;
11624 }
11625 return resultobj;
11626 fail:
11627 {
11628 if (temp1)
11629 delete arg1;
11630 }
11631 return NULL;
11632 }
11633
11634
11635 static PyObject *_wrap_Locale_AddLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11636 PyObject *resultobj;
11637 wxLanguageInfo *arg1 = 0 ;
11638 PyObject * obj0 = 0 ;
11639 char *kwnames[] = {
11640 (char *) "info", NULL
11641 };
11642
11643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddLanguage",kwnames,&obj0)) goto fail;
11644 {
11645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11646 if (SWIG_arg_fail(1)) SWIG_fail;
11647 if (arg1 == NULL) {
11648 SWIG_null_ref("wxLanguageInfo");
11649 }
11650 if (SWIG_arg_fail(1)) SWIG_fail;
11651 }
11652 {
11653 PyThreadState* __tstate = wxPyBeginAllowThreads();
11654 wxLocale::AddLanguage((wxLanguageInfo const &)*arg1);
11655
11656 wxPyEndAllowThreads(__tstate);
11657 if (PyErr_Occurred()) SWIG_fail;
11658 }
11659 Py_INCREF(Py_None); resultobj = Py_None;
11660 return resultobj;
11661 fail:
11662 return NULL;
11663 }
11664
11665
11666 static PyObject *_wrap_Locale_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
11667 PyObject *resultobj;
11668 wxLocale *arg1 = (wxLocale *) 0 ;
11669 wxString *arg2 = 0 ;
11670 wxString const &arg3_defvalue = wxPyEmptyString ;
11671 wxString *arg3 = (wxString *) &arg3_defvalue ;
11672 wxString result;
11673 bool temp2 = false ;
11674 bool temp3 = false ;
11675 PyObject * obj0 = 0 ;
11676 PyObject * obj1 = 0 ;
11677 PyObject * obj2 = 0 ;
11678 char *kwnames[] = {
11679 (char *) "self",(char *) "szOrigString",(char *) "szDomain", NULL
11680 };
11681
11682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Locale_GetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
11683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11684 if (SWIG_arg_fail(1)) SWIG_fail;
11685 {
11686 arg2 = wxString_in_helper(obj1);
11687 if (arg2 == NULL) SWIG_fail;
11688 temp2 = true;
11689 }
11690 if (obj2) {
11691 {
11692 arg3 = wxString_in_helper(obj2);
11693 if (arg3 == NULL) SWIG_fail;
11694 temp3 = true;
11695 }
11696 }
11697 {
11698 PyThreadState* __tstate = wxPyBeginAllowThreads();
11699 result = ((wxLocale const *)arg1)->GetString((wxString const &)*arg2,(wxString const &)*arg3);
11700
11701 wxPyEndAllowThreads(__tstate);
11702 if (PyErr_Occurred()) SWIG_fail;
11703 }
11704 {
11705 #if wxUSE_UNICODE
11706 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11707 #else
11708 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11709 #endif
11710 }
11711 {
11712 if (temp2)
11713 delete arg2;
11714 }
11715 {
11716 if (temp3)
11717 delete arg3;
11718 }
11719 return resultobj;
11720 fail:
11721 {
11722 if (temp2)
11723 delete arg2;
11724 }
11725 {
11726 if (temp3)
11727 delete arg3;
11728 }
11729 return NULL;
11730 }
11731
11732
11733 static PyObject *_wrap_Locale_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
11734 PyObject *resultobj;
11735 wxLocale *arg1 = (wxLocale *) 0 ;
11736 wxString *result;
11737 PyObject * obj0 = 0 ;
11738 char *kwnames[] = {
11739 (char *) "self", NULL
11740 };
11741
11742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetName",kwnames,&obj0)) goto fail;
11743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11744 if (SWIG_arg_fail(1)) SWIG_fail;
11745 {
11746 PyThreadState* __tstate = wxPyBeginAllowThreads();
11747 {
11748 wxString const &_result_ref = ((wxLocale const *)arg1)->GetName();
11749 result = (wxString *) &_result_ref;
11750 }
11751
11752 wxPyEndAllowThreads(__tstate);
11753 if (PyErr_Occurred()) SWIG_fail;
11754 }
11755 {
11756 #if wxUSE_UNICODE
11757 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
11758 #else
11759 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
11760 #endif
11761 }
11762 return resultobj;
11763 fail:
11764 return NULL;
11765 }
11766
11767
11768 static PyObject * Locale_swigregister(PyObject *, PyObject *args) {
11769 PyObject *obj;
11770 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11771 SWIG_TypeClientData(SWIGTYPE_p_wxLocale, obj);
11772 Py_INCREF(obj);
11773 return Py_BuildValue((char *)"");
11774 }
11775 static PyObject *_wrap_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
11776 PyObject *resultobj;
11777 wxLocale *result;
11778 char *kwnames[] = {
11779 NULL
11780 };
11781
11782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocale",kwnames)) goto fail;
11783 {
11784 PyThreadState* __tstate = wxPyBeginAllowThreads();
11785 result = (wxLocale *)wxGetLocale();
11786
11787 wxPyEndAllowThreads(__tstate);
11788 if (PyErr_Occurred()) SWIG_fail;
11789 }
11790 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 0);
11791 return resultobj;
11792 fail:
11793 return NULL;
11794 }
11795
11796
11797 static PyObject *_wrap_GetTranslation__SWIG_0(PyObject *, PyObject *args) {
11798 PyObject *resultobj;
11799 wxString *arg1 = 0 ;
11800 wxString result;
11801 bool temp1 = false ;
11802 PyObject * obj0 = 0 ;
11803
11804 if(!PyArg_ParseTuple(args,(char *)"O:GetTranslation",&obj0)) goto fail;
11805 {
11806 arg1 = wxString_in_helper(obj0);
11807 if (arg1 == NULL) SWIG_fail;
11808 temp1 = true;
11809 }
11810 {
11811 PyThreadState* __tstate = wxPyBeginAllowThreads();
11812 result = wxGetTranslation((wxString const &)*arg1);
11813
11814 wxPyEndAllowThreads(__tstate);
11815 if (PyErr_Occurred()) SWIG_fail;
11816 }
11817 {
11818 #if wxUSE_UNICODE
11819 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11820 #else
11821 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11822 #endif
11823 }
11824 {
11825 if (temp1)
11826 delete arg1;
11827 }
11828 return resultobj;
11829 fail:
11830 {
11831 if (temp1)
11832 delete arg1;
11833 }
11834 return NULL;
11835 }
11836
11837
11838 static PyObject *_wrap_GetTranslation__SWIG_1(PyObject *, PyObject *args) {
11839 PyObject *resultobj;
11840 wxString *arg1 = 0 ;
11841 wxString *arg2 = 0 ;
11842 size_t arg3 ;
11843 wxString result;
11844 bool temp1 = false ;
11845 bool temp2 = false ;
11846 PyObject * obj0 = 0 ;
11847 PyObject * obj1 = 0 ;
11848 PyObject * obj2 = 0 ;
11849
11850 if(!PyArg_ParseTuple(args,(char *)"OOO:GetTranslation",&obj0,&obj1,&obj2)) goto fail;
11851 {
11852 arg1 = wxString_in_helper(obj0);
11853 if (arg1 == NULL) SWIG_fail;
11854 temp1 = true;
11855 }
11856 {
11857 arg2 = wxString_in_helper(obj1);
11858 if (arg2 == NULL) SWIG_fail;
11859 temp2 = true;
11860 }
11861 {
11862 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
11863 if (SWIG_arg_fail(3)) SWIG_fail;
11864 }
11865 {
11866 PyThreadState* __tstate = wxPyBeginAllowThreads();
11867 result = wxGetTranslation((wxString const &)*arg1,(wxString const &)*arg2,arg3);
11868
11869 wxPyEndAllowThreads(__tstate);
11870 if (PyErr_Occurred()) SWIG_fail;
11871 }
11872 {
11873 #if wxUSE_UNICODE
11874 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11875 #else
11876 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11877 #endif
11878 }
11879 {
11880 if (temp1)
11881 delete arg1;
11882 }
11883 {
11884 if (temp2)
11885 delete arg2;
11886 }
11887 return resultobj;
11888 fail:
11889 {
11890 if (temp1)
11891 delete arg1;
11892 }
11893 {
11894 if (temp2)
11895 delete arg2;
11896 }
11897 return NULL;
11898 }
11899
11900
11901 static PyObject *_wrap_GetTranslation(PyObject *self, PyObject *args) {
11902 int argc;
11903 PyObject *argv[4];
11904 int ii;
11905
11906 argc = PyObject_Length(args);
11907 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
11908 argv[ii] = PyTuple_GetItem(args,ii);
11909 }
11910 if (argc == 1) {
11911 int _v;
11912 {
11913 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
11914 }
11915 if (_v) {
11916 return _wrap_GetTranslation__SWIG_0(self,args);
11917 }
11918 }
11919 if (argc == 3) {
11920 int _v;
11921 {
11922 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
11923 }
11924 if (_v) {
11925 {
11926 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
11927 }
11928 if (_v) {
11929 _v = SWIG_Check_unsigned_SS_long(argv[2]);
11930 if (_v) {
11931 return _wrap_GetTranslation__SWIG_1(self,args);
11932 }
11933 }
11934 }
11935 }
11936
11937 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GetTranslation'");
11938 return NULL;
11939 }
11940
11941
11942 static PyObject *_wrap_new_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
11943 PyObject *resultobj;
11944 wxEncodingConverter *result;
11945 char *kwnames[] = {
11946 NULL
11947 };
11948
11949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EncodingConverter",kwnames)) goto fail;
11950 {
11951 PyThreadState* __tstate = wxPyBeginAllowThreads();
11952 result = (wxEncodingConverter *)new wxEncodingConverter();
11953
11954 wxPyEndAllowThreads(__tstate);
11955 if (PyErr_Occurred()) SWIG_fail;
11956 }
11957 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEncodingConverter, 1);
11958 return resultobj;
11959 fail:
11960 return NULL;
11961 }
11962
11963
11964 static PyObject *_wrap_delete_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
11965 PyObject *resultobj;
11966 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
11967 PyObject * obj0 = 0 ;
11968 char *kwnames[] = {
11969 (char *) "self", NULL
11970 };
11971
11972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EncodingConverter",kwnames,&obj0)) goto fail;
11973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
11974 if (SWIG_arg_fail(1)) SWIG_fail;
11975 {
11976 PyThreadState* __tstate = wxPyBeginAllowThreads();
11977 delete arg1;
11978
11979 wxPyEndAllowThreads(__tstate);
11980 if (PyErr_Occurred()) SWIG_fail;
11981 }
11982 Py_INCREF(Py_None); resultobj = Py_None;
11983 return resultobj;
11984 fail:
11985 return NULL;
11986 }
11987
11988
11989 static PyObject *_wrap_EncodingConverter_Init(PyObject *, PyObject *args, PyObject *kwargs) {
11990 PyObject *resultobj;
11991 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
11992 wxFontEncoding arg2 ;
11993 wxFontEncoding arg3 ;
11994 int arg4 = (int) wxCONVERT_STRICT ;
11995 bool result;
11996 PyObject * obj0 = 0 ;
11997 PyObject * obj1 = 0 ;
11998 PyObject * obj2 = 0 ;
11999 PyObject * obj3 = 0 ;
12000 char *kwnames[] = {
12001 (char *) "self",(char *) "input_enc",(char *) "output_enc",(char *) "method", NULL
12002 };
12003
12004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:EncodingConverter_Init",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12006 if (SWIG_arg_fail(1)) SWIG_fail;
12007 {
12008 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12009 if (SWIG_arg_fail(2)) SWIG_fail;
12010 }
12011 {
12012 arg3 = (wxFontEncoding)(SWIG_As_int(obj2));
12013 if (SWIG_arg_fail(3)) SWIG_fail;
12014 }
12015 if (obj3) {
12016 {
12017 arg4 = (int)(SWIG_As_int(obj3));
12018 if (SWIG_arg_fail(4)) SWIG_fail;
12019 }
12020 }
12021 {
12022 PyThreadState* __tstate = wxPyBeginAllowThreads();
12023 result = (bool)(arg1)->Init((wxFontEncoding )arg2,(wxFontEncoding )arg3,arg4);
12024
12025 wxPyEndAllowThreads(__tstate);
12026 if (PyErr_Occurred()) SWIG_fail;
12027 }
12028 {
12029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12030 }
12031 return resultobj;
12032 fail:
12033 return NULL;
12034 }
12035
12036
12037 static PyObject *_wrap_EncodingConverter_Convert(PyObject *, PyObject *args, PyObject *kwargs) {
12038 PyObject *resultobj;
12039 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12040 wxString *arg2 = 0 ;
12041 wxString result;
12042 bool temp2 = false ;
12043 PyObject * obj0 = 0 ;
12044 PyObject * obj1 = 0 ;
12045 char *kwnames[] = {
12046 (char *) "self",(char *) "input", NULL
12047 };
12048
12049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_Convert",kwnames,&obj0,&obj1)) goto fail;
12050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12051 if (SWIG_arg_fail(1)) SWIG_fail;
12052 {
12053 arg2 = wxString_in_helper(obj1);
12054 if (arg2 == NULL) SWIG_fail;
12055 temp2 = true;
12056 }
12057 {
12058 PyThreadState* __tstate = wxPyBeginAllowThreads();
12059 result = (arg1)->Convert((wxString const &)*arg2);
12060
12061 wxPyEndAllowThreads(__tstate);
12062 if (PyErr_Occurred()) SWIG_fail;
12063 }
12064 {
12065 #if wxUSE_UNICODE
12066 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12067 #else
12068 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12069 #endif
12070 }
12071 {
12072 if (temp2)
12073 delete arg2;
12074 }
12075 return resultobj;
12076 fail:
12077 {
12078 if (temp2)
12079 delete arg2;
12080 }
12081 return NULL;
12082 }
12083
12084
12085 static PyObject *_wrap_EncodingConverter_GetPlatformEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12086 PyObject *resultobj;
12087 wxFontEncoding arg1 ;
12088 int arg2 = (int) wxPLATFORM_CURRENT ;
12089 wxFontEncodingArray result;
12090 PyObject * obj0 = 0 ;
12091 PyObject * obj1 = 0 ;
12092 char *kwnames[] = {
12093 (char *) "enc",(char *) "platform", NULL
12094 };
12095
12096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EncodingConverter_GetPlatformEquivalents",kwnames,&obj0,&obj1)) goto fail;
12097 {
12098 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12099 if (SWIG_arg_fail(1)) SWIG_fail;
12100 }
12101 if (obj1) {
12102 {
12103 arg2 = (int)(SWIG_As_int(obj1));
12104 if (SWIG_arg_fail(2)) SWIG_fail;
12105 }
12106 }
12107 {
12108 PyThreadState* __tstate = wxPyBeginAllowThreads();
12109 result = wxEncodingConverter::GetPlatformEquivalents((wxFontEncoding )arg1,arg2);
12110
12111 wxPyEndAllowThreads(__tstate);
12112 if (PyErr_Occurred()) SWIG_fail;
12113 }
12114 {
12115 resultobj = PyList_New(0);
12116 for (size_t i=0; i < (&result)->GetCount(); i++) {
12117 PyObject* number = PyInt_FromLong((&result)->Item(i));
12118 PyList_Append(resultobj, number);
12119 Py_DECREF(number);
12120 }
12121 }
12122 return resultobj;
12123 fail:
12124 return NULL;
12125 }
12126
12127
12128 static PyObject *_wrap_EncodingConverter_GetAllEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12129 PyObject *resultobj;
12130 wxFontEncoding arg1 ;
12131 wxFontEncodingArray result;
12132 PyObject * obj0 = 0 ;
12133 char *kwnames[] = {
12134 (char *) "enc", NULL
12135 };
12136
12137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EncodingConverter_GetAllEquivalents",kwnames,&obj0)) goto fail;
12138 {
12139 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12140 if (SWIG_arg_fail(1)) SWIG_fail;
12141 }
12142 {
12143 PyThreadState* __tstate = wxPyBeginAllowThreads();
12144 result = wxEncodingConverter::GetAllEquivalents((wxFontEncoding )arg1);
12145
12146 wxPyEndAllowThreads(__tstate);
12147 if (PyErr_Occurred()) SWIG_fail;
12148 }
12149 {
12150 resultobj = PyList_New(0);
12151 for (size_t i=0; i < (&result)->GetCount(); i++) {
12152 PyObject* number = PyInt_FromLong((&result)->Item(i));
12153 PyList_Append(resultobj, number);
12154 Py_DECREF(number);
12155 }
12156 }
12157 return resultobj;
12158 fail:
12159 return NULL;
12160 }
12161
12162
12163 static PyObject *_wrap_EncodingConverter_CanConvert(PyObject *, PyObject *args, PyObject *kwargs) {
12164 PyObject *resultobj;
12165 wxFontEncoding arg1 ;
12166 wxFontEncoding arg2 ;
12167 bool result;
12168 PyObject * obj0 = 0 ;
12169 PyObject * obj1 = 0 ;
12170 char *kwnames[] = {
12171 (char *) "encIn",(char *) "encOut", NULL
12172 };
12173
12174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_CanConvert",kwnames,&obj0,&obj1)) goto fail;
12175 {
12176 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12177 if (SWIG_arg_fail(1)) SWIG_fail;
12178 }
12179 {
12180 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12181 if (SWIG_arg_fail(2)) SWIG_fail;
12182 }
12183 {
12184 PyThreadState* __tstate = wxPyBeginAllowThreads();
12185 result = (bool)wxEncodingConverter::CanConvert((wxFontEncoding )arg1,(wxFontEncoding )arg2);
12186
12187 wxPyEndAllowThreads(__tstate);
12188 if (PyErr_Occurred()) SWIG_fail;
12189 }
12190 {
12191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12192 }
12193 return resultobj;
12194 fail:
12195 return NULL;
12196 }
12197
12198
12199 static PyObject * EncodingConverter_swigregister(PyObject *, PyObject *args) {
12200 PyObject *obj;
12201 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12202 SWIG_TypeClientData(SWIGTYPE_p_wxEncodingConverter, obj);
12203 Py_INCREF(obj);
12204 return Py_BuildValue((char *)"");
12205 }
12206 static PyObject *_wrap_delete_DC(PyObject *, PyObject *args, PyObject *kwargs) {
12207 PyObject *resultobj;
12208 wxDC *arg1 = (wxDC *) 0 ;
12209 PyObject * obj0 = 0 ;
12210 char *kwnames[] = {
12211 (char *) "self", NULL
12212 };
12213
12214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DC",kwnames,&obj0)) goto fail;
12215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12216 if (SWIG_arg_fail(1)) SWIG_fail;
12217 {
12218 PyThreadState* __tstate = wxPyBeginAllowThreads();
12219 delete arg1;
12220
12221 wxPyEndAllowThreads(__tstate);
12222 if (PyErr_Occurred()) SWIG_fail;
12223 }
12224 Py_INCREF(Py_None); resultobj = Py_None;
12225 return resultobj;
12226 fail:
12227 return NULL;
12228 }
12229
12230
12231 static PyObject *_wrap_DC_BeginDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12232 PyObject *resultobj;
12233 wxDC *arg1 = (wxDC *) 0 ;
12234 PyObject * obj0 = 0 ;
12235 char *kwnames[] = {
12236 (char *) "self", NULL
12237 };
12238
12239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_BeginDrawing",kwnames,&obj0)) goto fail;
12240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12241 if (SWIG_arg_fail(1)) SWIG_fail;
12242 {
12243 PyThreadState* __tstate = wxPyBeginAllowThreads();
12244 (arg1)->BeginDrawing();
12245
12246 wxPyEndAllowThreads(__tstate);
12247 if (PyErr_Occurred()) SWIG_fail;
12248 }
12249 Py_INCREF(Py_None); resultobj = Py_None;
12250 return resultobj;
12251 fail:
12252 return NULL;
12253 }
12254
12255
12256 static PyObject *_wrap_DC_EndDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12257 PyObject *resultobj;
12258 wxDC *arg1 = (wxDC *) 0 ;
12259 PyObject * obj0 = 0 ;
12260 char *kwnames[] = {
12261 (char *) "self", NULL
12262 };
12263
12264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDrawing",kwnames,&obj0)) goto fail;
12265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12266 if (SWIG_arg_fail(1)) SWIG_fail;
12267 {
12268 PyThreadState* __tstate = wxPyBeginAllowThreads();
12269 (arg1)->EndDrawing();
12270
12271 wxPyEndAllowThreads(__tstate);
12272 if (PyErr_Occurred()) SWIG_fail;
12273 }
12274 Py_INCREF(Py_None); resultobj = Py_None;
12275 return resultobj;
12276 fail:
12277 return NULL;
12278 }
12279
12280
12281 static PyObject *_wrap_DC_FloodFill(PyObject *, PyObject *args, PyObject *kwargs) {
12282 PyObject *resultobj;
12283 wxDC *arg1 = (wxDC *) 0 ;
12284 int arg2 ;
12285 int arg3 ;
12286 wxColour *arg4 = 0 ;
12287 int arg5 = (int) wxFLOOD_SURFACE ;
12288 bool result;
12289 wxColour temp4 ;
12290 PyObject * obj0 = 0 ;
12291 PyObject * obj1 = 0 ;
12292 PyObject * obj2 = 0 ;
12293 PyObject * obj3 = 0 ;
12294 PyObject * obj4 = 0 ;
12295 char *kwnames[] = {
12296 (char *) "self",(char *) "x",(char *) "y",(char *) "col",(char *) "style", NULL
12297 };
12298
12299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_FloodFill",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12301 if (SWIG_arg_fail(1)) SWIG_fail;
12302 {
12303 arg2 = (int)(SWIG_As_int(obj1));
12304 if (SWIG_arg_fail(2)) SWIG_fail;
12305 }
12306 {
12307 arg3 = (int)(SWIG_As_int(obj2));
12308 if (SWIG_arg_fail(3)) SWIG_fail;
12309 }
12310 {
12311 arg4 = &temp4;
12312 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
12313 }
12314 if (obj4) {
12315 {
12316 arg5 = (int)(SWIG_As_int(obj4));
12317 if (SWIG_arg_fail(5)) SWIG_fail;
12318 }
12319 }
12320 {
12321 PyThreadState* __tstate = wxPyBeginAllowThreads();
12322 result = (bool)(arg1)->FloodFill(arg2,arg3,(wxColour const &)*arg4,arg5);
12323
12324 wxPyEndAllowThreads(__tstate);
12325 if (PyErr_Occurred()) SWIG_fail;
12326 }
12327 {
12328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12329 }
12330 return resultobj;
12331 fail:
12332 return NULL;
12333 }
12334
12335
12336 static PyObject *_wrap_DC_FloodFillPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12337 PyObject *resultobj;
12338 wxDC *arg1 = (wxDC *) 0 ;
12339 wxPoint *arg2 = 0 ;
12340 wxColour *arg3 = 0 ;
12341 int arg4 = (int) wxFLOOD_SURFACE ;
12342 bool result;
12343 wxPoint temp2 ;
12344 wxColour temp3 ;
12345 PyObject * obj0 = 0 ;
12346 PyObject * obj1 = 0 ;
12347 PyObject * obj2 = 0 ;
12348 PyObject * obj3 = 0 ;
12349 char *kwnames[] = {
12350 (char *) "self",(char *) "pt",(char *) "col",(char *) "style", NULL
12351 };
12352
12353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_FloodFillPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12355 if (SWIG_arg_fail(1)) SWIG_fail;
12356 {
12357 arg2 = &temp2;
12358 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12359 }
12360 {
12361 arg3 = &temp3;
12362 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
12363 }
12364 if (obj3) {
12365 {
12366 arg4 = (int)(SWIG_As_int(obj3));
12367 if (SWIG_arg_fail(4)) SWIG_fail;
12368 }
12369 }
12370 {
12371 PyThreadState* __tstate = wxPyBeginAllowThreads();
12372 result = (bool)(arg1)->FloodFill((wxPoint const &)*arg2,(wxColour const &)*arg3,arg4);
12373
12374 wxPyEndAllowThreads(__tstate);
12375 if (PyErr_Occurred()) SWIG_fail;
12376 }
12377 {
12378 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12379 }
12380 return resultobj;
12381 fail:
12382 return NULL;
12383 }
12384
12385
12386 static PyObject *_wrap_DC_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
12387 PyObject *resultobj;
12388 wxDC *arg1 = (wxDC *) 0 ;
12389 int arg2 ;
12390 int arg3 ;
12391 wxColour result;
12392 PyObject * obj0 = 0 ;
12393 PyObject * obj1 = 0 ;
12394 PyObject * obj2 = 0 ;
12395 char *kwnames[] = {
12396 (char *) "self",(char *) "x",(char *) "y", NULL
12397 };
12398
12399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_GetPixel",kwnames,&obj0,&obj1,&obj2)) goto fail;
12400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12401 if (SWIG_arg_fail(1)) SWIG_fail;
12402 {
12403 arg2 = (int)(SWIG_As_int(obj1));
12404 if (SWIG_arg_fail(2)) SWIG_fail;
12405 }
12406 {
12407 arg3 = (int)(SWIG_As_int(obj2));
12408 if (SWIG_arg_fail(3)) SWIG_fail;
12409 }
12410 {
12411 PyThreadState* __tstate = wxPyBeginAllowThreads();
12412 result = wxDC_GetPixel(arg1,arg2,arg3);
12413
12414 wxPyEndAllowThreads(__tstate);
12415 if (PyErr_Occurred()) SWIG_fail;
12416 }
12417 {
12418 wxColour * resultptr;
12419 resultptr = new wxColour((wxColour &)(result));
12420 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12421 }
12422 return resultobj;
12423 fail:
12424 return NULL;
12425 }
12426
12427
12428 static PyObject *_wrap_DC_GetPixelPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12429 PyObject *resultobj;
12430 wxDC *arg1 = (wxDC *) 0 ;
12431 wxPoint *arg2 = 0 ;
12432 wxColour result;
12433 wxPoint temp2 ;
12434 PyObject * obj0 = 0 ;
12435 PyObject * obj1 = 0 ;
12436 char *kwnames[] = {
12437 (char *) "self",(char *) "pt", NULL
12438 };
12439
12440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPixelPoint",kwnames,&obj0,&obj1)) goto fail;
12441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12442 if (SWIG_arg_fail(1)) SWIG_fail;
12443 {
12444 arg2 = &temp2;
12445 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12446 }
12447 {
12448 PyThreadState* __tstate = wxPyBeginAllowThreads();
12449 result = wxDC_GetPixelPoint(arg1,(wxPoint const &)*arg2);
12450
12451 wxPyEndAllowThreads(__tstate);
12452 if (PyErr_Occurred()) SWIG_fail;
12453 }
12454 {
12455 wxColour * resultptr;
12456 resultptr = new wxColour((wxColour &)(result));
12457 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12458 }
12459 return resultobj;
12460 fail:
12461 return NULL;
12462 }
12463
12464
12465 static PyObject *_wrap_DC_DrawLine(PyObject *, PyObject *args, PyObject *kwargs) {
12466 PyObject *resultobj;
12467 wxDC *arg1 = (wxDC *) 0 ;
12468 int arg2 ;
12469 int arg3 ;
12470 int arg4 ;
12471 int arg5 ;
12472 PyObject * obj0 = 0 ;
12473 PyObject * obj1 = 0 ;
12474 PyObject * obj2 = 0 ;
12475 PyObject * obj3 = 0 ;
12476 PyObject * obj4 = 0 ;
12477 char *kwnames[] = {
12478 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2", NULL
12479 };
12480
12481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawLine",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12483 if (SWIG_arg_fail(1)) SWIG_fail;
12484 {
12485 arg2 = (int)(SWIG_As_int(obj1));
12486 if (SWIG_arg_fail(2)) SWIG_fail;
12487 }
12488 {
12489 arg3 = (int)(SWIG_As_int(obj2));
12490 if (SWIG_arg_fail(3)) SWIG_fail;
12491 }
12492 {
12493 arg4 = (int)(SWIG_As_int(obj3));
12494 if (SWIG_arg_fail(4)) SWIG_fail;
12495 }
12496 {
12497 arg5 = (int)(SWIG_As_int(obj4));
12498 if (SWIG_arg_fail(5)) SWIG_fail;
12499 }
12500 {
12501 PyThreadState* __tstate = wxPyBeginAllowThreads();
12502 (arg1)->DrawLine(arg2,arg3,arg4,arg5);
12503
12504 wxPyEndAllowThreads(__tstate);
12505 if (PyErr_Occurred()) SWIG_fail;
12506 }
12507 Py_INCREF(Py_None); resultobj = Py_None;
12508 return resultobj;
12509 fail:
12510 return NULL;
12511 }
12512
12513
12514 static PyObject *_wrap_DC_DrawLinePoint(PyObject *, PyObject *args, PyObject *kwargs) {
12515 PyObject *resultobj;
12516 wxDC *arg1 = (wxDC *) 0 ;
12517 wxPoint *arg2 = 0 ;
12518 wxPoint *arg3 = 0 ;
12519 wxPoint temp2 ;
12520 wxPoint temp3 ;
12521 PyObject * obj0 = 0 ;
12522 PyObject * obj1 = 0 ;
12523 PyObject * obj2 = 0 ;
12524 char *kwnames[] = {
12525 (char *) "self",(char *) "pt1",(char *) "pt2", NULL
12526 };
12527
12528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawLinePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
12529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12530 if (SWIG_arg_fail(1)) SWIG_fail;
12531 {
12532 arg2 = &temp2;
12533 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12534 }
12535 {
12536 arg3 = &temp3;
12537 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12538 }
12539 {
12540 PyThreadState* __tstate = wxPyBeginAllowThreads();
12541 (arg1)->DrawLine((wxPoint const &)*arg2,(wxPoint const &)*arg3);
12542
12543 wxPyEndAllowThreads(__tstate);
12544 if (PyErr_Occurred()) SWIG_fail;
12545 }
12546 Py_INCREF(Py_None); resultobj = Py_None;
12547 return resultobj;
12548 fail:
12549 return NULL;
12550 }
12551
12552
12553 static PyObject *_wrap_DC_CrossHair(PyObject *, PyObject *args, PyObject *kwargs) {
12554 PyObject *resultobj;
12555 wxDC *arg1 = (wxDC *) 0 ;
12556 int arg2 ;
12557 int arg3 ;
12558 PyObject * obj0 = 0 ;
12559 PyObject * obj1 = 0 ;
12560 PyObject * obj2 = 0 ;
12561 char *kwnames[] = {
12562 (char *) "self",(char *) "x",(char *) "y", NULL
12563 };
12564
12565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CrossHair",kwnames,&obj0,&obj1,&obj2)) goto fail;
12566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12567 if (SWIG_arg_fail(1)) SWIG_fail;
12568 {
12569 arg2 = (int)(SWIG_As_int(obj1));
12570 if (SWIG_arg_fail(2)) SWIG_fail;
12571 }
12572 {
12573 arg3 = (int)(SWIG_As_int(obj2));
12574 if (SWIG_arg_fail(3)) SWIG_fail;
12575 }
12576 {
12577 PyThreadState* __tstate = wxPyBeginAllowThreads();
12578 (arg1)->CrossHair(arg2,arg3);
12579
12580 wxPyEndAllowThreads(__tstate);
12581 if (PyErr_Occurred()) SWIG_fail;
12582 }
12583 Py_INCREF(Py_None); resultobj = Py_None;
12584 return resultobj;
12585 fail:
12586 return NULL;
12587 }
12588
12589
12590 static PyObject *_wrap_DC_CrossHairPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12591 PyObject *resultobj;
12592 wxDC *arg1 = (wxDC *) 0 ;
12593 wxPoint *arg2 = 0 ;
12594 wxPoint temp2 ;
12595 PyObject * obj0 = 0 ;
12596 PyObject * obj1 = 0 ;
12597 char *kwnames[] = {
12598 (char *) "self",(char *) "pt", NULL
12599 };
12600
12601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CrossHairPoint",kwnames,&obj0,&obj1)) goto fail;
12602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12603 if (SWIG_arg_fail(1)) SWIG_fail;
12604 {
12605 arg2 = &temp2;
12606 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12607 }
12608 {
12609 PyThreadState* __tstate = wxPyBeginAllowThreads();
12610 (arg1)->CrossHair((wxPoint const &)*arg2);
12611
12612 wxPyEndAllowThreads(__tstate);
12613 if (PyErr_Occurred()) SWIG_fail;
12614 }
12615 Py_INCREF(Py_None); resultobj = Py_None;
12616 return resultobj;
12617 fail:
12618 return NULL;
12619 }
12620
12621
12622 static PyObject *_wrap_DC_DrawArc(PyObject *, PyObject *args, PyObject *kwargs) {
12623 PyObject *resultobj;
12624 wxDC *arg1 = (wxDC *) 0 ;
12625 int arg2 ;
12626 int arg3 ;
12627 int arg4 ;
12628 int arg5 ;
12629 int arg6 ;
12630 int arg7 ;
12631 PyObject * obj0 = 0 ;
12632 PyObject * obj1 = 0 ;
12633 PyObject * obj2 = 0 ;
12634 PyObject * obj3 = 0 ;
12635 PyObject * obj4 = 0 ;
12636 PyObject * obj5 = 0 ;
12637 PyObject * obj6 = 0 ;
12638 char *kwnames[] = {
12639 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2",(char *) "xc",(char *) "yc", NULL
12640 };
12641
12642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12644 if (SWIG_arg_fail(1)) SWIG_fail;
12645 {
12646 arg2 = (int)(SWIG_As_int(obj1));
12647 if (SWIG_arg_fail(2)) SWIG_fail;
12648 }
12649 {
12650 arg3 = (int)(SWIG_As_int(obj2));
12651 if (SWIG_arg_fail(3)) SWIG_fail;
12652 }
12653 {
12654 arg4 = (int)(SWIG_As_int(obj3));
12655 if (SWIG_arg_fail(4)) SWIG_fail;
12656 }
12657 {
12658 arg5 = (int)(SWIG_As_int(obj4));
12659 if (SWIG_arg_fail(5)) SWIG_fail;
12660 }
12661 {
12662 arg6 = (int)(SWIG_As_int(obj5));
12663 if (SWIG_arg_fail(6)) SWIG_fail;
12664 }
12665 {
12666 arg7 = (int)(SWIG_As_int(obj6));
12667 if (SWIG_arg_fail(7)) SWIG_fail;
12668 }
12669 {
12670 PyThreadState* __tstate = wxPyBeginAllowThreads();
12671 (arg1)->DrawArc(arg2,arg3,arg4,arg5,arg6,arg7);
12672
12673 wxPyEndAllowThreads(__tstate);
12674 if (PyErr_Occurred()) SWIG_fail;
12675 }
12676 Py_INCREF(Py_None); resultobj = Py_None;
12677 return resultobj;
12678 fail:
12679 return NULL;
12680 }
12681
12682
12683 static PyObject *_wrap_DC_DrawArcPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12684 PyObject *resultobj;
12685 wxDC *arg1 = (wxDC *) 0 ;
12686 wxPoint *arg2 = 0 ;
12687 wxPoint *arg3 = 0 ;
12688 wxPoint *arg4 = 0 ;
12689 wxPoint temp2 ;
12690 wxPoint temp3 ;
12691 wxPoint temp4 ;
12692 PyObject * obj0 = 0 ;
12693 PyObject * obj1 = 0 ;
12694 PyObject * obj2 = 0 ;
12695 PyObject * obj3 = 0 ;
12696 char *kwnames[] = {
12697 (char *) "self",(char *) "pt1",(char *) "pt2",(char *) "center", NULL
12698 };
12699
12700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawArcPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12702 if (SWIG_arg_fail(1)) SWIG_fail;
12703 {
12704 arg2 = &temp2;
12705 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12706 }
12707 {
12708 arg3 = &temp3;
12709 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12710 }
12711 {
12712 arg4 = &temp4;
12713 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
12714 }
12715 {
12716 PyThreadState* __tstate = wxPyBeginAllowThreads();
12717 (arg1)->DrawArc((wxPoint const &)*arg2,(wxPoint const &)*arg3,(wxPoint const &)*arg4);
12718
12719 wxPyEndAllowThreads(__tstate);
12720 if (PyErr_Occurred()) SWIG_fail;
12721 }
12722 Py_INCREF(Py_None); resultobj = Py_None;
12723 return resultobj;
12724 fail:
12725 return NULL;
12726 }
12727
12728
12729 static PyObject *_wrap_DC_DrawCheckMark(PyObject *, PyObject *args, PyObject *kwargs) {
12730 PyObject *resultobj;
12731 wxDC *arg1 = (wxDC *) 0 ;
12732 int arg2 ;
12733 int arg3 ;
12734 int arg4 ;
12735 int arg5 ;
12736 PyObject * obj0 = 0 ;
12737 PyObject * obj1 = 0 ;
12738 PyObject * obj2 = 0 ;
12739 PyObject * obj3 = 0 ;
12740 PyObject * obj4 = 0 ;
12741 char *kwnames[] = {
12742 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
12743 };
12744
12745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawCheckMark",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12747 if (SWIG_arg_fail(1)) SWIG_fail;
12748 {
12749 arg2 = (int)(SWIG_As_int(obj1));
12750 if (SWIG_arg_fail(2)) SWIG_fail;
12751 }
12752 {
12753 arg3 = (int)(SWIG_As_int(obj2));
12754 if (SWIG_arg_fail(3)) SWIG_fail;
12755 }
12756 {
12757 arg4 = (int)(SWIG_As_int(obj3));
12758 if (SWIG_arg_fail(4)) SWIG_fail;
12759 }
12760 {
12761 arg5 = (int)(SWIG_As_int(obj4));
12762 if (SWIG_arg_fail(5)) SWIG_fail;
12763 }
12764 {
12765 PyThreadState* __tstate = wxPyBeginAllowThreads();
12766 (arg1)->DrawCheckMark(arg2,arg3,arg4,arg5);
12767
12768 wxPyEndAllowThreads(__tstate);
12769 if (PyErr_Occurred()) SWIG_fail;
12770 }
12771 Py_INCREF(Py_None); resultobj = Py_None;
12772 return resultobj;
12773 fail:
12774 return NULL;
12775 }
12776
12777
12778 static PyObject *_wrap_DC_DrawCheckMarkRect(PyObject *, PyObject *args, PyObject *kwargs) {
12779 PyObject *resultobj;
12780 wxDC *arg1 = (wxDC *) 0 ;
12781 wxRect *arg2 = 0 ;
12782 wxRect temp2 ;
12783 PyObject * obj0 = 0 ;
12784 PyObject * obj1 = 0 ;
12785 char *kwnames[] = {
12786 (char *) "self",(char *) "rect", NULL
12787 };
12788
12789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawCheckMarkRect",kwnames,&obj0,&obj1)) goto fail;
12790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12791 if (SWIG_arg_fail(1)) SWIG_fail;
12792 {
12793 arg2 = &temp2;
12794 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12795 }
12796 {
12797 PyThreadState* __tstate = wxPyBeginAllowThreads();
12798 (arg1)->DrawCheckMark((wxRect const &)*arg2);
12799
12800 wxPyEndAllowThreads(__tstate);
12801 if (PyErr_Occurred()) SWIG_fail;
12802 }
12803 Py_INCREF(Py_None); resultobj = Py_None;
12804 return resultobj;
12805 fail:
12806 return NULL;
12807 }
12808
12809
12810 static PyObject *_wrap_DC_DrawEllipticArc(PyObject *, PyObject *args, PyObject *kwargs) {
12811 PyObject *resultobj;
12812 wxDC *arg1 = (wxDC *) 0 ;
12813 int arg2 ;
12814 int arg3 ;
12815 int arg4 ;
12816 int arg5 ;
12817 double arg6 ;
12818 double arg7 ;
12819 PyObject * obj0 = 0 ;
12820 PyObject * obj1 = 0 ;
12821 PyObject * obj2 = 0 ;
12822 PyObject * obj3 = 0 ;
12823 PyObject * obj4 = 0 ;
12824 PyObject * obj5 = 0 ;
12825 PyObject * obj6 = 0 ;
12826 char *kwnames[] = {
12827 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h",(char *) "start",(char *) "end", NULL
12828 };
12829
12830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawEllipticArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12832 if (SWIG_arg_fail(1)) SWIG_fail;
12833 {
12834 arg2 = (int)(SWIG_As_int(obj1));
12835 if (SWIG_arg_fail(2)) SWIG_fail;
12836 }
12837 {
12838 arg3 = (int)(SWIG_As_int(obj2));
12839 if (SWIG_arg_fail(3)) SWIG_fail;
12840 }
12841 {
12842 arg4 = (int)(SWIG_As_int(obj3));
12843 if (SWIG_arg_fail(4)) SWIG_fail;
12844 }
12845 {
12846 arg5 = (int)(SWIG_As_int(obj4));
12847 if (SWIG_arg_fail(5)) SWIG_fail;
12848 }
12849 {
12850 arg6 = (double)(SWIG_As_double(obj5));
12851 if (SWIG_arg_fail(6)) SWIG_fail;
12852 }
12853 {
12854 arg7 = (double)(SWIG_As_double(obj6));
12855 if (SWIG_arg_fail(7)) SWIG_fail;
12856 }
12857 {
12858 PyThreadState* __tstate = wxPyBeginAllowThreads();
12859 (arg1)->DrawEllipticArc(arg2,arg3,arg4,arg5,arg6,arg7);
12860
12861 wxPyEndAllowThreads(__tstate);
12862 if (PyErr_Occurred()) SWIG_fail;
12863 }
12864 Py_INCREF(Py_None); resultobj = Py_None;
12865 return resultobj;
12866 fail:
12867 return NULL;
12868 }
12869
12870
12871 static PyObject *_wrap_DC_DrawEllipticArcPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
12872 PyObject *resultobj;
12873 wxDC *arg1 = (wxDC *) 0 ;
12874 wxPoint *arg2 = 0 ;
12875 wxSize *arg3 = 0 ;
12876 double arg4 ;
12877 double arg5 ;
12878 wxPoint temp2 ;
12879 wxSize temp3 ;
12880 PyObject * obj0 = 0 ;
12881 PyObject * obj1 = 0 ;
12882 PyObject * obj2 = 0 ;
12883 PyObject * obj3 = 0 ;
12884 PyObject * obj4 = 0 ;
12885 char *kwnames[] = {
12886 (char *) "self",(char *) "pt",(char *) "sz",(char *) "start",(char *) "end", NULL
12887 };
12888
12889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipticArcPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12891 if (SWIG_arg_fail(1)) SWIG_fail;
12892 {
12893 arg2 = &temp2;
12894 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12895 }
12896 {
12897 arg3 = &temp3;
12898 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
12899 }
12900 {
12901 arg4 = (double)(SWIG_As_double(obj3));
12902 if (SWIG_arg_fail(4)) SWIG_fail;
12903 }
12904 {
12905 arg5 = (double)(SWIG_As_double(obj4));
12906 if (SWIG_arg_fail(5)) SWIG_fail;
12907 }
12908 {
12909 PyThreadState* __tstate = wxPyBeginAllowThreads();
12910 (arg1)->DrawEllipticArc((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,arg5);
12911
12912 wxPyEndAllowThreads(__tstate);
12913 if (PyErr_Occurred()) SWIG_fail;
12914 }
12915 Py_INCREF(Py_None); resultobj = Py_None;
12916 return resultobj;
12917 fail:
12918 return NULL;
12919 }
12920
12921
12922 static PyObject *_wrap_DC_DrawPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12923 PyObject *resultobj;
12924 wxDC *arg1 = (wxDC *) 0 ;
12925 int arg2 ;
12926 int arg3 ;
12927 PyObject * obj0 = 0 ;
12928 PyObject * obj1 = 0 ;
12929 PyObject * obj2 = 0 ;
12930 char *kwnames[] = {
12931 (char *) "self",(char *) "x",(char *) "y", NULL
12932 };
12933
12934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
12935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12936 if (SWIG_arg_fail(1)) SWIG_fail;
12937 {
12938 arg2 = (int)(SWIG_As_int(obj1));
12939 if (SWIG_arg_fail(2)) SWIG_fail;
12940 }
12941 {
12942 arg3 = (int)(SWIG_As_int(obj2));
12943 if (SWIG_arg_fail(3)) SWIG_fail;
12944 }
12945 {
12946 PyThreadState* __tstate = wxPyBeginAllowThreads();
12947 (arg1)->DrawPoint(arg2,arg3);
12948
12949 wxPyEndAllowThreads(__tstate);
12950 if (PyErr_Occurred()) SWIG_fail;
12951 }
12952 Py_INCREF(Py_None); resultobj = Py_None;
12953 return resultobj;
12954 fail:
12955 return NULL;
12956 }
12957
12958
12959 static PyObject *_wrap_DC_DrawPointPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12960 PyObject *resultobj;
12961 wxDC *arg1 = (wxDC *) 0 ;
12962 wxPoint *arg2 = 0 ;
12963 wxPoint temp2 ;
12964 PyObject * obj0 = 0 ;
12965 PyObject * obj1 = 0 ;
12966 char *kwnames[] = {
12967 (char *) "self",(char *) "pt", NULL
12968 };
12969
12970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawPointPoint",kwnames,&obj0,&obj1)) goto fail;
12971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12972 if (SWIG_arg_fail(1)) SWIG_fail;
12973 {
12974 arg2 = &temp2;
12975 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12976 }
12977 {
12978 PyThreadState* __tstate = wxPyBeginAllowThreads();
12979 (arg1)->DrawPoint((wxPoint const &)*arg2);
12980
12981 wxPyEndAllowThreads(__tstate);
12982 if (PyErr_Occurred()) SWIG_fail;
12983 }
12984 Py_INCREF(Py_None); resultobj = Py_None;
12985 return resultobj;
12986 fail:
12987 return NULL;
12988 }
12989
12990
12991 static PyObject *_wrap_DC_DrawRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
12992 PyObject *resultobj;
12993 wxDC *arg1 = (wxDC *) 0 ;
12994 int arg2 ;
12995 int arg3 ;
12996 int arg4 ;
12997 int arg5 ;
12998 PyObject * obj0 = 0 ;
12999 PyObject * obj1 = 0 ;
13000 PyObject * obj2 = 0 ;
13001 PyObject * obj3 = 0 ;
13002 PyObject * obj4 = 0 ;
13003 char *kwnames[] = {
13004 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13005 };
13006
13007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13009 if (SWIG_arg_fail(1)) SWIG_fail;
13010 {
13011 arg2 = (int)(SWIG_As_int(obj1));
13012 if (SWIG_arg_fail(2)) SWIG_fail;
13013 }
13014 {
13015 arg3 = (int)(SWIG_As_int(obj2));
13016 if (SWIG_arg_fail(3)) SWIG_fail;
13017 }
13018 {
13019 arg4 = (int)(SWIG_As_int(obj3));
13020 if (SWIG_arg_fail(4)) SWIG_fail;
13021 }
13022 {
13023 arg5 = (int)(SWIG_As_int(obj4));
13024 if (SWIG_arg_fail(5)) SWIG_fail;
13025 }
13026 {
13027 PyThreadState* __tstate = wxPyBeginAllowThreads();
13028 (arg1)->DrawRectangle(arg2,arg3,arg4,arg5);
13029
13030 wxPyEndAllowThreads(__tstate);
13031 if (PyErr_Occurred()) SWIG_fail;
13032 }
13033 Py_INCREF(Py_None); resultobj = Py_None;
13034 return resultobj;
13035 fail:
13036 return NULL;
13037 }
13038
13039
13040 static PyObject *_wrap_DC_DrawRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13041 PyObject *resultobj;
13042 wxDC *arg1 = (wxDC *) 0 ;
13043 wxRect *arg2 = 0 ;
13044 wxRect temp2 ;
13045 PyObject * obj0 = 0 ;
13046 PyObject * obj1 = 0 ;
13047 char *kwnames[] = {
13048 (char *) "self",(char *) "rect", NULL
13049 };
13050
13051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawRectangleRect",kwnames,&obj0,&obj1)) goto fail;
13052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13053 if (SWIG_arg_fail(1)) SWIG_fail;
13054 {
13055 arg2 = &temp2;
13056 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13057 }
13058 {
13059 PyThreadState* __tstate = wxPyBeginAllowThreads();
13060 (arg1)->DrawRectangle((wxRect const &)*arg2);
13061
13062 wxPyEndAllowThreads(__tstate);
13063 if (PyErr_Occurred()) SWIG_fail;
13064 }
13065 Py_INCREF(Py_None); resultobj = Py_None;
13066 return resultobj;
13067 fail:
13068 return NULL;
13069 }
13070
13071
13072 static PyObject *_wrap_DC_DrawRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13073 PyObject *resultobj;
13074 wxDC *arg1 = (wxDC *) 0 ;
13075 wxPoint *arg2 = 0 ;
13076 wxSize *arg3 = 0 ;
13077 wxPoint temp2 ;
13078 wxSize temp3 ;
13079 PyObject * obj0 = 0 ;
13080 PyObject * obj1 = 0 ;
13081 PyObject * obj2 = 0 ;
13082 char *kwnames[] = {
13083 (char *) "self",(char *) "pt",(char *) "sz", NULL
13084 };
13085
13086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRectanglePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13088 if (SWIG_arg_fail(1)) SWIG_fail;
13089 {
13090 arg2 = &temp2;
13091 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13092 }
13093 {
13094 arg3 = &temp3;
13095 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13096 }
13097 {
13098 PyThreadState* __tstate = wxPyBeginAllowThreads();
13099 (arg1)->DrawRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3);
13100
13101 wxPyEndAllowThreads(__tstate);
13102 if (PyErr_Occurred()) SWIG_fail;
13103 }
13104 Py_INCREF(Py_None); resultobj = Py_None;
13105 return resultobj;
13106 fail:
13107 return NULL;
13108 }
13109
13110
13111 static PyObject *_wrap_DC_DrawRoundedRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
13112 PyObject *resultobj;
13113 wxDC *arg1 = (wxDC *) 0 ;
13114 int arg2 ;
13115 int arg3 ;
13116 int arg4 ;
13117 int arg5 ;
13118 double arg6 ;
13119 PyObject * obj0 = 0 ;
13120 PyObject * obj1 = 0 ;
13121 PyObject * obj2 = 0 ;
13122 PyObject * obj3 = 0 ;
13123 PyObject * obj4 = 0 ;
13124 PyObject * obj5 = 0 ;
13125 char *kwnames[] = {
13126 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "radius", NULL
13127 };
13128
13129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:DC_DrawRoundedRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
13130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13131 if (SWIG_arg_fail(1)) SWIG_fail;
13132 {
13133 arg2 = (int)(SWIG_As_int(obj1));
13134 if (SWIG_arg_fail(2)) SWIG_fail;
13135 }
13136 {
13137 arg3 = (int)(SWIG_As_int(obj2));
13138 if (SWIG_arg_fail(3)) SWIG_fail;
13139 }
13140 {
13141 arg4 = (int)(SWIG_As_int(obj3));
13142 if (SWIG_arg_fail(4)) SWIG_fail;
13143 }
13144 {
13145 arg5 = (int)(SWIG_As_int(obj4));
13146 if (SWIG_arg_fail(5)) SWIG_fail;
13147 }
13148 {
13149 arg6 = (double)(SWIG_As_double(obj5));
13150 if (SWIG_arg_fail(6)) SWIG_fail;
13151 }
13152 {
13153 PyThreadState* __tstate = wxPyBeginAllowThreads();
13154 (arg1)->DrawRoundedRectangle(arg2,arg3,arg4,arg5,arg6);
13155
13156 wxPyEndAllowThreads(__tstate);
13157 if (PyErr_Occurred()) SWIG_fail;
13158 }
13159 Py_INCREF(Py_None); resultobj = Py_None;
13160 return resultobj;
13161 fail:
13162 return NULL;
13163 }
13164
13165
13166 static PyObject *_wrap_DC_DrawRoundedRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13167 PyObject *resultobj;
13168 wxDC *arg1 = (wxDC *) 0 ;
13169 wxRect *arg2 = 0 ;
13170 double arg3 ;
13171 wxRect temp2 ;
13172 PyObject * obj0 = 0 ;
13173 PyObject * obj1 = 0 ;
13174 PyObject * obj2 = 0 ;
13175 char *kwnames[] = {
13176 (char *) "self",(char *) "r",(char *) "radius", NULL
13177 };
13178
13179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRoundedRectangleRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
13180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13181 if (SWIG_arg_fail(1)) SWIG_fail;
13182 {
13183 arg2 = &temp2;
13184 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13185 }
13186 {
13187 arg3 = (double)(SWIG_As_double(obj2));
13188 if (SWIG_arg_fail(3)) SWIG_fail;
13189 }
13190 {
13191 PyThreadState* __tstate = wxPyBeginAllowThreads();
13192 (arg1)->DrawRoundedRectangle((wxRect const &)*arg2,arg3);
13193
13194 wxPyEndAllowThreads(__tstate);
13195 if (PyErr_Occurred()) SWIG_fail;
13196 }
13197 Py_INCREF(Py_None); resultobj = Py_None;
13198 return resultobj;
13199 fail:
13200 return NULL;
13201 }
13202
13203
13204 static PyObject *_wrap_DC_DrawRoundedRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13205 PyObject *resultobj;
13206 wxDC *arg1 = (wxDC *) 0 ;
13207 wxPoint *arg2 = 0 ;
13208 wxSize *arg3 = 0 ;
13209 double arg4 ;
13210 wxPoint temp2 ;
13211 wxSize temp3 ;
13212 PyObject * obj0 = 0 ;
13213 PyObject * obj1 = 0 ;
13214 PyObject * obj2 = 0 ;
13215 PyObject * obj3 = 0 ;
13216 char *kwnames[] = {
13217 (char *) "self",(char *) "pt",(char *) "sz",(char *) "radius", NULL
13218 };
13219
13220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRoundedRectanglePointSize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13222 if (SWIG_arg_fail(1)) SWIG_fail;
13223 {
13224 arg2 = &temp2;
13225 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13226 }
13227 {
13228 arg3 = &temp3;
13229 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13230 }
13231 {
13232 arg4 = (double)(SWIG_As_double(obj3));
13233 if (SWIG_arg_fail(4)) SWIG_fail;
13234 }
13235 {
13236 PyThreadState* __tstate = wxPyBeginAllowThreads();
13237 (arg1)->DrawRoundedRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4);
13238
13239 wxPyEndAllowThreads(__tstate);
13240 if (PyErr_Occurred()) SWIG_fail;
13241 }
13242 Py_INCREF(Py_None); resultobj = Py_None;
13243 return resultobj;
13244 fail:
13245 return NULL;
13246 }
13247
13248
13249 static PyObject *_wrap_DC_DrawCircle(PyObject *, PyObject *args, PyObject *kwargs) {
13250 PyObject *resultobj;
13251 wxDC *arg1 = (wxDC *) 0 ;
13252 int arg2 ;
13253 int arg3 ;
13254 int arg4 ;
13255 PyObject * obj0 = 0 ;
13256 PyObject * obj1 = 0 ;
13257 PyObject * obj2 = 0 ;
13258 PyObject * obj3 = 0 ;
13259 char *kwnames[] = {
13260 (char *) "self",(char *) "x",(char *) "y",(char *) "radius", NULL
13261 };
13262
13263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawCircle",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13265 if (SWIG_arg_fail(1)) SWIG_fail;
13266 {
13267 arg2 = (int)(SWIG_As_int(obj1));
13268 if (SWIG_arg_fail(2)) SWIG_fail;
13269 }
13270 {
13271 arg3 = (int)(SWIG_As_int(obj2));
13272 if (SWIG_arg_fail(3)) SWIG_fail;
13273 }
13274 {
13275 arg4 = (int)(SWIG_As_int(obj3));
13276 if (SWIG_arg_fail(4)) SWIG_fail;
13277 }
13278 {
13279 PyThreadState* __tstate = wxPyBeginAllowThreads();
13280 (arg1)->DrawCircle(arg2,arg3,arg4);
13281
13282 wxPyEndAllowThreads(__tstate);
13283 if (PyErr_Occurred()) SWIG_fail;
13284 }
13285 Py_INCREF(Py_None); resultobj = Py_None;
13286 return resultobj;
13287 fail:
13288 return NULL;
13289 }
13290
13291
13292 static PyObject *_wrap_DC_DrawCirclePoint(PyObject *, PyObject *args, PyObject *kwargs) {
13293 PyObject *resultobj;
13294 wxDC *arg1 = (wxDC *) 0 ;
13295 wxPoint *arg2 = 0 ;
13296 int arg3 ;
13297 wxPoint temp2 ;
13298 PyObject * obj0 = 0 ;
13299 PyObject * obj1 = 0 ;
13300 PyObject * obj2 = 0 ;
13301 char *kwnames[] = {
13302 (char *) "self",(char *) "pt",(char *) "radius", NULL
13303 };
13304
13305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawCirclePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13307 if (SWIG_arg_fail(1)) SWIG_fail;
13308 {
13309 arg2 = &temp2;
13310 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13311 }
13312 {
13313 arg3 = (int)(SWIG_As_int(obj2));
13314 if (SWIG_arg_fail(3)) SWIG_fail;
13315 }
13316 {
13317 PyThreadState* __tstate = wxPyBeginAllowThreads();
13318 (arg1)->DrawCircle((wxPoint const &)*arg2,arg3);
13319
13320 wxPyEndAllowThreads(__tstate);
13321 if (PyErr_Occurred()) SWIG_fail;
13322 }
13323 Py_INCREF(Py_None); resultobj = Py_None;
13324 return resultobj;
13325 fail:
13326 return NULL;
13327 }
13328
13329
13330 static PyObject *_wrap_DC_DrawEllipse(PyObject *, PyObject *args, PyObject *kwargs) {
13331 PyObject *resultobj;
13332 wxDC *arg1 = (wxDC *) 0 ;
13333 int arg2 ;
13334 int arg3 ;
13335 int arg4 ;
13336 int arg5 ;
13337 PyObject * obj0 = 0 ;
13338 PyObject * obj1 = 0 ;
13339 PyObject * obj2 = 0 ;
13340 PyObject * obj3 = 0 ;
13341 PyObject * obj4 = 0 ;
13342 char *kwnames[] = {
13343 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13344 };
13345
13346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipse",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13348 if (SWIG_arg_fail(1)) SWIG_fail;
13349 {
13350 arg2 = (int)(SWIG_As_int(obj1));
13351 if (SWIG_arg_fail(2)) SWIG_fail;
13352 }
13353 {
13354 arg3 = (int)(SWIG_As_int(obj2));
13355 if (SWIG_arg_fail(3)) SWIG_fail;
13356 }
13357 {
13358 arg4 = (int)(SWIG_As_int(obj3));
13359 if (SWIG_arg_fail(4)) SWIG_fail;
13360 }
13361 {
13362 arg5 = (int)(SWIG_As_int(obj4));
13363 if (SWIG_arg_fail(5)) SWIG_fail;
13364 }
13365 {
13366 PyThreadState* __tstate = wxPyBeginAllowThreads();
13367 (arg1)->DrawEllipse(arg2,arg3,arg4,arg5);
13368
13369 wxPyEndAllowThreads(__tstate);
13370 if (PyErr_Occurred()) SWIG_fail;
13371 }
13372 Py_INCREF(Py_None); resultobj = Py_None;
13373 return resultobj;
13374 fail:
13375 return NULL;
13376 }
13377
13378
13379 static PyObject *_wrap_DC_DrawEllipseRect(PyObject *, PyObject *args, PyObject *kwargs) {
13380 PyObject *resultobj;
13381 wxDC *arg1 = (wxDC *) 0 ;
13382 wxRect *arg2 = 0 ;
13383 wxRect temp2 ;
13384 PyObject * obj0 = 0 ;
13385 PyObject * obj1 = 0 ;
13386 char *kwnames[] = {
13387 (char *) "self",(char *) "rect", NULL
13388 };
13389
13390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawEllipseRect",kwnames,&obj0,&obj1)) goto fail;
13391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13392 if (SWIG_arg_fail(1)) SWIG_fail;
13393 {
13394 arg2 = &temp2;
13395 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13396 }
13397 {
13398 PyThreadState* __tstate = wxPyBeginAllowThreads();
13399 (arg1)->DrawEllipse((wxRect const &)*arg2);
13400
13401 wxPyEndAllowThreads(__tstate);
13402 if (PyErr_Occurred()) SWIG_fail;
13403 }
13404 Py_INCREF(Py_None); resultobj = Py_None;
13405 return resultobj;
13406 fail:
13407 return NULL;
13408 }
13409
13410
13411 static PyObject *_wrap_DC_DrawEllipsePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13412 PyObject *resultobj;
13413 wxDC *arg1 = (wxDC *) 0 ;
13414 wxPoint *arg2 = 0 ;
13415 wxSize *arg3 = 0 ;
13416 wxPoint temp2 ;
13417 wxSize temp3 ;
13418 PyObject * obj0 = 0 ;
13419 PyObject * obj1 = 0 ;
13420 PyObject * obj2 = 0 ;
13421 char *kwnames[] = {
13422 (char *) "self",(char *) "pt",(char *) "sz", NULL
13423 };
13424
13425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawEllipsePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13427 if (SWIG_arg_fail(1)) SWIG_fail;
13428 {
13429 arg2 = &temp2;
13430 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13431 }
13432 {
13433 arg3 = &temp3;
13434 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13435 }
13436 {
13437 PyThreadState* __tstate = wxPyBeginAllowThreads();
13438 (arg1)->DrawEllipse((wxPoint const &)*arg2,(wxSize const &)*arg3);
13439
13440 wxPyEndAllowThreads(__tstate);
13441 if (PyErr_Occurred()) SWIG_fail;
13442 }
13443 Py_INCREF(Py_None); resultobj = Py_None;
13444 return resultobj;
13445 fail:
13446 return NULL;
13447 }
13448
13449
13450 static PyObject *_wrap_DC_DrawIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13451 PyObject *resultobj;
13452 wxDC *arg1 = (wxDC *) 0 ;
13453 wxIcon *arg2 = 0 ;
13454 int arg3 ;
13455 int arg4 ;
13456 PyObject * obj0 = 0 ;
13457 PyObject * obj1 = 0 ;
13458 PyObject * obj2 = 0 ;
13459 PyObject * obj3 = 0 ;
13460 char *kwnames[] = {
13461 (char *) "self",(char *) "icon",(char *) "x",(char *) "y", NULL
13462 };
13463
13464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawIcon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13466 if (SWIG_arg_fail(1)) SWIG_fail;
13467 {
13468 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
13469 if (SWIG_arg_fail(2)) SWIG_fail;
13470 if (arg2 == NULL) {
13471 SWIG_null_ref("wxIcon");
13472 }
13473 if (SWIG_arg_fail(2)) SWIG_fail;
13474 }
13475 {
13476 arg3 = (int)(SWIG_As_int(obj2));
13477 if (SWIG_arg_fail(3)) SWIG_fail;
13478 }
13479 {
13480 arg4 = (int)(SWIG_As_int(obj3));
13481 if (SWIG_arg_fail(4)) SWIG_fail;
13482 }
13483 {
13484 PyThreadState* __tstate = wxPyBeginAllowThreads();
13485 (arg1)->DrawIcon((wxIcon const &)*arg2,arg3,arg4);
13486
13487 wxPyEndAllowThreads(__tstate);
13488 if (PyErr_Occurred()) SWIG_fail;
13489 }
13490 Py_INCREF(Py_None); resultobj = Py_None;
13491 return resultobj;
13492 fail:
13493 return NULL;
13494 }
13495
13496
13497 static PyObject *_wrap_DC_DrawIconPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13498 PyObject *resultobj;
13499 wxDC *arg1 = (wxDC *) 0 ;
13500 wxIcon *arg2 = 0 ;
13501 wxPoint *arg3 = 0 ;
13502 wxPoint temp3 ;
13503 PyObject * obj0 = 0 ;
13504 PyObject * obj1 = 0 ;
13505 PyObject * obj2 = 0 ;
13506 char *kwnames[] = {
13507 (char *) "self",(char *) "icon",(char *) "pt", NULL
13508 };
13509
13510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawIconPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13512 if (SWIG_arg_fail(1)) SWIG_fail;
13513 {
13514 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
13515 if (SWIG_arg_fail(2)) SWIG_fail;
13516 if (arg2 == NULL) {
13517 SWIG_null_ref("wxIcon");
13518 }
13519 if (SWIG_arg_fail(2)) SWIG_fail;
13520 }
13521 {
13522 arg3 = &temp3;
13523 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13524 }
13525 {
13526 PyThreadState* __tstate = wxPyBeginAllowThreads();
13527 (arg1)->DrawIcon((wxIcon const &)*arg2,(wxPoint const &)*arg3);
13528
13529 wxPyEndAllowThreads(__tstate);
13530 if (PyErr_Occurred()) SWIG_fail;
13531 }
13532 Py_INCREF(Py_None); resultobj = Py_None;
13533 return resultobj;
13534 fail:
13535 return NULL;
13536 }
13537
13538
13539 static PyObject *_wrap_DC_DrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13540 PyObject *resultobj;
13541 wxDC *arg1 = (wxDC *) 0 ;
13542 wxBitmap *arg2 = 0 ;
13543 int arg3 ;
13544 int arg4 ;
13545 bool arg5 = (bool) false ;
13546 PyObject * obj0 = 0 ;
13547 PyObject * obj1 = 0 ;
13548 PyObject * obj2 = 0 ;
13549 PyObject * obj3 = 0 ;
13550 PyObject * obj4 = 0 ;
13551 char *kwnames[] = {
13552 (char *) "self",(char *) "bmp",(char *) "x",(char *) "y",(char *) "useMask", NULL
13553 };
13554
13555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_DrawBitmap",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13557 if (SWIG_arg_fail(1)) SWIG_fail;
13558 {
13559 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
13560 if (SWIG_arg_fail(2)) SWIG_fail;
13561 if (arg2 == NULL) {
13562 SWIG_null_ref("wxBitmap");
13563 }
13564 if (SWIG_arg_fail(2)) SWIG_fail;
13565 }
13566 {
13567 arg3 = (int)(SWIG_As_int(obj2));
13568 if (SWIG_arg_fail(3)) SWIG_fail;
13569 }
13570 {
13571 arg4 = (int)(SWIG_As_int(obj3));
13572 if (SWIG_arg_fail(4)) SWIG_fail;
13573 }
13574 if (obj4) {
13575 {
13576 arg5 = (bool)(SWIG_As_bool(obj4));
13577 if (SWIG_arg_fail(5)) SWIG_fail;
13578 }
13579 }
13580 {
13581 PyThreadState* __tstate = wxPyBeginAllowThreads();
13582 (arg1)->DrawBitmap((wxBitmap const &)*arg2,arg3,arg4,arg5);
13583
13584 wxPyEndAllowThreads(__tstate);
13585 if (PyErr_Occurred()) SWIG_fail;
13586 }
13587 Py_INCREF(Py_None); resultobj = Py_None;
13588 return resultobj;
13589 fail:
13590 return NULL;
13591 }
13592
13593
13594 static PyObject *_wrap_DC_DrawBitmapPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13595 PyObject *resultobj;
13596 wxDC *arg1 = (wxDC *) 0 ;
13597 wxBitmap *arg2 = 0 ;
13598 wxPoint *arg3 = 0 ;
13599 bool arg4 = (bool) false ;
13600 wxPoint temp3 ;
13601 PyObject * obj0 = 0 ;
13602 PyObject * obj1 = 0 ;
13603 PyObject * obj2 = 0 ;
13604 PyObject * obj3 = 0 ;
13605 char *kwnames[] = {
13606 (char *) "self",(char *) "bmp",(char *) "pt",(char *) "useMask", NULL
13607 };
13608
13609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_DrawBitmapPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13611 if (SWIG_arg_fail(1)) SWIG_fail;
13612 {
13613 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
13614 if (SWIG_arg_fail(2)) SWIG_fail;
13615 if (arg2 == NULL) {
13616 SWIG_null_ref("wxBitmap");
13617 }
13618 if (SWIG_arg_fail(2)) SWIG_fail;
13619 }
13620 {
13621 arg3 = &temp3;
13622 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13623 }
13624 if (obj3) {
13625 {
13626 arg4 = (bool)(SWIG_As_bool(obj3));
13627 if (SWIG_arg_fail(4)) SWIG_fail;
13628 }
13629 }
13630 {
13631 PyThreadState* __tstate = wxPyBeginAllowThreads();
13632 (arg1)->DrawBitmap((wxBitmap const &)*arg2,(wxPoint const &)*arg3,arg4);
13633
13634 wxPyEndAllowThreads(__tstate);
13635 if (PyErr_Occurred()) SWIG_fail;
13636 }
13637 Py_INCREF(Py_None); resultobj = Py_None;
13638 return resultobj;
13639 fail:
13640 return NULL;
13641 }
13642
13643
13644 static PyObject *_wrap_DC_DrawText(PyObject *, PyObject *args, PyObject *kwargs) {
13645 PyObject *resultobj;
13646 wxDC *arg1 = (wxDC *) 0 ;
13647 wxString *arg2 = 0 ;
13648 int arg3 ;
13649 int arg4 ;
13650 bool temp2 = false ;
13651 PyObject * obj0 = 0 ;
13652 PyObject * obj1 = 0 ;
13653 PyObject * obj2 = 0 ;
13654 PyObject * obj3 = 0 ;
13655 char *kwnames[] = {
13656 (char *) "self",(char *) "text",(char *) "x",(char *) "y", NULL
13657 };
13658
13659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawText",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13661 if (SWIG_arg_fail(1)) SWIG_fail;
13662 {
13663 arg2 = wxString_in_helper(obj1);
13664 if (arg2 == NULL) SWIG_fail;
13665 temp2 = true;
13666 }
13667 {
13668 arg3 = (int)(SWIG_As_int(obj2));
13669 if (SWIG_arg_fail(3)) SWIG_fail;
13670 }
13671 {
13672 arg4 = (int)(SWIG_As_int(obj3));
13673 if (SWIG_arg_fail(4)) SWIG_fail;
13674 }
13675 {
13676 PyThreadState* __tstate = wxPyBeginAllowThreads();
13677 (arg1)->DrawText((wxString const &)*arg2,arg3,arg4);
13678
13679 wxPyEndAllowThreads(__tstate);
13680 if (PyErr_Occurred()) SWIG_fail;
13681 }
13682 Py_INCREF(Py_None); resultobj = Py_None;
13683 {
13684 if (temp2)
13685 delete arg2;
13686 }
13687 return resultobj;
13688 fail:
13689 {
13690 if (temp2)
13691 delete arg2;
13692 }
13693 return NULL;
13694 }
13695
13696
13697 static PyObject *_wrap_DC_DrawTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13698 PyObject *resultobj;
13699 wxDC *arg1 = (wxDC *) 0 ;
13700 wxString *arg2 = 0 ;
13701 wxPoint *arg3 = 0 ;
13702 bool temp2 = false ;
13703 wxPoint temp3 ;
13704 PyObject * obj0 = 0 ;
13705 PyObject * obj1 = 0 ;
13706 PyObject * obj2 = 0 ;
13707 char *kwnames[] = {
13708 (char *) "self",(char *) "text",(char *) "pt", NULL
13709 };
13710
13711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawTextPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13713 if (SWIG_arg_fail(1)) SWIG_fail;
13714 {
13715 arg2 = wxString_in_helper(obj1);
13716 if (arg2 == NULL) SWIG_fail;
13717 temp2 = true;
13718 }
13719 {
13720 arg3 = &temp3;
13721 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13722 }
13723 {
13724 PyThreadState* __tstate = wxPyBeginAllowThreads();
13725 (arg1)->DrawText((wxString const &)*arg2,(wxPoint const &)*arg3);
13726
13727 wxPyEndAllowThreads(__tstate);
13728 if (PyErr_Occurred()) SWIG_fail;
13729 }
13730 Py_INCREF(Py_None); resultobj = Py_None;
13731 {
13732 if (temp2)
13733 delete arg2;
13734 }
13735 return resultobj;
13736 fail:
13737 {
13738 if (temp2)
13739 delete arg2;
13740 }
13741 return NULL;
13742 }
13743
13744
13745 static PyObject *_wrap_DC_DrawRotatedText(PyObject *, PyObject *args, PyObject *kwargs) {
13746 PyObject *resultobj;
13747 wxDC *arg1 = (wxDC *) 0 ;
13748 wxString *arg2 = 0 ;
13749 int arg3 ;
13750 int arg4 ;
13751 double arg5 ;
13752 bool temp2 = false ;
13753 PyObject * obj0 = 0 ;
13754 PyObject * obj1 = 0 ;
13755 PyObject * obj2 = 0 ;
13756 PyObject * obj3 = 0 ;
13757 PyObject * obj4 = 0 ;
13758 char *kwnames[] = {
13759 (char *) "self",(char *) "text",(char *) "x",(char *) "y",(char *) "angle", NULL
13760 };
13761
13762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRotatedText",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13764 if (SWIG_arg_fail(1)) SWIG_fail;
13765 {
13766 arg2 = wxString_in_helper(obj1);
13767 if (arg2 == NULL) SWIG_fail;
13768 temp2 = true;
13769 }
13770 {
13771 arg3 = (int)(SWIG_As_int(obj2));
13772 if (SWIG_arg_fail(3)) SWIG_fail;
13773 }
13774 {
13775 arg4 = (int)(SWIG_As_int(obj3));
13776 if (SWIG_arg_fail(4)) SWIG_fail;
13777 }
13778 {
13779 arg5 = (double)(SWIG_As_double(obj4));
13780 if (SWIG_arg_fail(5)) SWIG_fail;
13781 }
13782 {
13783 PyThreadState* __tstate = wxPyBeginAllowThreads();
13784 (arg1)->DrawRotatedText((wxString const &)*arg2,arg3,arg4,arg5);
13785
13786 wxPyEndAllowThreads(__tstate);
13787 if (PyErr_Occurred()) SWIG_fail;
13788 }
13789 Py_INCREF(Py_None); resultobj = Py_None;
13790 {
13791 if (temp2)
13792 delete arg2;
13793 }
13794 return resultobj;
13795 fail:
13796 {
13797 if (temp2)
13798 delete arg2;
13799 }
13800 return NULL;
13801 }
13802
13803
13804 static PyObject *_wrap_DC_DrawRotatedTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13805 PyObject *resultobj;
13806 wxDC *arg1 = (wxDC *) 0 ;
13807 wxString *arg2 = 0 ;
13808 wxPoint *arg3 = 0 ;
13809 double arg4 ;
13810 bool temp2 = false ;
13811 wxPoint temp3 ;
13812 PyObject * obj0 = 0 ;
13813 PyObject * obj1 = 0 ;
13814 PyObject * obj2 = 0 ;
13815 PyObject * obj3 = 0 ;
13816 char *kwnames[] = {
13817 (char *) "self",(char *) "text",(char *) "pt",(char *) "angle", NULL
13818 };
13819
13820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRotatedTextPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13822 if (SWIG_arg_fail(1)) SWIG_fail;
13823 {
13824 arg2 = wxString_in_helper(obj1);
13825 if (arg2 == NULL) SWIG_fail;
13826 temp2 = true;
13827 }
13828 {
13829 arg3 = &temp3;
13830 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13831 }
13832 {
13833 arg4 = (double)(SWIG_As_double(obj3));
13834 if (SWIG_arg_fail(4)) SWIG_fail;
13835 }
13836 {
13837 PyThreadState* __tstate = wxPyBeginAllowThreads();
13838 (arg1)->DrawRotatedText((wxString const &)*arg2,(wxPoint const &)*arg3,arg4);
13839
13840 wxPyEndAllowThreads(__tstate);
13841 if (PyErr_Occurred()) SWIG_fail;
13842 }
13843 Py_INCREF(Py_None); resultobj = Py_None;
13844 {
13845 if (temp2)
13846 delete arg2;
13847 }
13848 return resultobj;
13849 fail:
13850 {
13851 if (temp2)
13852 delete arg2;
13853 }
13854 return NULL;
13855 }
13856
13857
13858 static PyObject *_wrap_DC_Blit(PyObject *, PyObject *args, PyObject *kwargs) {
13859 PyObject *resultobj;
13860 wxDC *arg1 = (wxDC *) 0 ;
13861 int arg2 ;
13862 int arg3 ;
13863 int arg4 ;
13864 int arg5 ;
13865 wxDC *arg6 = (wxDC *) 0 ;
13866 int arg7 ;
13867 int arg8 ;
13868 int arg9 = (int) wxCOPY ;
13869 bool arg10 = (bool) false ;
13870 int arg11 = (int) -1 ;
13871 int arg12 = (int) -1 ;
13872 bool result;
13873 PyObject * obj0 = 0 ;
13874 PyObject * obj1 = 0 ;
13875 PyObject * obj2 = 0 ;
13876 PyObject * obj3 = 0 ;
13877 PyObject * obj4 = 0 ;
13878 PyObject * obj5 = 0 ;
13879 PyObject * obj6 = 0 ;
13880 PyObject * obj7 = 0 ;
13881 PyObject * obj8 = 0 ;
13882 PyObject * obj9 = 0 ;
13883 PyObject * obj10 = 0 ;
13884 PyObject * obj11 = 0 ;
13885 char *kwnames[] = {
13886 (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
13887 };
13888
13889 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;
13890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13891 if (SWIG_arg_fail(1)) SWIG_fail;
13892 {
13893 arg2 = (int)(SWIG_As_int(obj1));
13894 if (SWIG_arg_fail(2)) SWIG_fail;
13895 }
13896 {
13897 arg3 = (int)(SWIG_As_int(obj2));
13898 if (SWIG_arg_fail(3)) SWIG_fail;
13899 }
13900 {
13901 arg4 = (int)(SWIG_As_int(obj3));
13902 if (SWIG_arg_fail(4)) SWIG_fail;
13903 }
13904 {
13905 arg5 = (int)(SWIG_As_int(obj4));
13906 if (SWIG_arg_fail(5)) SWIG_fail;
13907 }
13908 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13909 if (SWIG_arg_fail(6)) SWIG_fail;
13910 {
13911 arg7 = (int)(SWIG_As_int(obj6));
13912 if (SWIG_arg_fail(7)) SWIG_fail;
13913 }
13914 {
13915 arg8 = (int)(SWIG_As_int(obj7));
13916 if (SWIG_arg_fail(8)) SWIG_fail;
13917 }
13918 if (obj8) {
13919 {
13920 arg9 = (int)(SWIG_As_int(obj8));
13921 if (SWIG_arg_fail(9)) SWIG_fail;
13922 }
13923 }
13924 if (obj9) {
13925 {
13926 arg10 = (bool)(SWIG_As_bool(obj9));
13927 if (SWIG_arg_fail(10)) SWIG_fail;
13928 }
13929 }
13930 if (obj10) {
13931 {
13932 arg11 = (int)(SWIG_As_int(obj10));
13933 if (SWIG_arg_fail(11)) SWIG_fail;
13934 }
13935 }
13936 if (obj11) {
13937 {
13938 arg12 = (int)(SWIG_As_int(obj11));
13939 if (SWIG_arg_fail(12)) SWIG_fail;
13940 }
13941 }
13942 {
13943 PyThreadState* __tstate = wxPyBeginAllowThreads();
13944 result = (bool)(arg1)->Blit(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
13945
13946 wxPyEndAllowThreads(__tstate);
13947 if (PyErr_Occurred()) SWIG_fail;
13948 }
13949 {
13950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13951 }
13952 return resultobj;
13953 fail:
13954 return NULL;
13955 }
13956
13957
13958 static PyObject *_wrap_DC_BlitPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13959 PyObject *resultobj;
13960 wxDC *arg1 = (wxDC *) 0 ;
13961 wxPoint *arg2 = 0 ;
13962 wxSize *arg3 = 0 ;
13963 wxDC *arg4 = (wxDC *) 0 ;
13964 wxPoint *arg5 = 0 ;
13965 int arg6 = (int) wxCOPY ;
13966 bool arg7 = (bool) false ;
13967 wxPoint const &arg8_defvalue = wxDefaultPosition ;
13968 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
13969 bool result;
13970 wxPoint temp2 ;
13971 wxSize temp3 ;
13972 wxPoint temp5 ;
13973 wxPoint temp8 ;
13974 PyObject * obj0 = 0 ;
13975 PyObject * obj1 = 0 ;
13976 PyObject * obj2 = 0 ;
13977 PyObject * obj3 = 0 ;
13978 PyObject * obj4 = 0 ;
13979 PyObject * obj5 = 0 ;
13980 PyObject * obj6 = 0 ;
13981 PyObject * obj7 = 0 ;
13982 char *kwnames[] = {
13983 (char *) "self",(char *) "destPt",(char *) "sz",(char *) "source",(char *) "srcPt",(char *) "rop",(char *) "useMask",(char *) "srcPtMask", NULL
13984 };
13985
13986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:DC_BlitPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
13987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13988 if (SWIG_arg_fail(1)) SWIG_fail;
13989 {
13990 arg2 = &temp2;
13991 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13992 }
13993 {
13994 arg3 = &temp3;
13995 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13996 }
13997 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13998 if (SWIG_arg_fail(4)) SWIG_fail;
13999 {
14000 arg5 = &temp5;
14001 if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
14002 }
14003 if (obj5) {
14004 {
14005 arg6 = (int)(SWIG_As_int(obj5));
14006 if (SWIG_arg_fail(6)) SWIG_fail;
14007 }
14008 }
14009 if (obj6) {
14010 {
14011 arg7 = (bool)(SWIG_As_bool(obj6));
14012 if (SWIG_arg_fail(7)) SWIG_fail;
14013 }
14014 }
14015 if (obj7) {
14016 {
14017 arg8 = &temp8;
14018 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
14019 }
14020 }
14021 {
14022 PyThreadState* __tstate = wxPyBeginAllowThreads();
14023 result = (bool)(arg1)->Blit((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,(wxPoint const &)*arg5,arg6,arg7,(wxPoint const &)*arg8);
14024
14025 wxPyEndAllowThreads(__tstate);
14026 if (PyErr_Occurred()) SWIG_fail;
14027 }
14028 {
14029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14030 }
14031 return resultobj;
14032 fail:
14033 return NULL;
14034 }
14035
14036
14037 static PyObject *_wrap_DC_SetClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14038 PyObject *resultobj;
14039 wxDC *arg1 = (wxDC *) 0 ;
14040 int arg2 ;
14041 int arg3 ;
14042 int arg4 ;
14043 int arg5 ;
14044 PyObject * obj0 = 0 ;
14045 PyObject * obj1 = 0 ;
14046 PyObject * obj2 = 0 ;
14047 PyObject * obj3 = 0 ;
14048 PyObject * obj4 = 0 ;
14049 char *kwnames[] = {
14050 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
14051 };
14052
14053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_SetClippingRegion",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14055 if (SWIG_arg_fail(1)) SWIG_fail;
14056 {
14057 arg2 = (int)(SWIG_As_int(obj1));
14058 if (SWIG_arg_fail(2)) SWIG_fail;
14059 }
14060 {
14061 arg3 = (int)(SWIG_As_int(obj2));
14062 if (SWIG_arg_fail(3)) SWIG_fail;
14063 }
14064 {
14065 arg4 = (int)(SWIG_As_int(obj3));
14066 if (SWIG_arg_fail(4)) SWIG_fail;
14067 }
14068 {
14069 arg5 = (int)(SWIG_As_int(obj4));
14070 if (SWIG_arg_fail(5)) SWIG_fail;
14071 }
14072 {
14073 PyThreadState* __tstate = wxPyBeginAllowThreads();
14074 (arg1)->SetClippingRegion(arg2,arg3,arg4,arg5);
14075
14076 wxPyEndAllowThreads(__tstate);
14077 if (PyErr_Occurred()) SWIG_fail;
14078 }
14079 Py_INCREF(Py_None); resultobj = Py_None;
14080 return resultobj;
14081 fail:
14082 return NULL;
14083 }
14084
14085
14086 static PyObject *_wrap_DC_SetClippingRegionPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14087 PyObject *resultobj;
14088 wxDC *arg1 = (wxDC *) 0 ;
14089 wxPoint *arg2 = 0 ;
14090 wxSize *arg3 = 0 ;
14091 wxPoint temp2 ;
14092 wxSize temp3 ;
14093 PyObject * obj0 = 0 ;
14094 PyObject * obj1 = 0 ;
14095 PyObject * obj2 = 0 ;
14096 char *kwnames[] = {
14097 (char *) "self",(char *) "pt",(char *) "sz", NULL
14098 };
14099
14100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetClippingRegionPointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14102 if (SWIG_arg_fail(1)) SWIG_fail;
14103 {
14104 arg2 = &temp2;
14105 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14106 }
14107 {
14108 arg3 = &temp3;
14109 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14110 }
14111 {
14112 PyThreadState* __tstate = wxPyBeginAllowThreads();
14113 (arg1)->SetClippingRegion((wxPoint const &)*arg2,(wxSize const &)*arg3);
14114
14115 wxPyEndAllowThreads(__tstate);
14116 if (PyErr_Occurred()) SWIG_fail;
14117 }
14118 Py_INCREF(Py_None); resultobj = Py_None;
14119 return resultobj;
14120 fail:
14121 return NULL;
14122 }
14123
14124
14125 static PyObject *_wrap_DC_SetClippingRegionAsRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14126 PyObject *resultobj;
14127 wxDC *arg1 = (wxDC *) 0 ;
14128 wxRegion *arg2 = 0 ;
14129 PyObject * obj0 = 0 ;
14130 PyObject * obj1 = 0 ;
14131 char *kwnames[] = {
14132 (char *) "self",(char *) "region", NULL
14133 };
14134
14135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRegionAsRegion",kwnames,&obj0,&obj1)) goto fail;
14136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14137 if (SWIG_arg_fail(1)) SWIG_fail;
14138 {
14139 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
14140 if (SWIG_arg_fail(2)) SWIG_fail;
14141 if (arg2 == NULL) {
14142 SWIG_null_ref("wxRegion");
14143 }
14144 if (SWIG_arg_fail(2)) SWIG_fail;
14145 }
14146 {
14147 PyThreadState* __tstate = wxPyBeginAllowThreads();
14148 (arg1)->SetClippingRegion((wxRegion const &)*arg2);
14149
14150 wxPyEndAllowThreads(__tstate);
14151 if (PyErr_Occurred()) SWIG_fail;
14152 }
14153 Py_INCREF(Py_None); resultobj = Py_None;
14154 return resultobj;
14155 fail:
14156 return NULL;
14157 }
14158
14159
14160 static PyObject *_wrap_DC_SetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
14161 PyObject *resultobj;
14162 wxDC *arg1 = (wxDC *) 0 ;
14163 wxRect *arg2 = 0 ;
14164 wxRect temp2 ;
14165 PyObject * obj0 = 0 ;
14166 PyObject * obj1 = 0 ;
14167 char *kwnames[] = {
14168 (char *) "self",(char *) "rect", NULL
14169 };
14170
14171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRect",kwnames,&obj0,&obj1)) goto fail;
14172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14173 if (SWIG_arg_fail(1)) SWIG_fail;
14174 {
14175 arg2 = &temp2;
14176 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14177 }
14178 {
14179 PyThreadState* __tstate = wxPyBeginAllowThreads();
14180 (arg1)->SetClippingRegion((wxRect const &)*arg2);
14181
14182 wxPyEndAllowThreads(__tstate);
14183 if (PyErr_Occurred()) SWIG_fail;
14184 }
14185 Py_INCREF(Py_None); resultobj = Py_None;
14186 return resultobj;
14187 fail:
14188 return NULL;
14189 }
14190
14191
14192 static PyObject *_wrap_DC_DrawLines(PyObject *, PyObject *args, PyObject *kwargs) {
14193 PyObject *resultobj;
14194 wxDC *arg1 = (wxDC *) 0 ;
14195 int arg2 ;
14196 wxPoint *arg3 = (wxPoint *) 0 ;
14197 int arg4 = (int) 0 ;
14198 int arg5 = (int) 0 ;
14199 PyObject * obj0 = 0 ;
14200 PyObject * obj1 = 0 ;
14201 PyObject * obj2 = 0 ;
14202 PyObject * obj3 = 0 ;
14203 char *kwnames[] = {
14204 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset", NULL
14205 };
14206
14207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DC_DrawLines",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14209 if (SWIG_arg_fail(1)) SWIG_fail;
14210 {
14211 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14212 if (arg3 == NULL) SWIG_fail;
14213 }
14214 if (obj2) {
14215 {
14216 arg4 = (int)(SWIG_As_int(obj2));
14217 if (SWIG_arg_fail(4)) SWIG_fail;
14218 }
14219 }
14220 if (obj3) {
14221 {
14222 arg5 = (int)(SWIG_As_int(obj3));
14223 if (SWIG_arg_fail(5)) SWIG_fail;
14224 }
14225 }
14226 {
14227 PyThreadState* __tstate = wxPyBeginAllowThreads();
14228 (arg1)->DrawLines(arg2,arg3,arg4,arg5);
14229
14230 wxPyEndAllowThreads(__tstate);
14231 if (PyErr_Occurred()) SWIG_fail;
14232 }
14233 Py_INCREF(Py_None); resultobj = Py_None;
14234 {
14235 if (arg3) delete [] arg3;
14236 }
14237 return resultobj;
14238 fail:
14239 {
14240 if (arg3) delete [] arg3;
14241 }
14242 return NULL;
14243 }
14244
14245
14246 static PyObject *_wrap_DC_DrawPolygon(PyObject *, PyObject *args, PyObject *kwargs) {
14247 PyObject *resultobj;
14248 wxDC *arg1 = (wxDC *) 0 ;
14249 int arg2 ;
14250 wxPoint *arg3 = (wxPoint *) 0 ;
14251 int arg4 = (int) 0 ;
14252 int arg5 = (int) 0 ;
14253 int arg6 = (int) wxODDEVEN_RULE ;
14254 PyObject * obj0 = 0 ;
14255 PyObject * obj1 = 0 ;
14256 PyObject * obj2 = 0 ;
14257 PyObject * obj3 = 0 ;
14258 PyObject * obj4 = 0 ;
14259 char *kwnames[] = {
14260 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset",(char *) "fillStyle", NULL
14261 };
14262
14263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DC_DrawPolygon",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14265 if (SWIG_arg_fail(1)) SWIG_fail;
14266 {
14267 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14268 if (arg3 == NULL) SWIG_fail;
14269 }
14270 if (obj2) {
14271 {
14272 arg4 = (int)(SWIG_As_int(obj2));
14273 if (SWIG_arg_fail(4)) SWIG_fail;
14274 }
14275 }
14276 if (obj3) {
14277 {
14278 arg5 = (int)(SWIG_As_int(obj3));
14279 if (SWIG_arg_fail(5)) SWIG_fail;
14280 }
14281 }
14282 if (obj4) {
14283 {
14284 arg6 = (int)(SWIG_As_int(obj4));
14285 if (SWIG_arg_fail(6)) SWIG_fail;
14286 }
14287 }
14288 {
14289 PyThreadState* __tstate = wxPyBeginAllowThreads();
14290 (arg1)->DrawPolygon(arg2,arg3,arg4,arg5,arg6);
14291
14292 wxPyEndAllowThreads(__tstate);
14293 if (PyErr_Occurred()) SWIG_fail;
14294 }
14295 Py_INCREF(Py_None); resultobj = Py_None;
14296 {
14297 if (arg3) delete [] arg3;
14298 }
14299 return resultobj;
14300 fail:
14301 {
14302 if (arg3) delete [] arg3;
14303 }
14304 return NULL;
14305 }
14306
14307
14308 static PyObject *_wrap_DC_DrawLabel(PyObject *, PyObject *args, PyObject *kwargs) {
14309 PyObject *resultobj;
14310 wxDC *arg1 = (wxDC *) 0 ;
14311 wxString *arg2 = 0 ;
14312 wxRect *arg3 = 0 ;
14313 int arg4 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
14314 int arg5 = (int) -1 ;
14315 bool temp2 = false ;
14316 wxRect temp3 ;
14317 PyObject * obj0 = 0 ;
14318 PyObject * obj1 = 0 ;
14319 PyObject * obj2 = 0 ;
14320 PyObject * obj3 = 0 ;
14321 PyObject * obj4 = 0 ;
14322 char *kwnames[] = {
14323 (char *) "self",(char *) "text",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
14324 };
14325
14326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:DC_DrawLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14328 if (SWIG_arg_fail(1)) SWIG_fail;
14329 {
14330 arg2 = wxString_in_helper(obj1);
14331 if (arg2 == NULL) SWIG_fail;
14332 temp2 = true;
14333 }
14334 {
14335 arg3 = &temp3;
14336 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
14337 }
14338 if (obj3) {
14339 {
14340 arg4 = (int)(SWIG_As_int(obj3));
14341 if (SWIG_arg_fail(4)) SWIG_fail;
14342 }
14343 }
14344 if (obj4) {
14345 {
14346 arg5 = (int)(SWIG_As_int(obj4));
14347 if (SWIG_arg_fail(5)) SWIG_fail;
14348 }
14349 }
14350 {
14351 PyThreadState* __tstate = wxPyBeginAllowThreads();
14352 (arg1)->DrawLabel((wxString const &)*arg2,(wxRect const &)*arg3,arg4,arg5);
14353
14354 wxPyEndAllowThreads(__tstate);
14355 if (PyErr_Occurred()) SWIG_fail;
14356 }
14357 Py_INCREF(Py_None); resultobj = Py_None;
14358 {
14359 if (temp2)
14360 delete arg2;
14361 }
14362 return resultobj;
14363 fail:
14364 {
14365 if (temp2)
14366 delete arg2;
14367 }
14368 return NULL;
14369 }
14370
14371
14372 static PyObject *_wrap_DC_DrawImageLabel(PyObject *, PyObject *args, PyObject *kwargs) {
14373 PyObject *resultobj;
14374 wxDC *arg1 = (wxDC *) 0 ;
14375 wxString *arg2 = 0 ;
14376 wxBitmap *arg3 = 0 ;
14377 wxRect *arg4 = 0 ;
14378 int arg5 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
14379 int arg6 = (int) -1 ;
14380 wxRect result;
14381 bool temp2 = false ;
14382 wxRect temp4 ;
14383 PyObject * obj0 = 0 ;
14384 PyObject * obj1 = 0 ;
14385 PyObject * obj2 = 0 ;
14386 PyObject * obj3 = 0 ;
14387 PyObject * obj4 = 0 ;
14388 PyObject * obj5 = 0 ;
14389 char *kwnames[] = {
14390 (char *) "self",(char *) "text",(char *) "image",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
14391 };
14392
14393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:DC_DrawImageLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
14394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14395 if (SWIG_arg_fail(1)) SWIG_fail;
14396 {
14397 arg2 = wxString_in_helper(obj1);
14398 if (arg2 == NULL) SWIG_fail;
14399 temp2 = true;
14400 }
14401 {
14402 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
14403 if (SWIG_arg_fail(3)) SWIG_fail;
14404 if (arg3 == NULL) {
14405 SWIG_null_ref("wxBitmap");
14406 }
14407 if (SWIG_arg_fail(3)) SWIG_fail;
14408 }
14409 {
14410 arg4 = &temp4;
14411 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
14412 }
14413 if (obj4) {
14414 {
14415 arg5 = (int)(SWIG_As_int(obj4));
14416 if (SWIG_arg_fail(5)) SWIG_fail;
14417 }
14418 }
14419 if (obj5) {
14420 {
14421 arg6 = (int)(SWIG_As_int(obj5));
14422 if (SWIG_arg_fail(6)) SWIG_fail;
14423 }
14424 }
14425 {
14426 PyThreadState* __tstate = wxPyBeginAllowThreads();
14427 result = wxDC_DrawImageLabel(arg1,(wxString const &)*arg2,(wxBitmap const &)*arg3,(wxRect const &)*arg4,arg5,arg6);
14428
14429 wxPyEndAllowThreads(__tstate);
14430 if (PyErr_Occurred()) SWIG_fail;
14431 }
14432 {
14433 wxRect * resultptr;
14434 resultptr = new wxRect((wxRect &)(result));
14435 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
14436 }
14437 {
14438 if (temp2)
14439 delete arg2;
14440 }
14441 return resultobj;
14442 fail:
14443 {
14444 if (temp2)
14445 delete arg2;
14446 }
14447 return NULL;
14448 }
14449
14450
14451 static PyObject *_wrap_DC_DrawSpline(PyObject *, PyObject *args, PyObject *kwargs) {
14452 PyObject *resultobj;
14453 wxDC *arg1 = (wxDC *) 0 ;
14454 int arg2 ;
14455 wxPoint *arg3 = (wxPoint *) 0 ;
14456 PyObject * obj0 = 0 ;
14457 PyObject * obj1 = 0 ;
14458 char *kwnames[] = {
14459 (char *) "self",(char *) "points", NULL
14460 };
14461
14462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawSpline",kwnames,&obj0,&obj1)) goto fail;
14463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14464 if (SWIG_arg_fail(1)) SWIG_fail;
14465 {
14466 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14467 if (arg3 == NULL) SWIG_fail;
14468 }
14469 {
14470 PyThreadState* __tstate = wxPyBeginAllowThreads();
14471 (arg1)->DrawSpline(arg2,arg3);
14472
14473 wxPyEndAllowThreads(__tstate);
14474 if (PyErr_Occurred()) SWIG_fail;
14475 }
14476 Py_INCREF(Py_None); resultobj = Py_None;
14477 {
14478 if (arg3) delete [] arg3;
14479 }
14480 return resultobj;
14481 fail:
14482 {
14483 if (arg3) delete [] arg3;
14484 }
14485 return NULL;
14486 }
14487
14488
14489 static PyObject *_wrap_DC_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
14490 PyObject *resultobj;
14491 wxDC *arg1 = (wxDC *) 0 ;
14492 PyObject * obj0 = 0 ;
14493 char *kwnames[] = {
14494 (char *) "self", NULL
14495 };
14496
14497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Clear",kwnames,&obj0)) goto fail;
14498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14499 if (SWIG_arg_fail(1)) SWIG_fail;
14500 {
14501 PyThreadState* __tstate = wxPyBeginAllowThreads();
14502 (arg1)->Clear();
14503
14504 wxPyEndAllowThreads(__tstate);
14505 if (PyErr_Occurred()) SWIG_fail;
14506 }
14507 Py_INCREF(Py_None); resultobj = Py_None;
14508 return resultobj;
14509 fail:
14510 return NULL;
14511 }
14512
14513
14514 static PyObject *_wrap_DC_StartDoc(PyObject *, PyObject *args, PyObject *kwargs) {
14515 PyObject *resultobj;
14516 wxDC *arg1 = (wxDC *) 0 ;
14517 wxString *arg2 = 0 ;
14518 bool result;
14519 bool temp2 = false ;
14520 PyObject * obj0 = 0 ;
14521 PyObject * obj1 = 0 ;
14522 char *kwnames[] = {
14523 (char *) "self",(char *) "message", NULL
14524 };
14525
14526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_StartDoc",kwnames,&obj0,&obj1)) goto fail;
14527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14528 if (SWIG_arg_fail(1)) SWIG_fail;
14529 {
14530 arg2 = wxString_in_helper(obj1);
14531 if (arg2 == NULL) SWIG_fail;
14532 temp2 = true;
14533 }
14534 {
14535 PyThreadState* __tstate = wxPyBeginAllowThreads();
14536 result = (bool)(arg1)->StartDoc((wxString const &)*arg2);
14537
14538 wxPyEndAllowThreads(__tstate);
14539 if (PyErr_Occurred()) SWIG_fail;
14540 }
14541 {
14542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14543 }
14544 {
14545 if (temp2)
14546 delete arg2;
14547 }
14548 return resultobj;
14549 fail:
14550 {
14551 if (temp2)
14552 delete arg2;
14553 }
14554 return NULL;
14555 }
14556
14557
14558 static PyObject *_wrap_DC_EndDoc(PyObject *, PyObject *args, PyObject *kwargs) {
14559 PyObject *resultobj;
14560 wxDC *arg1 = (wxDC *) 0 ;
14561 PyObject * obj0 = 0 ;
14562 char *kwnames[] = {
14563 (char *) "self", NULL
14564 };
14565
14566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDoc",kwnames,&obj0)) goto fail;
14567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14568 if (SWIG_arg_fail(1)) SWIG_fail;
14569 {
14570 PyThreadState* __tstate = wxPyBeginAllowThreads();
14571 (arg1)->EndDoc();
14572
14573 wxPyEndAllowThreads(__tstate);
14574 if (PyErr_Occurred()) SWIG_fail;
14575 }
14576 Py_INCREF(Py_None); resultobj = Py_None;
14577 return resultobj;
14578 fail:
14579 return NULL;
14580 }
14581
14582
14583 static PyObject *_wrap_DC_StartPage(PyObject *, PyObject *args, PyObject *kwargs) {
14584 PyObject *resultobj;
14585 wxDC *arg1 = (wxDC *) 0 ;
14586 PyObject * obj0 = 0 ;
14587 char *kwnames[] = {
14588 (char *) "self", NULL
14589 };
14590
14591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_StartPage",kwnames,&obj0)) goto fail;
14592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14593 if (SWIG_arg_fail(1)) SWIG_fail;
14594 {
14595 PyThreadState* __tstate = wxPyBeginAllowThreads();
14596 (arg1)->StartPage();
14597
14598 wxPyEndAllowThreads(__tstate);
14599 if (PyErr_Occurred()) SWIG_fail;
14600 }
14601 Py_INCREF(Py_None); resultobj = Py_None;
14602 return resultobj;
14603 fail:
14604 return NULL;
14605 }
14606
14607
14608 static PyObject *_wrap_DC_EndPage(PyObject *, PyObject *args, PyObject *kwargs) {
14609 PyObject *resultobj;
14610 wxDC *arg1 = (wxDC *) 0 ;
14611 PyObject * obj0 = 0 ;
14612 char *kwnames[] = {
14613 (char *) "self", NULL
14614 };
14615
14616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndPage",kwnames,&obj0)) goto fail;
14617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14618 if (SWIG_arg_fail(1)) SWIG_fail;
14619 {
14620 PyThreadState* __tstate = wxPyBeginAllowThreads();
14621 (arg1)->EndPage();
14622
14623 wxPyEndAllowThreads(__tstate);
14624 if (PyErr_Occurred()) SWIG_fail;
14625 }
14626 Py_INCREF(Py_None); resultobj = Py_None;
14627 return resultobj;
14628 fail:
14629 return NULL;
14630 }
14631
14632
14633 static PyObject *_wrap_DC_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
14634 PyObject *resultobj;
14635 wxDC *arg1 = (wxDC *) 0 ;
14636 wxFont *arg2 = 0 ;
14637 PyObject * obj0 = 0 ;
14638 PyObject * obj1 = 0 ;
14639 char *kwnames[] = {
14640 (char *) "self",(char *) "font", NULL
14641 };
14642
14643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetFont",kwnames,&obj0,&obj1)) goto fail;
14644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14645 if (SWIG_arg_fail(1)) SWIG_fail;
14646 {
14647 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
14648 if (SWIG_arg_fail(2)) SWIG_fail;
14649 if (arg2 == NULL) {
14650 SWIG_null_ref("wxFont");
14651 }
14652 if (SWIG_arg_fail(2)) SWIG_fail;
14653 }
14654 {
14655 PyThreadState* __tstate = wxPyBeginAllowThreads();
14656 (arg1)->SetFont((wxFont const &)*arg2);
14657
14658 wxPyEndAllowThreads(__tstate);
14659 if (PyErr_Occurred()) SWIG_fail;
14660 }
14661 Py_INCREF(Py_None); resultobj = Py_None;
14662 return resultobj;
14663 fail:
14664 return NULL;
14665 }
14666
14667
14668 static PyObject *_wrap_DC_SetPen(PyObject *, PyObject *args, PyObject *kwargs) {
14669 PyObject *resultobj;
14670 wxDC *arg1 = (wxDC *) 0 ;
14671 wxPen *arg2 = 0 ;
14672 PyObject * obj0 = 0 ;
14673 PyObject * obj1 = 0 ;
14674 char *kwnames[] = {
14675 (char *) "self",(char *) "pen", NULL
14676 };
14677
14678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPen",kwnames,&obj0,&obj1)) goto fail;
14679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14680 if (SWIG_arg_fail(1)) SWIG_fail;
14681 {
14682 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
14683 if (SWIG_arg_fail(2)) SWIG_fail;
14684 if (arg2 == NULL) {
14685 SWIG_null_ref("wxPen");
14686 }
14687 if (SWIG_arg_fail(2)) SWIG_fail;
14688 }
14689 {
14690 PyThreadState* __tstate = wxPyBeginAllowThreads();
14691 (arg1)->SetPen((wxPen const &)*arg2);
14692
14693 wxPyEndAllowThreads(__tstate);
14694 if (PyErr_Occurred()) SWIG_fail;
14695 }
14696 Py_INCREF(Py_None); resultobj = Py_None;
14697 return resultobj;
14698 fail:
14699 return NULL;
14700 }
14701
14702
14703 static PyObject *_wrap_DC_SetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
14704 PyObject *resultobj;
14705 wxDC *arg1 = (wxDC *) 0 ;
14706 wxBrush *arg2 = 0 ;
14707 PyObject * obj0 = 0 ;
14708 PyObject * obj1 = 0 ;
14709 char *kwnames[] = {
14710 (char *) "self",(char *) "brush", NULL
14711 };
14712
14713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBrush",kwnames,&obj0,&obj1)) goto fail;
14714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14715 if (SWIG_arg_fail(1)) SWIG_fail;
14716 {
14717 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
14718 if (SWIG_arg_fail(2)) SWIG_fail;
14719 if (arg2 == NULL) {
14720 SWIG_null_ref("wxBrush");
14721 }
14722 if (SWIG_arg_fail(2)) SWIG_fail;
14723 }
14724 {
14725 PyThreadState* __tstate = wxPyBeginAllowThreads();
14726 (arg1)->SetBrush((wxBrush const &)*arg2);
14727
14728 wxPyEndAllowThreads(__tstate);
14729 if (PyErr_Occurred()) SWIG_fail;
14730 }
14731 Py_INCREF(Py_None); resultobj = Py_None;
14732 return resultobj;
14733 fail:
14734 return NULL;
14735 }
14736
14737
14738 static PyObject *_wrap_DC_SetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
14739 PyObject *resultobj;
14740 wxDC *arg1 = (wxDC *) 0 ;
14741 wxBrush *arg2 = 0 ;
14742 PyObject * obj0 = 0 ;
14743 PyObject * obj1 = 0 ;
14744 char *kwnames[] = {
14745 (char *) "self",(char *) "brush", NULL
14746 };
14747
14748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackground",kwnames,&obj0,&obj1)) goto fail;
14749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14750 if (SWIG_arg_fail(1)) SWIG_fail;
14751 {
14752 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
14753 if (SWIG_arg_fail(2)) SWIG_fail;
14754 if (arg2 == NULL) {
14755 SWIG_null_ref("wxBrush");
14756 }
14757 if (SWIG_arg_fail(2)) SWIG_fail;
14758 }
14759 {
14760 PyThreadState* __tstate = wxPyBeginAllowThreads();
14761 (arg1)->SetBackground((wxBrush const &)*arg2);
14762
14763 wxPyEndAllowThreads(__tstate);
14764 if (PyErr_Occurred()) SWIG_fail;
14765 }
14766 Py_INCREF(Py_None); resultobj = Py_None;
14767 return resultobj;
14768 fail:
14769 return NULL;
14770 }
14771
14772
14773 static PyObject *_wrap_DC_SetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
14774 PyObject *resultobj;
14775 wxDC *arg1 = (wxDC *) 0 ;
14776 int arg2 ;
14777 PyObject * obj0 = 0 ;
14778 PyObject * obj1 = 0 ;
14779 char *kwnames[] = {
14780 (char *) "self",(char *) "mode", NULL
14781 };
14782
14783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackgroundMode",kwnames,&obj0,&obj1)) goto fail;
14784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14785 if (SWIG_arg_fail(1)) SWIG_fail;
14786 {
14787 arg2 = (int)(SWIG_As_int(obj1));
14788 if (SWIG_arg_fail(2)) SWIG_fail;
14789 }
14790 {
14791 PyThreadState* __tstate = wxPyBeginAllowThreads();
14792 (arg1)->SetBackgroundMode(arg2);
14793
14794 wxPyEndAllowThreads(__tstate);
14795 if (PyErr_Occurred()) SWIG_fail;
14796 }
14797 Py_INCREF(Py_None); resultobj = Py_None;
14798 return resultobj;
14799 fail:
14800 return NULL;
14801 }
14802
14803
14804 static PyObject *_wrap_DC_SetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
14805 PyObject *resultobj;
14806 wxDC *arg1 = (wxDC *) 0 ;
14807 wxPalette *arg2 = 0 ;
14808 PyObject * obj0 = 0 ;
14809 PyObject * obj1 = 0 ;
14810 char *kwnames[] = {
14811 (char *) "self",(char *) "palette", NULL
14812 };
14813
14814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPalette",kwnames,&obj0,&obj1)) goto fail;
14815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14816 if (SWIG_arg_fail(1)) SWIG_fail;
14817 {
14818 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
14819 if (SWIG_arg_fail(2)) SWIG_fail;
14820 if (arg2 == NULL) {
14821 SWIG_null_ref("wxPalette");
14822 }
14823 if (SWIG_arg_fail(2)) SWIG_fail;
14824 }
14825 {
14826 PyThreadState* __tstate = wxPyBeginAllowThreads();
14827 (arg1)->SetPalette((wxPalette const &)*arg2);
14828
14829 wxPyEndAllowThreads(__tstate);
14830 if (PyErr_Occurred()) SWIG_fail;
14831 }
14832 Py_INCREF(Py_None); resultobj = Py_None;
14833 return resultobj;
14834 fail:
14835 return NULL;
14836 }
14837
14838
14839 static PyObject *_wrap_DC_DestroyClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14840 PyObject *resultobj;
14841 wxDC *arg1 = (wxDC *) 0 ;
14842 PyObject * obj0 = 0 ;
14843 char *kwnames[] = {
14844 (char *) "self", NULL
14845 };
14846
14847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_DestroyClippingRegion",kwnames,&obj0)) goto fail;
14848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14849 if (SWIG_arg_fail(1)) SWIG_fail;
14850 {
14851 PyThreadState* __tstate = wxPyBeginAllowThreads();
14852 (arg1)->DestroyClippingRegion();
14853
14854 wxPyEndAllowThreads(__tstate);
14855 if (PyErr_Occurred()) SWIG_fail;
14856 }
14857 Py_INCREF(Py_None); resultobj = Py_None;
14858 return resultobj;
14859 fail:
14860 return NULL;
14861 }
14862
14863
14864 static PyObject *_wrap_DC_GetClippingBox(PyObject *, PyObject *args, PyObject *kwargs) {
14865 PyObject *resultobj;
14866 wxDC *arg1 = (wxDC *) 0 ;
14867 int *arg2 = (int *) 0 ;
14868 int *arg3 = (int *) 0 ;
14869 int *arg4 = (int *) 0 ;
14870 int *arg5 = (int *) 0 ;
14871 int temp2 ;
14872 int res2 = 0 ;
14873 int temp3 ;
14874 int res3 = 0 ;
14875 int temp4 ;
14876 int res4 = 0 ;
14877 int temp5 ;
14878 int res5 = 0 ;
14879 PyObject * obj0 = 0 ;
14880 char *kwnames[] = {
14881 (char *) "self", NULL
14882 };
14883
14884 arg2 = &temp2; res2 = SWIG_NEWOBJ;
14885 arg3 = &temp3; res3 = SWIG_NEWOBJ;
14886 arg4 = &temp4; res4 = SWIG_NEWOBJ;
14887 arg5 = &temp5; res5 = SWIG_NEWOBJ;
14888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingBox",kwnames,&obj0)) goto fail;
14889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14890 if (SWIG_arg_fail(1)) SWIG_fail;
14891 {
14892 PyThreadState* __tstate = wxPyBeginAllowThreads();
14893 ((wxDC const *)arg1)->GetClippingBox(arg2,arg3,arg4,arg5);
14894
14895 wxPyEndAllowThreads(__tstate);
14896 if (PyErr_Occurred()) SWIG_fail;
14897 }
14898 Py_INCREF(Py_None); resultobj = Py_None;
14899 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
14900 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
14901 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
14902 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
14903 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
14904 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
14905 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
14906 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
14907 return resultobj;
14908 fail:
14909 return NULL;
14910 }
14911
14912
14913 static PyObject *_wrap_DC_GetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
14914 PyObject *resultobj;
14915 wxDC *arg1 = (wxDC *) 0 ;
14916 wxRect result;
14917 PyObject * obj0 = 0 ;
14918 char *kwnames[] = {
14919 (char *) "self", NULL
14920 };
14921
14922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingRect",kwnames,&obj0)) goto fail;
14923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14924 if (SWIG_arg_fail(1)) SWIG_fail;
14925 {
14926 PyThreadState* __tstate = wxPyBeginAllowThreads();
14927 result = wxDC_GetClippingRect(arg1);
14928
14929 wxPyEndAllowThreads(__tstate);
14930 if (PyErr_Occurred()) SWIG_fail;
14931 }
14932 {
14933 wxRect * resultptr;
14934 resultptr = new wxRect((wxRect &)(result));
14935 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
14936 }
14937 return resultobj;
14938 fail:
14939 return NULL;
14940 }
14941
14942
14943 static PyObject *_wrap_DC_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
14944 PyObject *resultobj;
14945 wxDC *arg1 = (wxDC *) 0 ;
14946 int result;
14947 PyObject * obj0 = 0 ;
14948 char *kwnames[] = {
14949 (char *) "self", NULL
14950 };
14951
14952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharHeight",kwnames,&obj0)) goto fail;
14953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14954 if (SWIG_arg_fail(1)) SWIG_fail;
14955 {
14956 PyThreadState* __tstate = wxPyBeginAllowThreads();
14957 result = (int)((wxDC const *)arg1)->GetCharHeight();
14958
14959 wxPyEndAllowThreads(__tstate);
14960 if (PyErr_Occurred()) SWIG_fail;
14961 }
14962 {
14963 resultobj = SWIG_From_int((int)(result));
14964 }
14965 return resultobj;
14966 fail:
14967 return NULL;
14968 }
14969
14970
14971 static PyObject *_wrap_DC_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
14972 PyObject *resultobj;
14973 wxDC *arg1 = (wxDC *) 0 ;
14974 int result;
14975 PyObject * obj0 = 0 ;
14976 char *kwnames[] = {
14977 (char *) "self", NULL
14978 };
14979
14980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharWidth",kwnames,&obj0)) goto fail;
14981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14982 if (SWIG_arg_fail(1)) SWIG_fail;
14983 {
14984 PyThreadState* __tstate = wxPyBeginAllowThreads();
14985 result = (int)((wxDC const *)arg1)->GetCharWidth();
14986
14987 wxPyEndAllowThreads(__tstate);
14988 if (PyErr_Occurred()) SWIG_fail;
14989 }
14990 {
14991 resultobj = SWIG_From_int((int)(result));
14992 }
14993 return resultobj;
14994 fail:
14995 return NULL;
14996 }
14997
14998
14999 static PyObject *_wrap_DC_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15000 PyObject *resultobj;
15001 wxDC *arg1 = (wxDC *) 0 ;
15002 wxString *arg2 = 0 ;
15003 int *arg3 = (int *) 0 ;
15004 int *arg4 = (int *) 0 ;
15005 bool temp2 = false ;
15006 int temp3 ;
15007 int res3 = 0 ;
15008 int temp4 ;
15009 int res4 = 0 ;
15010 PyObject * obj0 = 0 ;
15011 PyObject * obj1 = 0 ;
15012 char *kwnames[] = {
15013 (char *) "self",(char *) "string", NULL
15014 };
15015
15016 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15017 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
15019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15020 if (SWIG_arg_fail(1)) SWIG_fail;
15021 {
15022 arg2 = wxString_in_helper(obj1);
15023 if (arg2 == NULL) SWIG_fail;
15024 temp2 = true;
15025 }
15026 {
15027 PyThreadState* __tstate = wxPyBeginAllowThreads();
15028 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
15029
15030 wxPyEndAllowThreads(__tstate);
15031 if (PyErr_Occurred()) SWIG_fail;
15032 }
15033 Py_INCREF(Py_None); resultobj = Py_None;
15034 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15035 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15036 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15037 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15038 {
15039 if (temp2)
15040 delete arg2;
15041 }
15042 return resultobj;
15043 fail:
15044 {
15045 if (temp2)
15046 delete arg2;
15047 }
15048 return NULL;
15049 }
15050
15051
15052 static PyObject *_wrap_DC_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15053 PyObject *resultobj;
15054 wxDC *arg1 = (wxDC *) 0 ;
15055 wxString *arg2 = 0 ;
15056 int *arg3 = (int *) 0 ;
15057 int *arg4 = (int *) 0 ;
15058 int *arg5 = (int *) 0 ;
15059 int *arg6 = (int *) 0 ;
15060 wxFont *arg7 = (wxFont *) NULL ;
15061 bool temp2 = false ;
15062 int temp3 ;
15063 int res3 = 0 ;
15064 int temp4 ;
15065 int res4 = 0 ;
15066 int temp5 ;
15067 int res5 = 0 ;
15068 int temp6 ;
15069 int res6 = 0 ;
15070 PyObject * obj0 = 0 ;
15071 PyObject * obj1 = 0 ;
15072 PyObject * obj2 = 0 ;
15073 char *kwnames[] = {
15074 (char *) "self",(char *) "string",(char *) "font", NULL
15075 };
15076
15077 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15078 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15079 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15080 arg6 = &temp6; res6 = SWIG_NEWOBJ;
15081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15083 if (SWIG_arg_fail(1)) SWIG_fail;
15084 {
15085 arg2 = wxString_in_helper(obj1);
15086 if (arg2 == NULL) SWIG_fail;
15087 temp2 = true;
15088 }
15089 if (obj2) {
15090 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15091 if (SWIG_arg_fail(7)) SWIG_fail;
15092 }
15093 {
15094 PyThreadState* __tstate = wxPyBeginAllowThreads();
15095 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7);
15096
15097 wxPyEndAllowThreads(__tstate);
15098 if (PyErr_Occurred()) SWIG_fail;
15099 }
15100 Py_INCREF(Py_None); resultobj = Py_None;
15101 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15102 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15103 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15104 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15105 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15106 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15107 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
15108 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
15109 {
15110 if (temp2)
15111 delete arg2;
15112 }
15113 return resultobj;
15114 fail:
15115 {
15116 if (temp2)
15117 delete arg2;
15118 }
15119 return NULL;
15120 }
15121
15122
15123 static PyObject *_wrap_DC_GetMultiLineTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15124 PyObject *resultobj;
15125 wxDC *arg1 = (wxDC *) 0 ;
15126 wxString *arg2 = 0 ;
15127 int *arg3 = (int *) 0 ;
15128 int *arg4 = (int *) 0 ;
15129 int *arg5 = (int *) 0 ;
15130 wxFont *arg6 = (wxFont *) NULL ;
15131 bool temp2 = false ;
15132 int temp3 ;
15133 int res3 = 0 ;
15134 int temp4 ;
15135 int res4 = 0 ;
15136 int temp5 ;
15137 int res5 = 0 ;
15138 PyObject * obj0 = 0 ;
15139 PyObject * obj1 = 0 ;
15140 PyObject * obj2 = 0 ;
15141 char *kwnames[] = {
15142 (char *) "self",(char *) "text",(char *) "font", NULL
15143 };
15144
15145 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15146 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15147 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetMultiLineTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15150 if (SWIG_arg_fail(1)) SWIG_fail;
15151 {
15152 arg2 = wxString_in_helper(obj1);
15153 if (arg2 == NULL) SWIG_fail;
15154 temp2 = true;
15155 }
15156 if (obj2) {
15157 SWIG_Python_ConvertPtr(obj2, (void **)&arg6, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15158 if (SWIG_arg_fail(6)) SWIG_fail;
15159 }
15160 {
15161 PyThreadState* __tstate = wxPyBeginAllowThreads();
15162 (arg1)->GetMultiLineTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6);
15163
15164 wxPyEndAllowThreads(__tstate);
15165 if (PyErr_Occurred()) SWIG_fail;
15166 }
15167 Py_INCREF(Py_None); resultobj = Py_None;
15168 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15169 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15170 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15171 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15172 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15173 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15174 {
15175 if (temp2)
15176 delete arg2;
15177 }
15178 return resultobj;
15179 fail:
15180 {
15181 if (temp2)
15182 delete arg2;
15183 }
15184 return NULL;
15185 }
15186
15187
15188 static PyObject *_wrap_DC_GetPartialTextExtents(PyObject *, PyObject *args, PyObject *kwargs) {
15189 PyObject *resultobj;
15190 wxDC *arg1 = (wxDC *) 0 ;
15191 wxString *arg2 = 0 ;
15192 wxArrayInt result;
15193 bool temp2 = false ;
15194 PyObject * obj0 = 0 ;
15195 PyObject * obj1 = 0 ;
15196 char *kwnames[] = {
15197 (char *) "self",(char *) "text", NULL
15198 };
15199
15200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPartialTextExtents",kwnames,&obj0,&obj1)) goto fail;
15201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15202 if (SWIG_arg_fail(1)) SWIG_fail;
15203 {
15204 arg2 = wxString_in_helper(obj1);
15205 if (arg2 == NULL) SWIG_fail;
15206 temp2 = true;
15207 }
15208 {
15209 PyThreadState* __tstate = wxPyBeginAllowThreads();
15210 result = wxDC_GetPartialTextExtents(arg1,(wxString const &)*arg2);
15211
15212 wxPyEndAllowThreads(__tstate);
15213 if (PyErr_Occurred()) SWIG_fail;
15214 }
15215 {
15216 resultobj = PyList_New(0);
15217 size_t idx;
15218 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
15219 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
15220 PyList_Append(resultobj, val);
15221 Py_DECREF(val);
15222 }
15223 }
15224 {
15225 if (temp2)
15226 delete arg2;
15227 }
15228 return resultobj;
15229 fail:
15230 {
15231 if (temp2)
15232 delete arg2;
15233 }
15234 return NULL;
15235 }
15236
15237
15238 static PyObject *_wrap_DC_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
15239 PyObject *resultobj;
15240 wxDC *arg1 = (wxDC *) 0 ;
15241 wxSize result;
15242 PyObject * obj0 = 0 ;
15243 char *kwnames[] = {
15244 (char *) "self", NULL
15245 };
15246
15247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSize",kwnames,&obj0)) goto fail;
15248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15249 if (SWIG_arg_fail(1)) SWIG_fail;
15250 {
15251 PyThreadState* __tstate = wxPyBeginAllowThreads();
15252 result = (arg1)->GetSize();
15253
15254 wxPyEndAllowThreads(__tstate);
15255 if (PyErr_Occurred()) SWIG_fail;
15256 }
15257 {
15258 wxSize * resultptr;
15259 resultptr = new wxSize((wxSize &)(result));
15260 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15261 }
15262 return resultobj;
15263 fail:
15264 return NULL;
15265 }
15266
15267
15268 static PyObject *_wrap_DC_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
15269 PyObject *resultobj;
15270 wxDC *arg1 = (wxDC *) 0 ;
15271 int *arg2 = (int *) 0 ;
15272 int *arg3 = (int *) 0 ;
15273 int temp2 ;
15274 int res2 = 0 ;
15275 int temp3 ;
15276 int res3 = 0 ;
15277 PyObject * obj0 = 0 ;
15278 char *kwnames[] = {
15279 (char *) "self", NULL
15280 };
15281
15282 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15283 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeTuple",kwnames,&obj0)) goto fail;
15285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15286 if (SWIG_arg_fail(1)) SWIG_fail;
15287 {
15288 PyThreadState* __tstate = wxPyBeginAllowThreads();
15289 (arg1)->GetSize(arg2,arg3);
15290
15291 wxPyEndAllowThreads(__tstate);
15292 if (PyErr_Occurred()) SWIG_fail;
15293 }
15294 Py_INCREF(Py_None); resultobj = Py_None;
15295 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15296 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15297 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15298 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15299 return resultobj;
15300 fail:
15301 return NULL;
15302 }
15303
15304
15305 static PyObject *_wrap_DC_GetSizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
15306 PyObject *resultobj;
15307 wxDC *arg1 = (wxDC *) 0 ;
15308 wxSize result;
15309 PyObject * obj0 = 0 ;
15310 char *kwnames[] = {
15311 (char *) "self", NULL
15312 };
15313
15314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMM",kwnames,&obj0)) goto fail;
15315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15316 if (SWIG_arg_fail(1)) SWIG_fail;
15317 {
15318 PyThreadState* __tstate = wxPyBeginAllowThreads();
15319 result = ((wxDC const *)arg1)->GetSizeMM();
15320
15321 wxPyEndAllowThreads(__tstate);
15322 if (PyErr_Occurred()) SWIG_fail;
15323 }
15324 {
15325 wxSize * resultptr;
15326 resultptr = new wxSize((wxSize &)(result));
15327 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15328 }
15329 return resultobj;
15330 fail:
15331 return NULL;
15332 }
15333
15334
15335 static PyObject *_wrap_DC_GetSizeMMTuple(PyObject *, PyObject *args, PyObject *kwargs) {
15336 PyObject *resultobj;
15337 wxDC *arg1 = (wxDC *) 0 ;
15338 int *arg2 = (int *) 0 ;
15339 int *arg3 = (int *) 0 ;
15340 int temp2 ;
15341 int res2 = 0 ;
15342 int temp3 ;
15343 int res3 = 0 ;
15344 PyObject * obj0 = 0 ;
15345 char *kwnames[] = {
15346 (char *) "self", NULL
15347 };
15348
15349 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15350 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMMTuple",kwnames,&obj0)) goto fail;
15352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15353 if (SWIG_arg_fail(1)) SWIG_fail;
15354 {
15355 PyThreadState* __tstate = wxPyBeginAllowThreads();
15356 ((wxDC const *)arg1)->GetSizeMM(arg2,arg3);
15357
15358 wxPyEndAllowThreads(__tstate);
15359 if (PyErr_Occurred()) SWIG_fail;
15360 }
15361 Py_INCREF(Py_None); resultobj = Py_None;
15362 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15363 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15364 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15365 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15366 return resultobj;
15367 fail:
15368 return NULL;
15369 }
15370
15371
15372 static PyObject *_wrap_DC_DeviceToLogicalX(PyObject *, PyObject *args, PyObject *kwargs) {
15373 PyObject *resultobj;
15374 wxDC *arg1 = (wxDC *) 0 ;
15375 int arg2 ;
15376 int result;
15377 PyObject * obj0 = 0 ;
15378 PyObject * obj1 = 0 ;
15379 char *kwnames[] = {
15380 (char *) "self",(char *) "x", NULL
15381 };
15382
15383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalX",kwnames,&obj0,&obj1)) goto fail;
15384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15385 if (SWIG_arg_fail(1)) SWIG_fail;
15386 {
15387 arg2 = (int)(SWIG_As_int(obj1));
15388 if (SWIG_arg_fail(2)) SWIG_fail;
15389 }
15390 {
15391 PyThreadState* __tstate = wxPyBeginAllowThreads();
15392 result = (int)((wxDC const *)arg1)->DeviceToLogicalX(arg2);
15393
15394 wxPyEndAllowThreads(__tstate);
15395 if (PyErr_Occurred()) SWIG_fail;
15396 }
15397 {
15398 resultobj = SWIG_From_int((int)(result));
15399 }
15400 return resultobj;
15401 fail:
15402 return NULL;
15403 }
15404
15405
15406 static PyObject *_wrap_DC_DeviceToLogicalY(PyObject *, PyObject *args, PyObject *kwargs) {
15407 PyObject *resultobj;
15408 wxDC *arg1 = (wxDC *) 0 ;
15409 int arg2 ;
15410 int result;
15411 PyObject * obj0 = 0 ;
15412 PyObject * obj1 = 0 ;
15413 char *kwnames[] = {
15414 (char *) "self",(char *) "y", NULL
15415 };
15416
15417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalY",kwnames,&obj0,&obj1)) goto fail;
15418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15419 if (SWIG_arg_fail(1)) SWIG_fail;
15420 {
15421 arg2 = (int)(SWIG_As_int(obj1));
15422 if (SWIG_arg_fail(2)) SWIG_fail;
15423 }
15424 {
15425 PyThreadState* __tstate = wxPyBeginAllowThreads();
15426 result = (int)((wxDC const *)arg1)->DeviceToLogicalY(arg2);
15427
15428 wxPyEndAllowThreads(__tstate);
15429 if (PyErr_Occurred()) SWIG_fail;
15430 }
15431 {
15432 resultobj = SWIG_From_int((int)(result));
15433 }
15434 return resultobj;
15435 fail:
15436 return NULL;
15437 }
15438
15439
15440 static PyObject *_wrap_DC_DeviceToLogicalXRel(PyObject *, PyObject *args, PyObject *kwargs) {
15441 PyObject *resultobj;
15442 wxDC *arg1 = (wxDC *) 0 ;
15443 int arg2 ;
15444 int result;
15445 PyObject * obj0 = 0 ;
15446 PyObject * obj1 = 0 ;
15447 char *kwnames[] = {
15448 (char *) "self",(char *) "x", NULL
15449 };
15450
15451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalXRel",kwnames,&obj0,&obj1)) goto fail;
15452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15453 if (SWIG_arg_fail(1)) SWIG_fail;
15454 {
15455 arg2 = (int)(SWIG_As_int(obj1));
15456 if (SWIG_arg_fail(2)) SWIG_fail;
15457 }
15458 {
15459 PyThreadState* __tstate = wxPyBeginAllowThreads();
15460 result = (int)((wxDC const *)arg1)->DeviceToLogicalXRel(arg2);
15461
15462 wxPyEndAllowThreads(__tstate);
15463 if (PyErr_Occurred()) SWIG_fail;
15464 }
15465 {
15466 resultobj = SWIG_From_int((int)(result));
15467 }
15468 return resultobj;
15469 fail:
15470 return NULL;
15471 }
15472
15473
15474 static PyObject *_wrap_DC_DeviceToLogicalYRel(PyObject *, PyObject *args, PyObject *kwargs) {
15475 PyObject *resultobj;
15476 wxDC *arg1 = (wxDC *) 0 ;
15477 int arg2 ;
15478 int result;
15479 PyObject * obj0 = 0 ;
15480 PyObject * obj1 = 0 ;
15481 char *kwnames[] = {
15482 (char *) "self",(char *) "y", NULL
15483 };
15484
15485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalYRel",kwnames,&obj0,&obj1)) goto fail;
15486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15487 if (SWIG_arg_fail(1)) SWIG_fail;
15488 {
15489 arg2 = (int)(SWIG_As_int(obj1));
15490 if (SWIG_arg_fail(2)) SWIG_fail;
15491 }
15492 {
15493 PyThreadState* __tstate = wxPyBeginAllowThreads();
15494 result = (int)((wxDC const *)arg1)->DeviceToLogicalYRel(arg2);
15495
15496 wxPyEndAllowThreads(__tstate);
15497 if (PyErr_Occurred()) SWIG_fail;
15498 }
15499 {
15500 resultobj = SWIG_From_int((int)(result));
15501 }
15502 return resultobj;
15503 fail:
15504 return NULL;
15505 }
15506
15507
15508 static PyObject *_wrap_DC_LogicalToDeviceX(PyObject *, PyObject *args, PyObject *kwargs) {
15509 PyObject *resultobj;
15510 wxDC *arg1 = (wxDC *) 0 ;
15511 int arg2 ;
15512 int result;
15513 PyObject * obj0 = 0 ;
15514 PyObject * obj1 = 0 ;
15515 char *kwnames[] = {
15516 (char *) "self",(char *) "x", NULL
15517 };
15518
15519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceX",kwnames,&obj0,&obj1)) goto fail;
15520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15521 if (SWIG_arg_fail(1)) SWIG_fail;
15522 {
15523 arg2 = (int)(SWIG_As_int(obj1));
15524 if (SWIG_arg_fail(2)) SWIG_fail;
15525 }
15526 {
15527 PyThreadState* __tstate = wxPyBeginAllowThreads();
15528 result = (int)((wxDC const *)arg1)->LogicalToDeviceX(arg2);
15529
15530 wxPyEndAllowThreads(__tstate);
15531 if (PyErr_Occurred()) SWIG_fail;
15532 }
15533 {
15534 resultobj = SWIG_From_int((int)(result));
15535 }
15536 return resultobj;
15537 fail:
15538 return NULL;
15539 }
15540
15541
15542 static PyObject *_wrap_DC_LogicalToDeviceY(PyObject *, PyObject *args, PyObject *kwargs) {
15543 PyObject *resultobj;
15544 wxDC *arg1 = (wxDC *) 0 ;
15545 int arg2 ;
15546 int result;
15547 PyObject * obj0 = 0 ;
15548 PyObject * obj1 = 0 ;
15549 char *kwnames[] = {
15550 (char *) "self",(char *) "y", NULL
15551 };
15552
15553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceY",kwnames,&obj0,&obj1)) goto fail;
15554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15555 if (SWIG_arg_fail(1)) SWIG_fail;
15556 {
15557 arg2 = (int)(SWIG_As_int(obj1));
15558 if (SWIG_arg_fail(2)) SWIG_fail;
15559 }
15560 {
15561 PyThreadState* __tstate = wxPyBeginAllowThreads();
15562 result = (int)((wxDC const *)arg1)->LogicalToDeviceY(arg2);
15563
15564 wxPyEndAllowThreads(__tstate);
15565 if (PyErr_Occurred()) SWIG_fail;
15566 }
15567 {
15568 resultobj = SWIG_From_int((int)(result));
15569 }
15570 return resultobj;
15571 fail:
15572 return NULL;
15573 }
15574
15575
15576 static PyObject *_wrap_DC_LogicalToDeviceXRel(PyObject *, PyObject *args, PyObject *kwargs) {
15577 PyObject *resultobj;
15578 wxDC *arg1 = (wxDC *) 0 ;
15579 int arg2 ;
15580 int result;
15581 PyObject * obj0 = 0 ;
15582 PyObject * obj1 = 0 ;
15583 char *kwnames[] = {
15584 (char *) "self",(char *) "x", NULL
15585 };
15586
15587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceXRel",kwnames,&obj0,&obj1)) goto fail;
15588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15589 if (SWIG_arg_fail(1)) SWIG_fail;
15590 {
15591 arg2 = (int)(SWIG_As_int(obj1));
15592 if (SWIG_arg_fail(2)) SWIG_fail;
15593 }
15594 {
15595 PyThreadState* __tstate = wxPyBeginAllowThreads();
15596 result = (int)((wxDC const *)arg1)->LogicalToDeviceXRel(arg2);
15597
15598 wxPyEndAllowThreads(__tstate);
15599 if (PyErr_Occurred()) SWIG_fail;
15600 }
15601 {
15602 resultobj = SWIG_From_int((int)(result));
15603 }
15604 return resultobj;
15605 fail:
15606 return NULL;
15607 }
15608
15609
15610 static PyObject *_wrap_DC_LogicalToDeviceYRel(PyObject *, PyObject *args, PyObject *kwargs) {
15611 PyObject *resultobj;
15612 wxDC *arg1 = (wxDC *) 0 ;
15613 int arg2 ;
15614 int result;
15615 PyObject * obj0 = 0 ;
15616 PyObject * obj1 = 0 ;
15617 char *kwnames[] = {
15618 (char *) "self",(char *) "y", NULL
15619 };
15620
15621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceYRel",kwnames,&obj0,&obj1)) goto fail;
15622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15623 if (SWIG_arg_fail(1)) SWIG_fail;
15624 {
15625 arg2 = (int)(SWIG_As_int(obj1));
15626 if (SWIG_arg_fail(2)) SWIG_fail;
15627 }
15628 {
15629 PyThreadState* __tstate = wxPyBeginAllowThreads();
15630 result = (int)((wxDC const *)arg1)->LogicalToDeviceYRel(arg2);
15631
15632 wxPyEndAllowThreads(__tstate);
15633 if (PyErr_Occurred()) SWIG_fail;
15634 }
15635 {
15636 resultobj = SWIG_From_int((int)(result));
15637 }
15638 return resultobj;
15639 fail:
15640 return NULL;
15641 }
15642
15643
15644 static PyObject *_wrap_DC_CanDrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
15645 PyObject *resultobj;
15646 wxDC *arg1 = (wxDC *) 0 ;
15647 bool result;
15648 PyObject * obj0 = 0 ;
15649 char *kwnames[] = {
15650 (char *) "self", NULL
15651 };
15652
15653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanDrawBitmap",kwnames,&obj0)) goto fail;
15654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15655 if (SWIG_arg_fail(1)) SWIG_fail;
15656 {
15657 PyThreadState* __tstate = wxPyBeginAllowThreads();
15658 result = (bool)((wxDC const *)arg1)->CanDrawBitmap();
15659
15660 wxPyEndAllowThreads(__tstate);
15661 if (PyErr_Occurred()) SWIG_fail;
15662 }
15663 {
15664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15665 }
15666 return resultobj;
15667 fail:
15668 return NULL;
15669 }
15670
15671
15672 static PyObject *_wrap_DC_CanGetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15673 PyObject *resultobj;
15674 wxDC *arg1 = (wxDC *) 0 ;
15675 bool result;
15676 PyObject * obj0 = 0 ;
15677 char *kwnames[] = {
15678 (char *) "self", NULL
15679 };
15680
15681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanGetTextExtent",kwnames,&obj0)) goto fail;
15682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15683 if (SWIG_arg_fail(1)) SWIG_fail;
15684 {
15685 PyThreadState* __tstate = wxPyBeginAllowThreads();
15686 result = (bool)((wxDC const *)arg1)->CanGetTextExtent();
15687
15688 wxPyEndAllowThreads(__tstate);
15689 if (PyErr_Occurred()) SWIG_fail;
15690 }
15691 {
15692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15693 }
15694 return resultobj;
15695 fail:
15696 return NULL;
15697 }
15698
15699
15700 static PyObject *_wrap_DC_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
15701 PyObject *resultobj;
15702 wxDC *arg1 = (wxDC *) 0 ;
15703 int result;
15704 PyObject * obj0 = 0 ;
15705 char *kwnames[] = {
15706 (char *) "self", NULL
15707 };
15708
15709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDepth",kwnames,&obj0)) goto fail;
15710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15711 if (SWIG_arg_fail(1)) SWIG_fail;
15712 {
15713 PyThreadState* __tstate = wxPyBeginAllowThreads();
15714 result = (int)((wxDC const *)arg1)->GetDepth();
15715
15716 wxPyEndAllowThreads(__tstate);
15717 if (PyErr_Occurred()) SWIG_fail;
15718 }
15719 {
15720 resultobj = SWIG_From_int((int)(result));
15721 }
15722 return resultobj;
15723 fail:
15724 return NULL;
15725 }
15726
15727
15728 static PyObject *_wrap_DC_GetPPI(PyObject *, PyObject *args, PyObject *kwargs) {
15729 PyObject *resultobj;
15730 wxDC *arg1 = (wxDC *) 0 ;
15731 wxSize result;
15732 PyObject * obj0 = 0 ;
15733 char *kwnames[] = {
15734 (char *) "self", NULL
15735 };
15736
15737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPPI",kwnames,&obj0)) goto fail;
15738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15739 if (SWIG_arg_fail(1)) SWIG_fail;
15740 {
15741 PyThreadState* __tstate = wxPyBeginAllowThreads();
15742 result = ((wxDC const *)arg1)->GetPPI();
15743
15744 wxPyEndAllowThreads(__tstate);
15745 if (PyErr_Occurred()) SWIG_fail;
15746 }
15747 {
15748 wxSize * resultptr;
15749 resultptr = new wxSize((wxSize &)(result));
15750 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15751 }
15752 return resultobj;
15753 fail:
15754 return NULL;
15755 }
15756
15757
15758 static PyObject *_wrap_DC_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
15759 PyObject *resultobj;
15760 wxDC *arg1 = (wxDC *) 0 ;
15761 bool result;
15762 PyObject * obj0 = 0 ;
15763 char *kwnames[] = {
15764 (char *) "self", NULL
15765 };
15766
15767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Ok",kwnames,&obj0)) goto fail;
15768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15769 if (SWIG_arg_fail(1)) SWIG_fail;
15770 {
15771 PyThreadState* __tstate = wxPyBeginAllowThreads();
15772 result = (bool)((wxDC const *)arg1)->Ok();
15773
15774 wxPyEndAllowThreads(__tstate);
15775 if (PyErr_Occurred()) SWIG_fail;
15776 }
15777 {
15778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15779 }
15780 return resultobj;
15781 fail:
15782 return NULL;
15783 }
15784
15785
15786 static PyObject *_wrap_DC_GetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
15787 PyObject *resultobj;
15788 wxDC *arg1 = (wxDC *) 0 ;
15789 int result;
15790 PyObject * obj0 = 0 ;
15791 char *kwnames[] = {
15792 (char *) "self", NULL
15793 };
15794
15795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackgroundMode",kwnames,&obj0)) goto fail;
15796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15797 if (SWIG_arg_fail(1)) SWIG_fail;
15798 {
15799 PyThreadState* __tstate = wxPyBeginAllowThreads();
15800 result = (int)((wxDC const *)arg1)->GetBackgroundMode();
15801
15802 wxPyEndAllowThreads(__tstate);
15803 if (PyErr_Occurred()) SWIG_fail;
15804 }
15805 {
15806 resultobj = SWIG_From_int((int)(result));
15807 }
15808 return resultobj;
15809 fail:
15810 return NULL;
15811 }
15812
15813
15814 static PyObject *_wrap_DC_GetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
15815 PyObject *resultobj;
15816 wxDC *arg1 = (wxDC *) 0 ;
15817 wxBrush *result;
15818 PyObject * obj0 = 0 ;
15819 char *kwnames[] = {
15820 (char *) "self", NULL
15821 };
15822
15823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackground",kwnames,&obj0)) goto fail;
15824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15825 if (SWIG_arg_fail(1)) SWIG_fail;
15826 {
15827 PyThreadState* __tstate = wxPyBeginAllowThreads();
15828 {
15829 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBackground();
15830 result = (wxBrush *) &_result_ref;
15831 }
15832
15833 wxPyEndAllowThreads(__tstate);
15834 if (PyErr_Occurred()) SWIG_fail;
15835 }
15836 {
15837 wxBrush* resultptr = new wxBrush(*result);
15838 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
15839 }
15840 return resultobj;
15841 fail:
15842 return NULL;
15843 }
15844
15845
15846 static PyObject *_wrap_DC_GetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
15847 PyObject *resultobj;
15848 wxDC *arg1 = (wxDC *) 0 ;
15849 wxBrush *result;
15850 PyObject * obj0 = 0 ;
15851 char *kwnames[] = {
15852 (char *) "self", NULL
15853 };
15854
15855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBrush",kwnames,&obj0)) goto fail;
15856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15857 if (SWIG_arg_fail(1)) SWIG_fail;
15858 {
15859 PyThreadState* __tstate = wxPyBeginAllowThreads();
15860 {
15861 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBrush();
15862 result = (wxBrush *) &_result_ref;
15863 }
15864
15865 wxPyEndAllowThreads(__tstate);
15866 if (PyErr_Occurred()) SWIG_fail;
15867 }
15868 {
15869 wxBrush* resultptr = new wxBrush(*result);
15870 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
15871 }
15872 return resultobj;
15873 fail:
15874 return NULL;
15875 }
15876
15877
15878 static PyObject *_wrap_DC_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
15879 PyObject *resultobj;
15880 wxDC *arg1 = (wxDC *) 0 ;
15881 wxFont *result;
15882 PyObject * obj0 = 0 ;
15883 char *kwnames[] = {
15884 (char *) "self", NULL
15885 };
15886
15887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetFont",kwnames,&obj0)) goto fail;
15888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15889 if (SWIG_arg_fail(1)) SWIG_fail;
15890 {
15891 PyThreadState* __tstate = wxPyBeginAllowThreads();
15892 {
15893 wxFont const &_result_ref = ((wxDC const *)arg1)->GetFont();
15894 result = (wxFont *) &_result_ref;
15895 }
15896
15897 wxPyEndAllowThreads(__tstate);
15898 if (PyErr_Occurred()) SWIG_fail;
15899 }
15900 {
15901 wxFont* resultptr = new wxFont(*result);
15902 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxFont, 1);
15903 }
15904 return resultobj;
15905 fail:
15906 return NULL;
15907 }
15908
15909
15910 static PyObject *_wrap_DC_GetPen(PyObject *, PyObject *args, PyObject *kwargs) {
15911 PyObject *resultobj;
15912 wxDC *arg1 = (wxDC *) 0 ;
15913 wxPen *result;
15914 PyObject * obj0 = 0 ;
15915 char *kwnames[] = {
15916 (char *) "self", NULL
15917 };
15918
15919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPen",kwnames,&obj0)) goto fail;
15920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15921 if (SWIG_arg_fail(1)) SWIG_fail;
15922 {
15923 PyThreadState* __tstate = wxPyBeginAllowThreads();
15924 {
15925 wxPen const &_result_ref = ((wxDC const *)arg1)->GetPen();
15926 result = (wxPen *) &_result_ref;
15927 }
15928
15929 wxPyEndAllowThreads(__tstate);
15930 if (PyErr_Occurred()) SWIG_fail;
15931 }
15932 {
15933 wxPen* resultptr = new wxPen(*result);
15934 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxPen, 1);
15935 }
15936 return resultobj;
15937 fail:
15938 return NULL;
15939 }
15940
15941
15942 static PyObject *_wrap_DC_GetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
15943 PyObject *resultobj;
15944 wxDC *arg1 = (wxDC *) 0 ;
15945 wxColour *result;
15946 PyObject * obj0 = 0 ;
15947 char *kwnames[] = {
15948 (char *) "self", NULL
15949 };
15950
15951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextBackground",kwnames,&obj0)) goto fail;
15952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15953 if (SWIG_arg_fail(1)) SWIG_fail;
15954 {
15955 PyThreadState* __tstate = wxPyBeginAllowThreads();
15956 {
15957 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextBackground();
15958 result = (wxColour *) &_result_ref;
15959 }
15960
15961 wxPyEndAllowThreads(__tstate);
15962 if (PyErr_Occurred()) SWIG_fail;
15963 }
15964 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
15965 return resultobj;
15966 fail:
15967 return NULL;
15968 }
15969
15970
15971 static PyObject *_wrap_DC_GetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
15972 PyObject *resultobj;
15973 wxDC *arg1 = (wxDC *) 0 ;
15974 wxColour *result;
15975 PyObject * obj0 = 0 ;
15976 char *kwnames[] = {
15977 (char *) "self", NULL
15978 };
15979
15980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextForeground",kwnames,&obj0)) goto fail;
15981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15982 if (SWIG_arg_fail(1)) SWIG_fail;
15983 {
15984 PyThreadState* __tstate = wxPyBeginAllowThreads();
15985 {
15986 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextForeground();
15987 result = (wxColour *) &_result_ref;
15988 }
15989
15990 wxPyEndAllowThreads(__tstate);
15991 if (PyErr_Occurred()) SWIG_fail;
15992 }
15993 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
15994 return resultobj;
15995 fail:
15996 return NULL;
15997 }
15998
15999
16000 static PyObject *_wrap_DC_SetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
16001 PyObject *resultobj;
16002 wxDC *arg1 = (wxDC *) 0 ;
16003 wxColour *arg2 = 0 ;
16004 wxColour temp2 ;
16005 PyObject * obj0 = 0 ;
16006 PyObject * obj1 = 0 ;
16007 char *kwnames[] = {
16008 (char *) "self",(char *) "colour", NULL
16009 };
16010
16011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextForeground",kwnames,&obj0,&obj1)) goto fail;
16012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16013 if (SWIG_arg_fail(1)) SWIG_fail;
16014 {
16015 arg2 = &temp2;
16016 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16017 }
16018 {
16019 PyThreadState* __tstate = wxPyBeginAllowThreads();
16020 (arg1)->SetTextForeground((wxColour const &)*arg2);
16021
16022 wxPyEndAllowThreads(__tstate);
16023 if (PyErr_Occurred()) SWIG_fail;
16024 }
16025 Py_INCREF(Py_None); resultobj = Py_None;
16026 return resultobj;
16027 fail:
16028 return NULL;
16029 }
16030
16031
16032 static PyObject *_wrap_DC_SetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16033 PyObject *resultobj;
16034 wxDC *arg1 = (wxDC *) 0 ;
16035 wxColour *arg2 = 0 ;
16036 wxColour temp2 ;
16037 PyObject * obj0 = 0 ;
16038 PyObject * obj1 = 0 ;
16039 char *kwnames[] = {
16040 (char *) "self",(char *) "colour", NULL
16041 };
16042
16043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextBackground",kwnames,&obj0,&obj1)) goto fail;
16044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16045 if (SWIG_arg_fail(1)) SWIG_fail;
16046 {
16047 arg2 = &temp2;
16048 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16049 }
16050 {
16051 PyThreadState* __tstate = wxPyBeginAllowThreads();
16052 (arg1)->SetTextBackground((wxColour const &)*arg2);
16053
16054 wxPyEndAllowThreads(__tstate);
16055 if (PyErr_Occurred()) SWIG_fail;
16056 }
16057 Py_INCREF(Py_None); resultobj = Py_None;
16058 return resultobj;
16059 fail:
16060 return NULL;
16061 }
16062
16063
16064 static PyObject *_wrap_DC_GetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16065 PyObject *resultobj;
16066 wxDC *arg1 = (wxDC *) 0 ;
16067 int result;
16068 PyObject * obj0 = 0 ;
16069 char *kwnames[] = {
16070 (char *) "self", NULL
16071 };
16072
16073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetMapMode",kwnames,&obj0)) goto fail;
16074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16075 if (SWIG_arg_fail(1)) SWIG_fail;
16076 {
16077 PyThreadState* __tstate = wxPyBeginAllowThreads();
16078 result = (int)((wxDC const *)arg1)->GetMapMode();
16079
16080 wxPyEndAllowThreads(__tstate);
16081 if (PyErr_Occurred()) SWIG_fail;
16082 }
16083 {
16084 resultobj = SWIG_From_int((int)(result));
16085 }
16086 return resultobj;
16087 fail:
16088 return NULL;
16089 }
16090
16091
16092 static PyObject *_wrap_DC_SetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16093 PyObject *resultobj;
16094 wxDC *arg1 = (wxDC *) 0 ;
16095 int arg2 ;
16096 PyObject * obj0 = 0 ;
16097 PyObject * obj1 = 0 ;
16098 char *kwnames[] = {
16099 (char *) "self",(char *) "mode", NULL
16100 };
16101
16102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetMapMode",kwnames,&obj0,&obj1)) goto fail;
16103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16104 if (SWIG_arg_fail(1)) SWIG_fail;
16105 {
16106 arg2 = (int)(SWIG_As_int(obj1));
16107 if (SWIG_arg_fail(2)) SWIG_fail;
16108 }
16109 {
16110 PyThreadState* __tstate = wxPyBeginAllowThreads();
16111 (arg1)->SetMapMode(arg2);
16112
16113 wxPyEndAllowThreads(__tstate);
16114 if (PyErr_Occurred()) SWIG_fail;
16115 }
16116 Py_INCREF(Py_None); resultobj = Py_None;
16117 return resultobj;
16118 fail:
16119 return NULL;
16120 }
16121
16122
16123 static PyObject *_wrap_DC_GetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16124 PyObject *resultobj;
16125 wxDC *arg1 = (wxDC *) 0 ;
16126 double *arg2 = (double *) 0 ;
16127 double *arg3 = (double *) 0 ;
16128 double temp2 ;
16129 int res2 = 0 ;
16130 double temp3 ;
16131 int res3 = 0 ;
16132 PyObject * obj0 = 0 ;
16133 char *kwnames[] = {
16134 (char *) "self", NULL
16135 };
16136
16137 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16138 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetUserScale",kwnames,&obj0)) goto fail;
16140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16141 if (SWIG_arg_fail(1)) SWIG_fail;
16142 {
16143 PyThreadState* __tstate = wxPyBeginAllowThreads();
16144 ((wxDC const *)arg1)->GetUserScale(arg2,arg3);
16145
16146 wxPyEndAllowThreads(__tstate);
16147 if (PyErr_Occurred()) SWIG_fail;
16148 }
16149 Py_INCREF(Py_None); resultobj = Py_None;
16150 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16151 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16152 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16153 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16154 return resultobj;
16155 fail:
16156 return NULL;
16157 }
16158
16159
16160 static PyObject *_wrap_DC_SetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16161 PyObject *resultobj;
16162 wxDC *arg1 = (wxDC *) 0 ;
16163 double arg2 ;
16164 double arg3 ;
16165 PyObject * obj0 = 0 ;
16166 PyObject * obj1 = 0 ;
16167 PyObject * obj2 = 0 ;
16168 char *kwnames[] = {
16169 (char *) "self",(char *) "x",(char *) "y", NULL
16170 };
16171
16172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetUserScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16174 if (SWIG_arg_fail(1)) SWIG_fail;
16175 {
16176 arg2 = (double)(SWIG_As_double(obj1));
16177 if (SWIG_arg_fail(2)) SWIG_fail;
16178 }
16179 {
16180 arg3 = (double)(SWIG_As_double(obj2));
16181 if (SWIG_arg_fail(3)) SWIG_fail;
16182 }
16183 {
16184 PyThreadState* __tstate = wxPyBeginAllowThreads();
16185 (arg1)->SetUserScale(arg2,arg3);
16186
16187 wxPyEndAllowThreads(__tstate);
16188 if (PyErr_Occurred()) SWIG_fail;
16189 }
16190 Py_INCREF(Py_None); resultobj = Py_None;
16191 return resultobj;
16192 fail:
16193 return NULL;
16194 }
16195
16196
16197 static PyObject *_wrap_DC_GetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16198 PyObject *resultobj;
16199 wxDC *arg1 = (wxDC *) 0 ;
16200 double *arg2 = (double *) 0 ;
16201 double *arg3 = (double *) 0 ;
16202 double temp2 ;
16203 int res2 = 0 ;
16204 double temp3 ;
16205 int res3 = 0 ;
16206 PyObject * obj0 = 0 ;
16207 char *kwnames[] = {
16208 (char *) "self", NULL
16209 };
16210
16211 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16212 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalScale",kwnames,&obj0)) goto fail;
16214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16215 if (SWIG_arg_fail(1)) SWIG_fail;
16216 {
16217 PyThreadState* __tstate = wxPyBeginAllowThreads();
16218 (arg1)->GetLogicalScale(arg2,arg3);
16219
16220 wxPyEndAllowThreads(__tstate);
16221 if (PyErr_Occurred()) SWIG_fail;
16222 }
16223 Py_INCREF(Py_None); resultobj = Py_None;
16224 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16225 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16226 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16227 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16228 return resultobj;
16229 fail:
16230 return NULL;
16231 }
16232
16233
16234 static PyObject *_wrap_DC_SetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16235 PyObject *resultobj;
16236 wxDC *arg1 = (wxDC *) 0 ;
16237 double arg2 ;
16238 double arg3 ;
16239 PyObject * obj0 = 0 ;
16240 PyObject * obj1 = 0 ;
16241 PyObject * obj2 = 0 ;
16242 char *kwnames[] = {
16243 (char *) "self",(char *) "x",(char *) "y", NULL
16244 };
16245
16246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16248 if (SWIG_arg_fail(1)) SWIG_fail;
16249 {
16250 arg2 = (double)(SWIG_As_double(obj1));
16251 if (SWIG_arg_fail(2)) SWIG_fail;
16252 }
16253 {
16254 arg3 = (double)(SWIG_As_double(obj2));
16255 if (SWIG_arg_fail(3)) SWIG_fail;
16256 }
16257 {
16258 PyThreadState* __tstate = wxPyBeginAllowThreads();
16259 (arg1)->SetLogicalScale(arg2,arg3);
16260
16261 wxPyEndAllowThreads(__tstate);
16262 if (PyErr_Occurred()) SWIG_fail;
16263 }
16264 Py_INCREF(Py_None); resultobj = Py_None;
16265 return resultobj;
16266 fail:
16267 return NULL;
16268 }
16269
16270
16271 static PyObject *_wrap_DC_GetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16272 PyObject *resultobj;
16273 wxDC *arg1 = (wxDC *) 0 ;
16274 wxPoint result;
16275 PyObject * obj0 = 0 ;
16276 char *kwnames[] = {
16277 (char *) "self", NULL
16278 };
16279
16280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOrigin",kwnames,&obj0)) goto fail;
16281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16282 if (SWIG_arg_fail(1)) SWIG_fail;
16283 {
16284 PyThreadState* __tstate = wxPyBeginAllowThreads();
16285 result = ((wxDC const *)arg1)->GetLogicalOrigin();
16286
16287 wxPyEndAllowThreads(__tstate);
16288 if (PyErr_Occurred()) SWIG_fail;
16289 }
16290 {
16291 wxPoint * resultptr;
16292 resultptr = new wxPoint((wxPoint &)(result));
16293 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16294 }
16295 return resultobj;
16296 fail:
16297 return NULL;
16298 }
16299
16300
16301 static PyObject *_wrap_DC_GetLogicalOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16302 PyObject *resultobj;
16303 wxDC *arg1 = (wxDC *) 0 ;
16304 int *arg2 = (int *) 0 ;
16305 int *arg3 = (int *) 0 ;
16306 int temp2 ;
16307 int res2 = 0 ;
16308 int temp3 ;
16309 int res3 = 0 ;
16310 PyObject * obj0 = 0 ;
16311 char *kwnames[] = {
16312 (char *) "self", NULL
16313 };
16314
16315 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16316 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOriginTuple",kwnames,&obj0)) goto fail;
16318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16319 if (SWIG_arg_fail(1)) SWIG_fail;
16320 {
16321 PyThreadState* __tstate = wxPyBeginAllowThreads();
16322 ((wxDC const *)arg1)->GetLogicalOrigin(arg2,arg3);
16323
16324 wxPyEndAllowThreads(__tstate);
16325 if (PyErr_Occurred()) SWIG_fail;
16326 }
16327 Py_INCREF(Py_None); resultobj = Py_None;
16328 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16329 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16330 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16331 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16332 return resultobj;
16333 fail:
16334 return NULL;
16335 }
16336
16337
16338 static PyObject *_wrap_DC_SetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16339 PyObject *resultobj;
16340 wxDC *arg1 = (wxDC *) 0 ;
16341 int arg2 ;
16342 int arg3 ;
16343 PyObject * obj0 = 0 ;
16344 PyObject * obj1 = 0 ;
16345 PyObject * obj2 = 0 ;
16346 char *kwnames[] = {
16347 (char *) "self",(char *) "x",(char *) "y", NULL
16348 };
16349
16350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
16351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16352 if (SWIG_arg_fail(1)) SWIG_fail;
16353 {
16354 arg2 = (int)(SWIG_As_int(obj1));
16355 if (SWIG_arg_fail(2)) SWIG_fail;
16356 }
16357 {
16358 arg3 = (int)(SWIG_As_int(obj2));
16359 if (SWIG_arg_fail(3)) SWIG_fail;
16360 }
16361 {
16362 PyThreadState* __tstate = wxPyBeginAllowThreads();
16363 (arg1)->SetLogicalOrigin(arg2,arg3);
16364
16365 wxPyEndAllowThreads(__tstate);
16366 if (PyErr_Occurred()) SWIG_fail;
16367 }
16368 Py_INCREF(Py_None); resultobj = Py_None;
16369 return resultobj;
16370 fail:
16371 return NULL;
16372 }
16373
16374
16375 static PyObject *_wrap_DC_SetLogicalOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16376 PyObject *resultobj;
16377 wxDC *arg1 = (wxDC *) 0 ;
16378 wxPoint *arg2 = 0 ;
16379 wxPoint temp2 ;
16380 PyObject * obj0 = 0 ;
16381 PyObject * obj1 = 0 ;
16382 char *kwnames[] = {
16383 (char *) "self",(char *) "point", NULL
16384 };
16385
16386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalOriginPoint",kwnames,&obj0,&obj1)) goto fail;
16387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16388 if (SWIG_arg_fail(1)) SWIG_fail;
16389 {
16390 arg2 = &temp2;
16391 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16392 }
16393 {
16394 PyThreadState* __tstate = wxPyBeginAllowThreads();
16395 wxDC_SetLogicalOriginPoint(arg1,(wxPoint const &)*arg2);
16396
16397 wxPyEndAllowThreads(__tstate);
16398 if (PyErr_Occurred()) SWIG_fail;
16399 }
16400 Py_INCREF(Py_None); resultobj = Py_None;
16401 return resultobj;
16402 fail:
16403 return NULL;
16404 }
16405
16406
16407 static PyObject *_wrap_DC_GetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16408 PyObject *resultobj;
16409 wxDC *arg1 = (wxDC *) 0 ;
16410 wxPoint result;
16411 PyObject * obj0 = 0 ;
16412 char *kwnames[] = {
16413 (char *) "self", NULL
16414 };
16415
16416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOrigin",kwnames,&obj0)) goto fail;
16417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16418 if (SWIG_arg_fail(1)) SWIG_fail;
16419 {
16420 PyThreadState* __tstate = wxPyBeginAllowThreads();
16421 result = ((wxDC const *)arg1)->GetDeviceOrigin();
16422
16423 wxPyEndAllowThreads(__tstate);
16424 if (PyErr_Occurred()) SWIG_fail;
16425 }
16426 {
16427 wxPoint * resultptr;
16428 resultptr = new wxPoint((wxPoint &)(result));
16429 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16430 }
16431 return resultobj;
16432 fail:
16433 return NULL;
16434 }
16435
16436
16437 static PyObject *_wrap_DC_GetDeviceOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16438 PyObject *resultobj;
16439 wxDC *arg1 = (wxDC *) 0 ;
16440 int *arg2 = (int *) 0 ;
16441 int *arg3 = (int *) 0 ;
16442 int temp2 ;
16443 int res2 = 0 ;
16444 int temp3 ;
16445 int res3 = 0 ;
16446 PyObject * obj0 = 0 ;
16447 char *kwnames[] = {
16448 (char *) "self", NULL
16449 };
16450
16451 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16452 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOriginTuple",kwnames,&obj0)) goto fail;
16454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16455 if (SWIG_arg_fail(1)) SWIG_fail;
16456 {
16457 PyThreadState* __tstate = wxPyBeginAllowThreads();
16458 ((wxDC const *)arg1)->GetDeviceOrigin(arg2,arg3);
16459
16460 wxPyEndAllowThreads(__tstate);
16461 if (PyErr_Occurred()) SWIG_fail;
16462 }
16463 Py_INCREF(Py_None); resultobj = Py_None;
16464 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16465 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16466 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16467 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16468 return resultobj;
16469 fail:
16470 return NULL;
16471 }
16472
16473
16474 static PyObject *_wrap_DC_SetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16475 PyObject *resultobj;
16476 wxDC *arg1 = (wxDC *) 0 ;
16477 int arg2 ;
16478 int arg3 ;
16479 PyObject * obj0 = 0 ;
16480 PyObject * obj1 = 0 ;
16481 PyObject * obj2 = 0 ;
16482 char *kwnames[] = {
16483 (char *) "self",(char *) "x",(char *) "y", NULL
16484 };
16485
16486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetDeviceOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
16487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16488 if (SWIG_arg_fail(1)) SWIG_fail;
16489 {
16490 arg2 = (int)(SWIG_As_int(obj1));
16491 if (SWIG_arg_fail(2)) SWIG_fail;
16492 }
16493 {
16494 arg3 = (int)(SWIG_As_int(obj2));
16495 if (SWIG_arg_fail(3)) SWIG_fail;
16496 }
16497 {
16498 PyThreadState* __tstate = wxPyBeginAllowThreads();
16499 (arg1)->SetDeviceOrigin(arg2,arg3);
16500
16501 wxPyEndAllowThreads(__tstate);
16502 if (PyErr_Occurred()) SWIG_fail;
16503 }
16504 Py_INCREF(Py_None); resultobj = Py_None;
16505 return resultobj;
16506 fail:
16507 return NULL;
16508 }
16509
16510
16511 static PyObject *_wrap_DC_SetDeviceOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16512 PyObject *resultobj;
16513 wxDC *arg1 = (wxDC *) 0 ;
16514 wxPoint *arg2 = 0 ;
16515 wxPoint temp2 ;
16516 PyObject * obj0 = 0 ;
16517 PyObject * obj1 = 0 ;
16518 char *kwnames[] = {
16519 (char *) "self",(char *) "point", NULL
16520 };
16521
16522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetDeviceOriginPoint",kwnames,&obj0,&obj1)) goto fail;
16523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16524 if (SWIG_arg_fail(1)) SWIG_fail;
16525 {
16526 arg2 = &temp2;
16527 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16528 }
16529 {
16530 PyThreadState* __tstate = wxPyBeginAllowThreads();
16531 wxDC_SetDeviceOriginPoint(arg1,(wxPoint const &)*arg2);
16532
16533 wxPyEndAllowThreads(__tstate);
16534 if (PyErr_Occurred()) SWIG_fail;
16535 }
16536 Py_INCREF(Py_None); resultobj = Py_None;
16537 return resultobj;
16538 fail:
16539 return NULL;
16540 }
16541
16542
16543 static PyObject *_wrap_DC_SetAxisOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16544 PyObject *resultobj;
16545 wxDC *arg1 = (wxDC *) 0 ;
16546 bool arg2 ;
16547 bool arg3 ;
16548 PyObject * obj0 = 0 ;
16549 PyObject * obj1 = 0 ;
16550 PyObject * obj2 = 0 ;
16551 char *kwnames[] = {
16552 (char *) "self",(char *) "xLeftRight",(char *) "yBottomUp", NULL
16553 };
16554
16555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetAxisOrientation",kwnames,&obj0,&obj1,&obj2)) goto fail;
16556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16557 if (SWIG_arg_fail(1)) SWIG_fail;
16558 {
16559 arg2 = (bool)(SWIG_As_bool(obj1));
16560 if (SWIG_arg_fail(2)) SWIG_fail;
16561 }
16562 {
16563 arg3 = (bool)(SWIG_As_bool(obj2));
16564 if (SWIG_arg_fail(3)) SWIG_fail;
16565 }
16566 {
16567 PyThreadState* __tstate = wxPyBeginAllowThreads();
16568 (arg1)->SetAxisOrientation(arg2,arg3);
16569
16570 wxPyEndAllowThreads(__tstate);
16571 if (PyErr_Occurred()) SWIG_fail;
16572 }
16573 Py_INCREF(Py_None); resultobj = Py_None;
16574 return resultobj;
16575 fail:
16576 return NULL;
16577 }
16578
16579
16580 static PyObject *_wrap_DC_GetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
16581 PyObject *resultobj;
16582 wxDC *arg1 = (wxDC *) 0 ;
16583 int result;
16584 PyObject * obj0 = 0 ;
16585 char *kwnames[] = {
16586 (char *) "self", NULL
16587 };
16588
16589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalFunction",kwnames,&obj0)) goto fail;
16590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16591 if (SWIG_arg_fail(1)) SWIG_fail;
16592 {
16593 PyThreadState* __tstate = wxPyBeginAllowThreads();
16594 result = (int)((wxDC const *)arg1)->GetLogicalFunction();
16595
16596 wxPyEndAllowThreads(__tstate);
16597 if (PyErr_Occurred()) SWIG_fail;
16598 }
16599 {
16600 resultobj = SWIG_From_int((int)(result));
16601 }
16602 return resultobj;
16603 fail:
16604 return NULL;
16605 }
16606
16607
16608 static PyObject *_wrap_DC_SetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
16609 PyObject *resultobj;
16610 wxDC *arg1 = (wxDC *) 0 ;
16611 int arg2 ;
16612 PyObject * obj0 = 0 ;
16613 PyObject * obj1 = 0 ;
16614 char *kwnames[] = {
16615 (char *) "self",(char *) "function", NULL
16616 };
16617
16618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalFunction",kwnames,&obj0,&obj1)) goto fail;
16619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16620 if (SWIG_arg_fail(1)) SWIG_fail;
16621 {
16622 arg2 = (int)(SWIG_As_int(obj1));
16623 if (SWIG_arg_fail(2)) SWIG_fail;
16624 }
16625 {
16626 PyThreadState* __tstate = wxPyBeginAllowThreads();
16627 (arg1)->SetLogicalFunction(arg2);
16628
16629 wxPyEndAllowThreads(__tstate);
16630 if (PyErr_Occurred()) SWIG_fail;
16631 }
16632 Py_INCREF(Py_None); resultobj = Py_None;
16633 return resultobj;
16634 fail:
16635 return NULL;
16636 }
16637
16638
16639 static PyObject *_wrap_DC_ComputeScaleAndOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16640 PyObject *resultobj;
16641 wxDC *arg1 = (wxDC *) 0 ;
16642 PyObject * obj0 = 0 ;
16643 char *kwnames[] = {
16644 (char *) "self", NULL
16645 };
16646
16647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ComputeScaleAndOrigin",kwnames,&obj0)) goto fail;
16648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16649 if (SWIG_arg_fail(1)) SWIG_fail;
16650 {
16651 PyThreadState* __tstate = wxPyBeginAllowThreads();
16652 (arg1)->ComputeScaleAndOrigin();
16653
16654 wxPyEndAllowThreads(__tstate);
16655 if (PyErr_Occurred()) SWIG_fail;
16656 }
16657 Py_INCREF(Py_None); resultobj = Py_None;
16658 return resultobj;
16659 fail:
16660 return NULL;
16661 }
16662
16663
16664 static PyObject *_wrap_DC_CalcBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16665 PyObject *resultobj;
16666 wxDC *arg1 = (wxDC *) 0 ;
16667 int arg2 ;
16668 int arg3 ;
16669 PyObject * obj0 = 0 ;
16670 PyObject * obj1 = 0 ;
16671 PyObject * obj2 = 0 ;
16672 char *kwnames[] = {
16673 (char *) "self",(char *) "x",(char *) "y", NULL
16674 };
16675
16676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CalcBoundingBox",kwnames,&obj0,&obj1,&obj2)) goto fail;
16677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16678 if (SWIG_arg_fail(1)) SWIG_fail;
16679 {
16680 arg2 = (int)(SWIG_As_int(obj1));
16681 if (SWIG_arg_fail(2)) SWIG_fail;
16682 }
16683 {
16684 arg3 = (int)(SWIG_As_int(obj2));
16685 if (SWIG_arg_fail(3)) SWIG_fail;
16686 }
16687 {
16688 PyThreadState* __tstate = wxPyBeginAllowThreads();
16689 (arg1)->CalcBoundingBox(arg2,arg3);
16690
16691 wxPyEndAllowThreads(__tstate);
16692 if (PyErr_Occurred()) SWIG_fail;
16693 }
16694 Py_INCREF(Py_None); resultobj = Py_None;
16695 return resultobj;
16696 fail:
16697 return NULL;
16698 }
16699
16700
16701 static PyObject *_wrap_DC_CalcBoundingBoxPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16702 PyObject *resultobj;
16703 wxDC *arg1 = (wxDC *) 0 ;
16704 wxPoint *arg2 = 0 ;
16705 wxPoint temp2 ;
16706 PyObject * obj0 = 0 ;
16707 PyObject * obj1 = 0 ;
16708 char *kwnames[] = {
16709 (char *) "self",(char *) "point", NULL
16710 };
16711
16712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CalcBoundingBoxPoint",kwnames,&obj0,&obj1)) goto fail;
16713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16714 if (SWIG_arg_fail(1)) SWIG_fail;
16715 {
16716 arg2 = &temp2;
16717 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16718 }
16719 {
16720 PyThreadState* __tstate = wxPyBeginAllowThreads();
16721 wxDC_CalcBoundingBoxPoint(arg1,(wxPoint const &)*arg2);
16722
16723 wxPyEndAllowThreads(__tstate);
16724 if (PyErr_Occurred()) SWIG_fail;
16725 }
16726 Py_INCREF(Py_None); resultobj = Py_None;
16727 return resultobj;
16728 fail:
16729 return NULL;
16730 }
16731
16732
16733 static PyObject *_wrap_DC_ResetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16734 PyObject *resultobj;
16735 wxDC *arg1 = (wxDC *) 0 ;
16736 PyObject * obj0 = 0 ;
16737 char *kwnames[] = {
16738 (char *) "self", NULL
16739 };
16740
16741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ResetBoundingBox",kwnames,&obj0)) goto fail;
16742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16743 if (SWIG_arg_fail(1)) SWIG_fail;
16744 {
16745 PyThreadState* __tstate = wxPyBeginAllowThreads();
16746 (arg1)->ResetBoundingBox();
16747
16748 wxPyEndAllowThreads(__tstate);
16749 if (PyErr_Occurred()) SWIG_fail;
16750 }
16751 Py_INCREF(Py_None); resultobj = Py_None;
16752 return resultobj;
16753 fail:
16754 return NULL;
16755 }
16756
16757
16758 static PyObject *_wrap_DC_MinX(PyObject *, PyObject *args, PyObject *kwargs) {
16759 PyObject *resultobj;
16760 wxDC *arg1 = (wxDC *) 0 ;
16761 int result;
16762 PyObject * obj0 = 0 ;
16763 char *kwnames[] = {
16764 (char *) "self", NULL
16765 };
16766
16767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinX",kwnames,&obj0)) goto fail;
16768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16769 if (SWIG_arg_fail(1)) SWIG_fail;
16770 {
16771 PyThreadState* __tstate = wxPyBeginAllowThreads();
16772 result = (int)((wxDC const *)arg1)->MinX();
16773
16774 wxPyEndAllowThreads(__tstate);
16775 if (PyErr_Occurred()) SWIG_fail;
16776 }
16777 {
16778 resultobj = SWIG_From_int((int)(result));
16779 }
16780 return resultobj;
16781 fail:
16782 return NULL;
16783 }
16784
16785
16786 static PyObject *_wrap_DC_MaxX(PyObject *, PyObject *args, PyObject *kwargs) {
16787 PyObject *resultobj;
16788 wxDC *arg1 = (wxDC *) 0 ;
16789 int result;
16790 PyObject * obj0 = 0 ;
16791 char *kwnames[] = {
16792 (char *) "self", NULL
16793 };
16794
16795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxX",kwnames,&obj0)) goto fail;
16796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16797 if (SWIG_arg_fail(1)) SWIG_fail;
16798 {
16799 PyThreadState* __tstate = wxPyBeginAllowThreads();
16800 result = (int)((wxDC const *)arg1)->MaxX();
16801
16802 wxPyEndAllowThreads(__tstate);
16803 if (PyErr_Occurred()) SWIG_fail;
16804 }
16805 {
16806 resultobj = SWIG_From_int((int)(result));
16807 }
16808 return resultobj;
16809 fail:
16810 return NULL;
16811 }
16812
16813
16814 static PyObject *_wrap_DC_MinY(PyObject *, PyObject *args, PyObject *kwargs) {
16815 PyObject *resultobj;
16816 wxDC *arg1 = (wxDC *) 0 ;
16817 int result;
16818 PyObject * obj0 = 0 ;
16819 char *kwnames[] = {
16820 (char *) "self", NULL
16821 };
16822
16823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinY",kwnames,&obj0)) goto fail;
16824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16825 if (SWIG_arg_fail(1)) SWIG_fail;
16826 {
16827 PyThreadState* __tstate = wxPyBeginAllowThreads();
16828 result = (int)((wxDC const *)arg1)->MinY();
16829
16830 wxPyEndAllowThreads(__tstate);
16831 if (PyErr_Occurred()) SWIG_fail;
16832 }
16833 {
16834 resultobj = SWIG_From_int((int)(result));
16835 }
16836 return resultobj;
16837 fail:
16838 return NULL;
16839 }
16840
16841
16842 static PyObject *_wrap_DC_MaxY(PyObject *, PyObject *args, PyObject *kwargs) {
16843 PyObject *resultobj;
16844 wxDC *arg1 = (wxDC *) 0 ;
16845 int result;
16846 PyObject * obj0 = 0 ;
16847 char *kwnames[] = {
16848 (char *) "self", NULL
16849 };
16850
16851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxY",kwnames,&obj0)) goto fail;
16852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16853 if (SWIG_arg_fail(1)) SWIG_fail;
16854 {
16855 PyThreadState* __tstate = wxPyBeginAllowThreads();
16856 result = (int)((wxDC const *)arg1)->MaxY();
16857
16858 wxPyEndAllowThreads(__tstate);
16859 if (PyErr_Occurred()) SWIG_fail;
16860 }
16861 {
16862 resultobj = SWIG_From_int((int)(result));
16863 }
16864 return resultobj;
16865 fail:
16866 return NULL;
16867 }
16868
16869
16870 static PyObject *_wrap_DC_GetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16871 PyObject *resultobj;
16872 wxDC *arg1 = (wxDC *) 0 ;
16873 int *arg2 = (int *) 0 ;
16874 int *arg3 = (int *) 0 ;
16875 int *arg4 = (int *) 0 ;
16876 int *arg5 = (int *) 0 ;
16877 int temp2 ;
16878 int res2 = 0 ;
16879 int temp3 ;
16880 int res3 = 0 ;
16881 int temp4 ;
16882 int res4 = 0 ;
16883 int temp5 ;
16884 int res5 = 0 ;
16885 PyObject * obj0 = 0 ;
16886 char *kwnames[] = {
16887 (char *) "self", NULL
16888 };
16889
16890 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16891 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16892 arg4 = &temp4; res4 = SWIG_NEWOBJ;
16893 arg5 = &temp5; res5 = SWIG_NEWOBJ;
16894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBoundingBox",kwnames,&obj0)) goto fail;
16895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16896 if (SWIG_arg_fail(1)) SWIG_fail;
16897 {
16898 PyThreadState* __tstate = wxPyBeginAllowThreads();
16899 wxDC_GetBoundingBox(arg1,arg2,arg3,arg4,arg5);
16900
16901 wxPyEndAllowThreads(__tstate);
16902 if (PyErr_Occurred()) SWIG_fail;
16903 }
16904 Py_INCREF(Py_None); resultobj = Py_None;
16905 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16906 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16907 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16908 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16909 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
16910 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
16911 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
16912 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
16913 return resultobj;
16914 fail:
16915 return NULL;
16916 }
16917
16918
16919 static PyObject *_wrap_DC__DrawPointList(PyObject *, PyObject *args, PyObject *kwargs) {
16920 PyObject *resultobj;
16921 wxDC *arg1 = (wxDC *) 0 ;
16922 PyObject *arg2 = (PyObject *) 0 ;
16923 PyObject *arg3 = (PyObject *) 0 ;
16924 PyObject *arg4 = (PyObject *) 0 ;
16925 PyObject *result;
16926 PyObject * obj0 = 0 ;
16927 PyObject * obj1 = 0 ;
16928 PyObject * obj2 = 0 ;
16929 PyObject * obj3 = 0 ;
16930 char *kwnames[] = {
16931 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
16932 };
16933
16934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPointList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16936 if (SWIG_arg_fail(1)) SWIG_fail;
16937 arg2 = obj1;
16938 arg3 = obj2;
16939 arg4 = obj3;
16940 {
16941 PyThreadState* __tstate = wxPyBeginAllowThreads();
16942 result = (PyObject *)wxDC__DrawPointList(arg1,arg2,arg3,arg4);
16943
16944 wxPyEndAllowThreads(__tstate);
16945 if (PyErr_Occurred()) SWIG_fail;
16946 }
16947 resultobj = result;
16948 return resultobj;
16949 fail:
16950 return NULL;
16951 }
16952
16953
16954 static PyObject *_wrap_DC__DrawLineList(PyObject *, PyObject *args, PyObject *kwargs) {
16955 PyObject *resultobj;
16956 wxDC *arg1 = (wxDC *) 0 ;
16957 PyObject *arg2 = (PyObject *) 0 ;
16958 PyObject *arg3 = (PyObject *) 0 ;
16959 PyObject *arg4 = (PyObject *) 0 ;
16960 PyObject *result;
16961 PyObject * obj0 = 0 ;
16962 PyObject * obj1 = 0 ;
16963 PyObject * obj2 = 0 ;
16964 PyObject * obj3 = 0 ;
16965 char *kwnames[] = {
16966 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
16967 };
16968
16969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawLineList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16971 if (SWIG_arg_fail(1)) SWIG_fail;
16972 arg2 = obj1;
16973 arg3 = obj2;
16974 arg4 = obj3;
16975 {
16976 PyThreadState* __tstate = wxPyBeginAllowThreads();
16977 result = (PyObject *)wxDC__DrawLineList(arg1,arg2,arg3,arg4);
16978
16979 wxPyEndAllowThreads(__tstate);
16980 if (PyErr_Occurred()) SWIG_fail;
16981 }
16982 resultobj = result;
16983 return resultobj;
16984 fail:
16985 return NULL;
16986 }
16987
16988
16989 static PyObject *_wrap_DC__DrawRectangleList(PyObject *, PyObject *args, PyObject *kwargs) {
16990 PyObject *resultobj;
16991 wxDC *arg1 = (wxDC *) 0 ;
16992 PyObject *arg2 = (PyObject *) 0 ;
16993 PyObject *arg3 = (PyObject *) 0 ;
16994 PyObject *arg4 = (PyObject *) 0 ;
16995 PyObject *result;
16996 PyObject * obj0 = 0 ;
16997 PyObject * obj1 = 0 ;
16998 PyObject * obj2 = 0 ;
16999 PyObject * obj3 = 0 ;
17000 char *kwnames[] = {
17001 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17002 };
17003
17004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawRectangleList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17006 if (SWIG_arg_fail(1)) SWIG_fail;
17007 arg2 = obj1;
17008 arg3 = obj2;
17009 arg4 = obj3;
17010 {
17011 PyThreadState* __tstate = wxPyBeginAllowThreads();
17012 result = (PyObject *)wxDC__DrawRectangleList(arg1,arg2,arg3,arg4);
17013
17014 wxPyEndAllowThreads(__tstate);
17015 if (PyErr_Occurred()) SWIG_fail;
17016 }
17017 resultobj = result;
17018 return resultobj;
17019 fail:
17020 return NULL;
17021 }
17022
17023
17024 static PyObject *_wrap_DC__DrawEllipseList(PyObject *, PyObject *args, PyObject *kwargs) {
17025 PyObject *resultobj;
17026 wxDC *arg1 = (wxDC *) 0 ;
17027 PyObject *arg2 = (PyObject *) 0 ;
17028 PyObject *arg3 = (PyObject *) 0 ;
17029 PyObject *arg4 = (PyObject *) 0 ;
17030 PyObject *result;
17031 PyObject * obj0 = 0 ;
17032 PyObject * obj1 = 0 ;
17033 PyObject * obj2 = 0 ;
17034 PyObject * obj3 = 0 ;
17035 char *kwnames[] = {
17036 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17037 };
17038
17039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawEllipseList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17041 if (SWIG_arg_fail(1)) SWIG_fail;
17042 arg2 = obj1;
17043 arg3 = obj2;
17044 arg4 = obj3;
17045 {
17046 PyThreadState* __tstate = wxPyBeginAllowThreads();
17047 result = (PyObject *)wxDC__DrawEllipseList(arg1,arg2,arg3,arg4);
17048
17049 wxPyEndAllowThreads(__tstate);
17050 if (PyErr_Occurred()) SWIG_fail;
17051 }
17052 resultobj = result;
17053 return resultobj;
17054 fail:
17055 return NULL;
17056 }
17057
17058
17059 static PyObject *_wrap_DC__DrawPolygonList(PyObject *, PyObject *args, PyObject *kwargs) {
17060 PyObject *resultobj;
17061 wxDC *arg1 = (wxDC *) 0 ;
17062 PyObject *arg2 = (PyObject *) 0 ;
17063 PyObject *arg3 = (PyObject *) 0 ;
17064 PyObject *arg4 = (PyObject *) 0 ;
17065 PyObject *result;
17066 PyObject * obj0 = 0 ;
17067 PyObject * obj1 = 0 ;
17068 PyObject * obj2 = 0 ;
17069 PyObject * obj3 = 0 ;
17070 char *kwnames[] = {
17071 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17072 };
17073
17074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPolygonList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17076 if (SWIG_arg_fail(1)) SWIG_fail;
17077 arg2 = obj1;
17078 arg3 = obj2;
17079 arg4 = obj3;
17080 {
17081 PyThreadState* __tstate = wxPyBeginAllowThreads();
17082 result = (PyObject *)wxDC__DrawPolygonList(arg1,arg2,arg3,arg4);
17083
17084 wxPyEndAllowThreads(__tstate);
17085 if (PyErr_Occurred()) SWIG_fail;
17086 }
17087 resultobj = result;
17088 return resultobj;
17089 fail:
17090 return NULL;
17091 }
17092
17093
17094 static PyObject *_wrap_DC__DrawTextList(PyObject *, PyObject *args, PyObject *kwargs) {
17095 PyObject *resultobj;
17096 wxDC *arg1 = (wxDC *) 0 ;
17097 PyObject *arg2 = (PyObject *) 0 ;
17098 PyObject *arg3 = (PyObject *) 0 ;
17099 PyObject *arg4 = (PyObject *) 0 ;
17100 PyObject *arg5 = (PyObject *) 0 ;
17101 PyObject *result;
17102 PyObject * obj0 = 0 ;
17103 PyObject * obj1 = 0 ;
17104 PyObject * obj2 = 0 ;
17105 PyObject * obj3 = 0 ;
17106 PyObject * obj4 = 0 ;
17107 char *kwnames[] = {
17108 (char *) "self",(char *) "textList",(char *) "pyPoints",(char *) "foregroundList",(char *) "backgroundList", NULL
17109 };
17110
17111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC__DrawTextList",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
17112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17113 if (SWIG_arg_fail(1)) SWIG_fail;
17114 arg2 = obj1;
17115 arg3 = obj2;
17116 arg4 = obj3;
17117 arg5 = obj4;
17118 {
17119 PyThreadState* __tstate = wxPyBeginAllowThreads();
17120 result = (PyObject *)wxDC__DrawTextList(arg1,arg2,arg3,arg4,arg5);
17121
17122 wxPyEndAllowThreads(__tstate);
17123 if (PyErr_Occurred()) SWIG_fail;
17124 }
17125 resultobj = result;
17126 return resultobj;
17127 fail:
17128 return NULL;
17129 }
17130
17131
17132 static PyObject * DC_swigregister(PyObject *, PyObject *args) {
17133 PyObject *obj;
17134 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17135 SWIG_TypeClientData(SWIGTYPE_p_wxDC, obj);
17136 Py_INCREF(obj);
17137 return Py_BuildValue((char *)"");
17138 }
17139 static PyObject *_wrap_new_MemoryDC(PyObject *, PyObject *args, PyObject *kwargs) {
17140 PyObject *resultobj;
17141 wxMemoryDC *result;
17142 char *kwnames[] = {
17143 NULL
17144 };
17145
17146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryDC",kwnames)) goto fail;
17147 {
17148 if (!wxPyCheckForApp()) SWIG_fail;
17149 PyThreadState* __tstate = wxPyBeginAllowThreads();
17150 result = (wxMemoryDC *)new wxMemoryDC();
17151
17152 wxPyEndAllowThreads(__tstate);
17153 if (PyErr_Occurred()) SWIG_fail;
17154 }
17155 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17156 return resultobj;
17157 fail:
17158 return NULL;
17159 }
17160
17161
17162 static PyObject *_wrap_new_MemoryDCFromDC(PyObject *, PyObject *args, PyObject *kwargs) {
17163 PyObject *resultobj;
17164 wxDC *arg1 = (wxDC *) 0 ;
17165 wxMemoryDC *result;
17166 PyObject * obj0 = 0 ;
17167 char *kwnames[] = {
17168 (char *) "oldDC", NULL
17169 };
17170
17171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_MemoryDCFromDC",kwnames,&obj0)) goto fail;
17172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17173 if (SWIG_arg_fail(1)) SWIG_fail;
17174 {
17175 if (!wxPyCheckForApp()) SWIG_fail;
17176 PyThreadState* __tstate = wxPyBeginAllowThreads();
17177 result = (wxMemoryDC *)new wxMemoryDC(arg1);
17178
17179 wxPyEndAllowThreads(__tstate);
17180 if (PyErr_Occurred()) SWIG_fail;
17181 }
17182 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17183 return resultobj;
17184 fail:
17185 return NULL;
17186 }
17187
17188
17189 static PyObject *_wrap_MemoryDC_SelectObject(PyObject *, PyObject *args, PyObject *kwargs) {
17190 PyObject *resultobj;
17191 wxMemoryDC *arg1 = (wxMemoryDC *) 0 ;
17192 wxBitmap *arg2 = 0 ;
17193 PyObject * obj0 = 0 ;
17194 PyObject * obj1 = 0 ;
17195 char *kwnames[] = {
17196 (char *) "self",(char *) "bitmap", NULL
17197 };
17198
17199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryDC_SelectObject",kwnames,&obj0,&obj1)) goto fail;
17200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryDC, SWIG_POINTER_EXCEPTION | 0);
17201 if (SWIG_arg_fail(1)) SWIG_fail;
17202 {
17203 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17204 if (SWIG_arg_fail(2)) SWIG_fail;
17205 if (arg2 == NULL) {
17206 SWIG_null_ref("wxBitmap");
17207 }
17208 if (SWIG_arg_fail(2)) SWIG_fail;
17209 }
17210 {
17211 PyThreadState* __tstate = wxPyBeginAllowThreads();
17212 (arg1)->SelectObject((wxBitmap const &)*arg2);
17213
17214 wxPyEndAllowThreads(__tstate);
17215 if (PyErr_Occurred()) SWIG_fail;
17216 }
17217 Py_INCREF(Py_None); resultobj = Py_None;
17218 return resultobj;
17219 fail:
17220 return NULL;
17221 }
17222
17223
17224 static PyObject * MemoryDC_swigregister(PyObject *, PyObject *args) {
17225 PyObject *obj;
17226 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17227 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryDC, obj);
17228 Py_INCREF(obj);
17229 return Py_BuildValue((char *)"");
17230 }
17231 static PyObject *_wrap_new_BufferedDC__SWIG_0(PyObject *, PyObject *args) {
17232 PyObject *resultobj;
17233 wxDC *arg1 = (wxDC *) 0 ;
17234 wxBitmap *arg2 = 0 ;
17235 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
17236 wxBufferedDC *result;
17237 PyObject * obj0 = 0 ;
17238 PyObject * obj1 = 0 ;
17239 PyObject * obj2 = 0 ;
17240
17241 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_BufferedDC",&obj0,&obj1,&obj2)) goto fail;
17242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17243 if (SWIG_arg_fail(1)) SWIG_fail;
17244 {
17245 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17246 if (SWIG_arg_fail(2)) SWIG_fail;
17247 if (arg2 == NULL) {
17248 SWIG_null_ref("wxBitmap");
17249 }
17250 if (SWIG_arg_fail(2)) SWIG_fail;
17251 }
17252 if (obj2) {
17253 {
17254 arg3 = (int)(SWIG_As_int(obj2));
17255 if (SWIG_arg_fail(3)) SWIG_fail;
17256 }
17257 }
17258 {
17259 if (!wxPyCheckForApp()) SWIG_fail;
17260 PyThreadState* __tstate = wxPyBeginAllowThreads();
17261 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxBitmap const &)*arg2,arg3);
17262
17263 wxPyEndAllowThreads(__tstate);
17264 if (PyErr_Occurred()) SWIG_fail;
17265 }
17266 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
17267 return resultobj;
17268 fail:
17269 return NULL;
17270 }
17271
17272
17273 static PyObject *_wrap_new_BufferedDC__SWIG_1(PyObject *, PyObject *args) {
17274 PyObject *resultobj;
17275 wxDC *arg1 = (wxDC *) 0 ;
17276 wxSize *arg2 = 0 ;
17277 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
17278 wxBufferedDC *result;
17279 wxSize temp2 ;
17280 PyObject * obj0 = 0 ;
17281 PyObject * obj1 = 0 ;
17282 PyObject * obj2 = 0 ;
17283
17284 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_BufferedDC",&obj0,&obj1,&obj2)) goto fail;
17285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17286 if (SWIG_arg_fail(1)) SWIG_fail;
17287 {
17288 arg2 = &temp2;
17289 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
17290 }
17291 if (obj2) {
17292 {
17293 arg3 = (int)(SWIG_As_int(obj2));
17294 if (SWIG_arg_fail(3)) SWIG_fail;
17295 }
17296 }
17297 {
17298 if (!wxPyCheckForApp()) SWIG_fail;
17299 PyThreadState* __tstate = wxPyBeginAllowThreads();
17300 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxSize const &)*arg2,arg3);
17301
17302 wxPyEndAllowThreads(__tstate);
17303 if (PyErr_Occurred()) SWIG_fail;
17304 }
17305 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
17306 return resultobj;
17307 fail:
17308 return NULL;
17309 }
17310
17311
17312 static PyObject *_wrap_new_BufferedDC(PyObject *self, PyObject *args) {
17313 int argc;
17314 PyObject *argv[4];
17315 int ii;
17316
17317 argc = PyObject_Length(args);
17318 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
17319 argv[ii] = PyTuple_GetItem(args,ii);
17320 }
17321 if ((argc >= 2) && (argc <= 3)) {
17322 int _v;
17323 {
17324 void *ptr;
17325 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
17326 _v = 0;
17327 PyErr_Clear();
17328 } else {
17329 _v = 1;
17330 }
17331 }
17332 if (_v) {
17333 {
17334 void *ptr = 0;
17335 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxBitmap, 0) == -1) {
17336 _v = 0;
17337 PyErr_Clear();
17338 } else {
17339 _v = (ptr != 0);
17340 }
17341 }
17342 if (_v) {
17343 if (argc <= 2) {
17344 return _wrap_new_BufferedDC__SWIG_0(self,args);
17345 }
17346 _v = SWIG_Check_int(argv[2]);
17347 if (_v) {
17348 return _wrap_new_BufferedDC__SWIG_0(self,args);
17349 }
17350 }
17351 }
17352 }
17353 if ((argc >= 2) && (argc <= 3)) {
17354 int _v;
17355 {
17356 void *ptr;
17357 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
17358 _v = 0;
17359 PyErr_Clear();
17360 } else {
17361 _v = 1;
17362 }
17363 }
17364 if (_v) {
17365 {
17366 _v = wxPySimple_typecheck(argv[1], wxT("wxSize"), 2);
17367 }
17368 if (_v) {
17369 if (argc <= 2) {
17370 return _wrap_new_BufferedDC__SWIG_1(self,args);
17371 }
17372 _v = SWIG_Check_int(argv[2]);
17373 if (_v) {
17374 return _wrap_new_BufferedDC__SWIG_1(self,args);
17375 }
17376 }
17377 }
17378 }
17379
17380 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_BufferedDC'");
17381 return NULL;
17382 }
17383
17384
17385 static PyObject *_wrap_delete_BufferedDC(PyObject *, PyObject *args, PyObject *kwargs) {
17386 PyObject *resultobj;
17387 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
17388 PyObject * obj0 = 0 ;
17389 char *kwnames[] = {
17390 (char *) "self", NULL
17391 };
17392
17393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BufferedDC",kwnames,&obj0)) goto fail;
17394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
17395 if (SWIG_arg_fail(1)) SWIG_fail;
17396 {
17397 PyThreadState* __tstate = wxPyBeginAllowThreads();
17398 delete arg1;
17399
17400 wxPyEndAllowThreads(__tstate);
17401 if (PyErr_Occurred()) SWIG_fail;
17402 }
17403 Py_INCREF(Py_None); resultobj = Py_None;
17404 return resultobj;
17405 fail:
17406 return NULL;
17407 }
17408
17409
17410 static PyObject *_wrap_BufferedDC_UnMask(PyObject *, PyObject *args, PyObject *kwargs) {
17411 PyObject *resultobj;
17412 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
17413 PyObject * obj0 = 0 ;
17414 char *kwnames[] = {
17415 (char *) "self", NULL
17416 };
17417
17418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BufferedDC_UnMask",kwnames,&obj0)) goto fail;
17419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
17420 if (SWIG_arg_fail(1)) SWIG_fail;
17421 {
17422 PyThreadState* __tstate = wxPyBeginAllowThreads();
17423 (arg1)->UnMask();
17424
17425 wxPyEndAllowThreads(__tstate);
17426 if (PyErr_Occurred()) SWIG_fail;
17427 }
17428 Py_INCREF(Py_None); resultobj = Py_None;
17429 return resultobj;
17430 fail:
17431 return NULL;
17432 }
17433
17434
17435 static PyObject * BufferedDC_swigregister(PyObject *, PyObject *args) {
17436 PyObject *obj;
17437 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17438 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedDC, obj);
17439 Py_INCREF(obj);
17440 return Py_BuildValue((char *)"");
17441 }
17442 static PyObject *_wrap_new_BufferedPaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
17443 PyObject *resultobj;
17444 wxWindow *arg1 = (wxWindow *) 0 ;
17445 wxBitmap const &arg2_defvalue = wxNullBitmap ;
17446 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
17447 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
17448 wxBufferedPaintDC *result;
17449 PyObject * obj0 = 0 ;
17450 PyObject * obj1 = 0 ;
17451 PyObject * obj2 = 0 ;
17452 char *kwnames[] = {
17453 (char *) "window",(char *) "buffer",(char *) "style", NULL
17454 };
17455
17456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_BufferedPaintDC",kwnames,&obj0,&obj1,&obj2)) goto fail;
17457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17458 if (SWIG_arg_fail(1)) SWIG_fail;
17459 if (obj1) {
17460 {
17461 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17462 if (SWIG_arg_fail(2)) SWIG_fail;
17463 if (arg2 == NULL) {
17464 SWIG_null_ref("wxBitmap");
17465 }
17466 if (SWIG_arg_fail(2)) SWIG_fail;
17467 }
17468 }
17469 if (obj2) {
17470 {
17471 arg3 = (int)(SWIG_As_int(obj2));
17472 if (SWIG_arg_fail(3)) SWIG_fail;
17473 }
17474 }
17475 {
17476 if (!wxPyCheckForApp()) SWIG_fail;
17477 PyThreadState* __tstate = wxPyBeginAllowThreads();
17478 result = (wxBufferedPaintDC *)new wxBufferedPaintDC(arg1,(wxBitmap const &)*arg2,arg3);
17479
17480 wxPyEndAllowThreads(__tstate);
17481 if (PyErr_Occurred()) SWIG_fail;
17482 }
17483 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedPaintDC, 1);
17484 return resultobj;
17485 fail:
17486 return NULL;
17487 }
17488
17489
17490 static PyObject * BufferedPaintDC_swigregister(PyObject *, PyObject *args) {
17491 PyObject *obj;
17492 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17493 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedPaintDC, obj);
17494 Py_INCREF(obj);
17495 return Py_BuildValue((char *)"");
17496 }
17497 static PyObject *_wrap_new_ScreenDC(PyObject *, PyObject *args, PyObject *kwargs) {
17498 PyObject *resultobj;
17499 wxScreenDC *result;
17500 char *kwnames[] = {
17501 NULL
17502 };
17503
17504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ScreenDC",kwnames)) goto fail;
17505 {
17506 if (!wxPyCheckForApp()) SWIG_fail;
17507 PyThreadState* __tstate = wxPyBeginAllowThreads();
17508 result = (wxScreenDC *)new wxScreenDC();
17509
17510 wxPyEndAllowThreads(__tstate);
17511 if (PyErr_Occurred()) SWIG_fail;
17512 }
17513 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScreenDC, 1);
17514 return resultobj;
17515 fail:
17516 return NULL;
17517 }
17518
17519
17520 static PyObject *_wrap_ScreenDC_StartDrawingOnTopWin(PyObject *, PyObject *args, PyObject *kwargs) {
17521 PyObject *resultobj;
17522 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17523 wxWindow *arg2 = (wxWindow *) 0 ;
17524 bool result;
17525 PyObject * obj0 = 0 ;
17526 PyObject * obj1 = 0 ;
17527 char *kwnames[] = {
17528 (char *) "self",(char *) "window", NULL
17529 };
17530
17531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScreenDC_StartDrawingOnTopWin",kwnames,&obj0,&obj1)) goto fail;
17532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17533 if (SWIG_arg_fail(1)) SWIG_fail;
17534 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17535 if (SWIG_arg_fail(2)) SWIG_fail;
17536 {
17537 PyThreadState* __tstate = wxPyBeginAllowThreads();
17538 result = (bool)(arg1)->StartDrawingOnTop(arg2);
17539
17540 wxPyEndAllowThreads(__tstate);
17541 if (PyErr_Occurred()) SWIG_fail;
17542 }
17543 {
17544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17545 }
17546 return resultobj;
17547 fail:
17548 return NULL;
17549 }
17550
17551
17552 static PyObject *_wrap_ScreenDC_StartDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
17553 PyObject *resultobj;
17554 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17555 wxRect *arg2 = (wxRect *) NULL ;
17556 bool result;
17557 PyObject * obj0 = 0 ;
17558 PyObject * obj1 = 0 ;
17559 char *kwnames[] = {
17560 (char *) "self",(char *) "rect", NULL
17561 };
17562
17563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ScreenDC_StartDrawingOnTop",kwnames,&obj0,&obj1)) goto fail;
17564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17565 if (SWIG_arg_fail(1)) SWIG_fail;
17566 if (obj1) {
17567 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
17568 if (SWIG_arg_fail(2)) SWIG_fail;
17569 }
17570 {
17571 PyThreadState* __tstate = wxPyBeginAllowThreads();
17572 result = (bool)(arg1)->StartDrawingOnTop(arg2);
17573
17574 wxPyEndAllowThreads(__tstate);
17575 if (PyErr_Occurred()) SWIG_fail;
17576 }
17577 {
17578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17579 }
17580 return resultobj;
17581 fail:
17582 return NULL;
17583 }
17584
17585
17586 static PyObject *_wrap_ScreenDC_EndDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
17587 PyObject *resultobj;
17588 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17589 bool result;
17590 PyObject * obj0 = 0 ;
17591 char *kwnames[] = {
17592 (char *) "self", NULL
17593 };
17594
17595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScreenDC_EndDrawingOnTop",kwnames,&obj0)) goto fail;
17596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17597 if (SWIG_arg_fail(1)) SWIG_fail;
17598 {
17599 PyThreadState* __tstate = wxPyBeginAllowThreads();
17600 result = (bool)(arg1)->EndDrawingOnTop();
17601
17602 wxPyEndAllowThreads(__tstate);
17603 if (PyErr_Occurred()) SWIG_fail;
17604 }
17605 {
17606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17607 }
17608 return resultobj;
17609 fail:
17610 return NULL;
17611 }
17612
17613
17614 static PyObject * ScreenDC_swigregister(PyObject *, PyObject *args) {
17615 PyObject *obj;
17616 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17617 SWIG_TypeClientData(SWIGTYPE_p_wxScreenDC, obj);
17618 Py_INCREF(obj);
17619 return Py_BuildValue((char *)"");
17620 }
17621 static PyObject *_wrap_new_ClientDC(PyObject *, PyObject *args, PyObject *kwargs) {
17622 PyObject *resultobj;
17623 wxWindow *arg1 = (wxWindow *) 0 ;
17624 wxClientDC *result;
17625 PyObject * obj0 = 0 ;
17626 char *kwnames[] = {
17627 (char *) "win", NULL
17628 };
17629
17630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ClientDC",kwnames,&obj0)) goto fail;
17631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17632 if (SWIG_arg_fail(1)) SWIG_fail;
17633 {
17634 if (!wxPyCheckForApp()) SWIG_fail;
17635 PyThreadState* __tstate = wxPyBeginAllowThreads();
17636 result = (wxClientDC *)new wxClientDC(arg1);
17637
17638 wxPyEndAllowThreads(__tstate);
17639 if (PyErr_Occurred()) SWIG_fail;
17640 }
17641 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClientDC, 1);
17642 return resultobj;
17643 fail:
17644 return NULL;
17645 }
17646
17647
17648 static PyObject * ClientDC_swigregister(PyObject *, PyObject *args) {
17649 PyObject *obj;
17650 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17651 SWIG_TypeClientData(SWIGTYPE_p_wxClientDC, obj);
17652 Py_INCREF(obj);
17653 return Py_BuildValue((char *)"");
17654 }
17655 static PyObject *_wrap_new_PaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
17656 PyObject *resultobj;
17657 wxWindow *arg1 = (wxWindow *) 0 ;
17658 wxPaintDC *result;
17659 PyObject * obj0 = 0 ;
17660 char *kwnames[] = {
17661 (char *) "win", NULL
17662 };
17663
17664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PaintDC",kwnames,&obj0)) goto fail;
17665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17666 if (SWIG_arg_fail(1)) SWIG_fail;
17667 {
17668 if (!wxPyCheckForApp()) SWIG_fail;
17669 PyThreadState* __tstate = wxPyBeginAllowThreads();
17670 result = (wxPaintDC *)new wxPaintDC(arg1);
17671
17672 wxPyEndAllowThreads(__tstate);
17673 if (PyErr_Occurred()) SWIG_fail;
17674 }
17675 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintDC, 1);
17676 return resultobj;
17677 fail:
17678 return NULL;
17679 }
17680
17681
17682 static PyObject * PaintDC_swigregister(PyObject *, PyObject *args) {
17683 PyObject *obj;
17684 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17685 SWIG_TypeClientData(SWIGTYPE_p_wxPaintDC, obj);
17686 Py_INCREF(obj);
17687 return Py_BuildValue((char *)"");
17688 }
17689 static PyObject *_wrap_new_WindowDC(PyObject *, PyObject *args, PyObject *kwargs) {
17690 PyObject *resultobj;
17691 wxWindow *arg1 = (wxWindow *) 0 ;
17692 wxWindowDC *result;
17693 PyObject * obj0 = 0 ;
17694 char *kwnames[] = {
17695 (char *) "win", NULL
17696 };
17697
17698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_WindowDC",kwnames,&obj0)) goto fail;
17699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17700 if (SWIG_arg_fail(1)) SWIG_fail;
17701 {
17702 if (!wxPyCheckForApp()) SWIG_fail;
17703 PyThreadState* __tstate = wxPyBeginAllowThreads();
17704 result = (wxWindowDC *)new wxWindowDC(arg1);
17705
17706 wxPyEndAllowThreads(__tstate);
17707 if (PyErr_Occurred()) SWIG_fail;
17708 }
17709 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDC, 1);
17710 return resultobj;
17711 fail:
17712 return NULL;
17713 }
17714
17715
17716 static PyObject * WindowDC_swigregister(PyObject *, PyObject *args) {
17717 PyObject *obj;
17718 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17719 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDC, obj);
17720 Py_INCREF(obj);
17721 return Py_BuildValue((char *)"");
17722 }
17723 static PyObject *_wrap_new_MirrorDC(PyObject *, PyObject *args, PyObject *kwargs) {
17724 PyObject *resultobj;
17725 wxDC *arg1 = 0 ;
17726 bool arg2 ;
17727 wxMirrorDC *result;
17728 PyObject * obj0 = 0 ;
17729 PyObject * obj1 = 0 ;
17730 char *kwnames[] = {
17731 (char *) "dc",(char *) "mirror", NULL
17732 };
17733
17734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_MirrorDC",kwnames,&obj0,&obj1)) goto fail;
17735 {
17736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17737 if (SWIG_arg_fail(1)) SWIG_fail;
17738 if (arg1 == NULL) {
17739 SWIG_null_ref("wxDC");
17740 }
17741 if (SWIG_arg_fail(1)) SWIG_fail;
17742 }
17743 {
17744 arg2 = (bool)(SWIG_As_bool(obj1));
17745 if (SWIG_arg_fail(2)) SWIG_fail;
17746 }
17747 {
17748 if (!wxPyCheckForApp()) SWIG_fail;
17749 PyThreadState* __tstate = wxPyBeginAllowThreads();
17750 result = (wxMirrorDC *)new wxMirrorDC(*arg1,arg2);
17751
17752 wxPyEndAllowThreads(__tstate);
17753 if (PyErr_Occurred()) SWIG_fail;
17754 }
17755 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMirrorDC, 1);
17756 return resultobj;
17757 fail:
17758 return NULL;
17759 }
17760
17761
17762 static PyObject * MirrorDC_swigregister(PyObject *, PyObject *args) {
17763 PyObject *obj;
17764 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17765 SWIG_TypeClientData(SWIGTYPE_p_wxMirrorDC, obj);
17766 Py_INCREF(obj);
17767 return Py_BuildValue((char *)"");
17768 }
17769 static PyObject *_wrap_new_PostScriptDC(PyObject *, PyObject *args, PyObject *kwargs) {
17770 PyObject *resultobj;
17771 wxPrintData *arg1 = 0 ;
17772 wxPostScriptDC *result;
17773 PyObject * obj0 = 0 ;
17774 char *kwnames[] = {
17775 (char *) "printData", NULL
17776 };
17777
17778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PostScriptDC",kwnames,&obj0)) goto fail;
17779 {
17780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
17781 if (SWIG_arg_fail(1)) SWIG_fail;
17782 if (arg1 == NULL) {
17783 SWIG_null_ref("wxPrintData");
17784 }
17785 if (SWIG_arg_fail(1)) SWIG_fail;
17786 }
17787 {
17788 if (!wxPyCheckForApp()) SWIG_fail;
17789 PyThreadState* __tstate = wxPyBeginAllowThreads();
17790 result = (wxPostScriptDC *)new wxPostScriptDC((wxPrintData const &)*arg1);
17791
17792 wxPyEndAllowThreads(__tstate);
17793 if (PyErr_Occurred()) SWIG_fail;
17794 }
17795 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPostScriptDC, 1);
17796 return resultobj;
17797 fail:
17798 return NULL;
17799 }
17800
17801
17802 static PyObject *_wrap_PostScriptDC_GetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
17803 PyObject *resultobj;
17804 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
17805 wxPrintData *result;
17806 PyObject * obj0 = 0 ;
17807 char *kwnames[] = {
17808 (char *) "self", NULL
17809 };
17810
17811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_GetPrintData",kwnames,&obj0)) goto fail;
17812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
17813 if (SWIG_arg_fail(1)) SWIG_fail;
17814 {
17815 PyThreadState* __tstate = wxPyBeginAllowThreads();
17816 {
17817 wxPrintData &_result_ref = (arg1)->GetPrintData();
17818 result = (wxPrintData *) &_result_ref;
17819 }
17820
17821 wxPyEndAllowThreads(__tstate);
17822 if (PyErr_Occurred()) SWIG_fail;
17823 }
17824 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 0);
17825 return resultobj;
17826 fail:
17827 return NULL;
17828 }
17829
17830
17831 static PyObject *_wrap_PostScriptDC_SetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
17832 PyObject *resultobj;
17833 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
17834 wxPrintData *arg2 = 0 ;
17835 PyObject * obj0 = 0 ;
17836 PyObject * obj1 = 0 ;
17837 char *kwnames[] = {
17838 (char *) "self",(char *) "data", NULL
17839 };
17840
17841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostScriptDC_SetPrintData",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
17846 if (SWIG_arg_fail(2)) SWIG_fail;
17847 if (arg2 == NULL) {
17848 SWIG_null_ref("wxPrintData");
17849 }
17850 if (SWIG_arg_fail(2)) SWIG_fail;
17851 }
17852 {
17853 PyThreadState* __tstate = wxPyBeginAllowThreads();
17854 (arg1)->SetPrintData((wxPrintData const &)*arg2);
17855
17856 wxPyEndAllowThreads(__tstate);
17857 if (PyErr_Occurred()) SWIG_fail;
17858 }
17859 Py_INCREF(Py_None); resultobj = Py_None;
17860 return resultobj;
17861 fail:
17862 return NULL;
17863 }
17864
17865
17866 static PyObject *_wrap_PostScriptDC_SetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
17867 PyObject *resultobj;
17868 int arg1 ;
17869 PyObject * obj0 = 0 ;
17870 char *kwnames[] = {
17871 (char *) "ppi", NULL
17872 };
17873
17874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_SetResolution",kwnames,&obj0)) goto fail;
17875 {
17876 arg1 = (int)(SWIG_As_int(obj0));
17877 if (SWIG_arg_fail(1)) SWIG_fail;
17878 }
17879 {
17880 PyThreadState* __tstate = wxPyBeginAllowThreads();
17881 wxPostScriptDC::SetResolution(arg1);
17882
17883 wxPyEndAllowThreads(__tstate);
17884 if (PyErr_Occurred()) SWIG_fail;
17885 }
17886 Py_INCREF(Py_None); resultobj = Py_None;
17887 return resultobj;
17888 fail:
17889 return NULL;
17890 }
17891
17892
17893 static PyObject *_wrap_PostScriptDC_GetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
17894 PyObject *resultobj;
17895 int result;
17896 char *kwnames[] = {
17897 NULL
17898 };
17899
17900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PostScriptDC_GetResolution",kwnames)) goto fail;
17901 {
17902 PyThreadState* __tstate = wxPyBeginAllowThreads();
17903 result = (int)wxPostScriptDC::GetResolution();
17904
17905 wxPyEndAllowThreads(__tstate);
17906 if (PyErr_Occurred()) SWIG_fail;
17907 }
17908 {
17909 resultobj = SWIG_From_int((int)(result));
17910 }
17911 return resultobj;
17912 fail:
17913 return NULL;
17914 }
17915
17916
17917 static PyObject * PostScriptDC_swigregister(PyObject *, PyObject *args) {
17918 PyObject *obj;
17919 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17920 SWIG_TypeClientData(SWIGTYPE_p_wxPostScriptDC, obj);
17921 Py_INCREF(obj);
17922 return Py_BuildValue((char *)"");
17923 }
17924 static PyObject *_wrap_new_MetaFile(PyObject *, PyObject *args, PyObject *kwargs) {
17925 PyObject *resultobj;
17926 wxString const &arg1_defvalue = wxPyEmptyString ;
17927 wxString *arg1 = (wxString *) &arg1_defvalue ;
17928 wxMetaFile *result;
17929 bool temp1 = false ;
17930 PyObject * obj0 = 0 ;
17931 char *kwnames[] = {
17932 (char *) "filename", NULL
17933 };
17934
17935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MetaFile",kwnames,&obj0)) goto fail;
17936 if (obj0) {
17937 {
17938 arg1 = wxString_in_helper(obj0);
17939 if (arg1 == NULL) SWIG_fail;
17940 temp1 = true;
17941 }
17942 }
17943 {
17944 if (!wxPyCheckForApp()) SWIG_fail;
17945 PyThreadState* __tstate = wxPyBeginAllowThreads();
17946 result = (wxMetaFile *)new wxMetaFile((wxString const &)*arg1);
17947
17948 wxPyEndAllowThreads(__tstate);
17949 if (PyErr_Occurred()) SWIG_fail;
17950 }
17951 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFile, 1);
17952 {
17953 if (temp1)
17954 delete arg1;
17955 }
17956 return resultobj;
17957 fail:
17958 {
17959 if (temp1)
17960 delete arg1;
17961 }
17962 return NULL;
17963 }
17964
17965
17966 static PyObject *_wrap_delete_MetaFile(PyObject *, PyObject *args, PyObject *kwargs) {
17967 PyObject *resultobj;
17968 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
17969 PyObject * obj0 = 0 ;
17970 char *kwnames[] = {
17971 (char *) "self", NULL
17972 };
17973
17974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MetaFile",kwnames,&obj0)) goto fail;
17975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
17976 if (SWIG_arg_fail(1)) SWIG_fail;
17977 {
17978 PyThreadState* __tstate = wxPyBeginAllowThreads();
17979 delete arg1;
17980
17981 wxPyEndAllowThreads(__tstate);
17982 if (PyErr_Occurred()) SWIG_fail;
17983 }
17984 Py_INCREF(Py_None); resultobj = Py_None;
17985 return resultobj;
17986 fail:
17987 return NULL;
17988 }
17989
17990
17991 static PyObject *_wrap_MetaFile_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
17992 PyObject *resultobj;
17993 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
17994 bool result;
17995 PyObject * obj0 = 0 ;
17996 char *kwnames[] = {
17997 (char *) "self", NULL
17998 };
17999
18000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_Ok",kwnames,&obj0)) goto fail;
18001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18002 if (SWIG_arg_fail(1)) SWIG_fail;
18003 {
18004 PyThreadState* __tstate = wxPyBeginAllowThreads();
18005 result = (bool)(arg1)->Ok();
18006
18007 wxPyEndAllowThreads(__tstate);
18008 if (PyErr_Occurred()) SWIG_fail;
18009 }
18010 {
18011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18012 }
18013 return resultobj;
18014 fail:
18015 return NULL;
18016 }
18017
18018
18019 static PyObject *_wrap_MetaFile_SetClipboard(PyObject *, PyObject *args, PyObject *kwargs) {
18020 PyObject *resultobj;
18021 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18022 int arg2 = (int) 0 ;
18023 int arg3 = (int) 0 ;
18024 bool result;
18025 PyObject * obj0 = 0 ;
18026 PyObject * obj1 = 0 ;
18027 PyObject * obj2 = 0 ;
18028 char *kwnames[] = {
18029 (char *) "self",(char *) "width",(char *) "height", NULL
18030 };
18031
18032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MetaFile_SetClipboard",kwnames,&obj0,&obj1,&obj2)) goto fail;
18033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18034 if (SWIG_arg_fail(1)) SWIG_fail;
18035 if (obj1) {
18036 {
18037 arg2 = (int)(SWIG_As_int(obj1));
18038 if (SWIG_arg_fail(2)) SWIG_fail;
18039 }
18040 }
18041 if (obj2) {
18042 {
18043 arg3 = (int)(SWIG_As_int(obj2));
18044 if (SWIG_arg_fail(3)) SWIG_fail;
18045 }
18046 }
18047 {
18048 PyThreadState* __tstate = wxPyBeginAllowThreads();
18049 result = (bool)(arg1)->SetClipboard(arg2,arg3);
18050
18051 wxPyEndAllowThreads(__tstate);
18052 if (PyErr_Occurred()) SWIG_fail;
18053 }
18054 {
18055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18056 }
18057 return resultobj;
18058 fail:
18059 return NULL;
18060 }
18061
18062
18063 static PyObject *_wrap_MetaFile_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18064 PyObject *resultobj;
18065 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18066 wxSize result;
18067 PyObject * obj0 = 0 ;
18068 char *kwnames[] = {
18069 (char *) "self", NULL
18070 };
18071
18072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetSize",kwnames,&obj0)) goto fail;
18073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18074 if (SWIG_arg_fail(1)) SWIG_fail;
18075 {
18076 PyThreadState* __tstate = wxPyBeginAllowThreads();
18077 result = (arg1)->GetSize();
18078
18079 wxPyEndAllowThreads(__tstate);
18080 if (PyErr_Occurred()) SWIG_fail;
18081 }
18082 {
18083 wxSize * resultptr;
18084 resultptr = new wxSize((wxSize &)(result));
18085 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18086 }
18087 return resultobj;
18088 fail:
18089 return NULL;
18090 }
18091
18092
18093 static PyObject *_wrap_MetaFile_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
18094 PyObject *resultobj;
18095 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18096 int result;
18097 PyObject * obj0 = 0 ;
18098 char *kwnames[] = {
18099 (char *) "self", NULL
18100 };
18101
18102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetWidth",kwnames,&obj0)) goto fail;
18103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18104 if (SWIG_arg_fail(1)) SWIG_fail;
18105 {
18106 PyThreadState* __tstate = wxPyBeginAllowThreads();
18107 result = (int)(arg1)->GetWidth();
18108
18109 wxPyEndAllowThreads(__tstate);
18110 if (PyErr_Occurred()) SWIG_fail;
18111 }
18112 {
18113 resultobj = SWIG_From_int((int)(result));
18114 }
18115 return resultobj;
18116 fail:
18117 return NULL;
18118 }
18119
18120
18121 static PyObject *_wrap_MetaFile_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
18122 PyObject *resultobj;
18123 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18124 int result;
18125 PyObject * obj0 = 0 ;
18126 char *kwnames[] = {
18127 (char *) "self", NULL
18128 };
18129
18130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetHeight",kwnames,&obj0)) goto fail;
18131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18132 if (SWIG_arg_fail(1)) SWIG_fail;
18133 {
18134 PyThreadState* __tstate = wxPyBeginAllowThreads();
18135 result = (int)(arg1)->GetHeight();
18136
18137 wxPyEndAllowThreads(__tstate);
18138 if (PyErr_Occurred()) SWIG_fail;
18139 }
18140 {
18141 resultobj = SWIG_From_int((int)(result));
18142 }
18143 return resultobj;
18144 fail:
18145 return NULL;
18146 }
18147
18148
18149 static PyObject * MetaFile_swigregister(PyObject *, PyObject *args) {
18150 PyObject *obj;
18151 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18152 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFile, obj);
18153 Py_INCREF(obj);
18154 return Py_BuildValue((char *)"");
18155 }
18156 static PyObject *_wrap_new_MetaFileDC(PyObject *, PyObject *args, PyObject *kwargs) {
18157 PyObject *resultobj;
18158 wxString const &arg1_defvalue = wxPyEmptyString ;
18159 wxString *arg1 = (wxString *) &arg1_defvalue ;
18160 int arg2 = (int) 0 ;
18161 int arg3 = (int) 0 ;
18162 wxString const &arg4_defvalue = wxPyEmptyString ;
18163 wxString *arg4 = (wxString *) &arg4_defvalue ;
18164 wxMetaFileDC *result;
18165 bool temp1 = false ;
18166 bool temp4 = false ;
18167 PyObject * obj0 = 0 ;
18168 PyObject * obj1 = 0 ;
18169 PyObject * obj2 = 0 ;
18170 PyObject * obj3 = 0 ;
18171 char *kwnames[] = {
18172 (char *) "filename",(char *) "width",(char *) "height",(char *) "description", NULL
18173 };
18174
18175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_MetaFileDC",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
18176 if (obj0) {
18177 {
18178 arg1 = wxString_in_helper(obj0);
18179 if (arg1 == NULL) SWIG_fail;
18180 temp1 = true;
18181 }
18182 }
18183 if (obj1) {
18184 {
18185 arg2 = (int)(SWIG_As_int(obj1));
18186 if (SWIG_arg_fail(2)) SWIG_fail;
18187 }
18188 }
18189 if (obj2) {
18190 {
18191 arg3 = (int)(SWIG_As_int(obj2));
18192 if (SWIG_arg_fail(3)) SWIG_fail;
18193 }
18194 }
18195 if (obj3) {
18196 {
18197 arg4 = wxString_in_helper(obj3);
18198 if (arg4 == NULL) SWIG_fail;
18199 temp4 = true;
18200 }
18201 }
18202 {
18203 if (!wxPyCheckForApp()) SWIG_fail;
18204 PyThreadState* __tstate = wxPyBeginAllowThreads();
18205 result = (wxMetaFileDC *)new wxMetaFileDC((wxString const &)*arg1,arg2,arg3,(wxString const &)*arg4);
18206
18207 wxPyEndAllowThreads(__tstate);
18208 if (PyErr_Occurred()) SWIG_fail;
18209 }
18210 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFileDC, 1);
18211 {
18212 if (temp1)
18213 delete arg1;
18214 }
18215 {
18216 if (temp4)
18217 delete arg4;
18218 }
18219 return resultobj;
18220 fail:
18221 {
18222 if (temp1)
18223 delete arg1;
18224 }
18225 {
18226 if (temp4)
18227 delete arg4;
18228 }
18229 return NULL;
18230 }
18231
18232
18233 static PyObject *_wrap_MetaFileDC_Close(PyObject *, PyObject *args, PyObject *kwargs) {
18234 PyObject *resultobj;
18235 wxMetaFileDC *arg1 = (wxMetaFileDC *) 0 ;
18236 wxMetaFile *result;
18237 PyObject * obj0 = 0 ;
18238 char *kwnames[] = {
18239 (char *) "self", NULL
18240 };
18241
18242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFileDC_Close",kwnames,&obj0)) goto fail;
18243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFileDC, SWIG_POINTER_EXCEPTION | 0);
18244 if (SWIG_arg_fail(1)) SWIG_fail;
18245 {
18246 PyThreadState* __tstate = wxPyBeginAllowThreads();
18247 result = (wxMetaFile *)(arg1)->Close();
18248
18249 wxPyEndAllowThreads(__tstate);
18250 if (PyErr_Occurred()) SWIG_fail;
18251 }
18252 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFile, 0);
18253 return resultobj;
18254 fail:
18255 return NULL;
18256 }
18257
18258
18259 static PyObject * MetaFileDC_swigregister(PyObject *, PyObject *args) {
18260 PyObject *obj;
18261 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18262 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFileDC, obj);
18263 Py_INCREF(obj);
18264 return Py_BuildValue((char *)"");
18265 }
18266 static PyObject *_wrap_new_PrinterDC(PyObject *, PyObject *args, PyObject *kwargs) {
18267 PyObject *resultobj;
18268 wxPrintData *arg1 = 0 ;
18269 wxPrinterDC *result;
18270 PyObject * obj0 = 0 ;
18271 char *kwnames[] = {
18272 (char *) "printData", NULL
18273 };
18274
18275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PrinterDC",kwnames,&obj0)) goto fail;
18276 {
18277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
18278 if (SWIG_arg_fail(1)) SWIG_fail;
18279 if (arg1 == NULL) {
18280 SWIG_null_ref("wxPrintData");
18281 }
18282 if (SWIG_arg_fail(1)) SWIG_fail;
18283 }
18284 {
18285 if (!wxPyCheckForApp()) SWIG_fail;
18286 PyThreadState* __tstate = wxPyBeginAllowThreads();
18287 result = (wxPrinterDC *)new wxPrinterDC((wxPrintData const &)*arg1);
18288
18289 wxPyEndAllowThreads(__tstate);
18290 if (PyErr_Occurred()) SWIG_fail;
18291 }
18292 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrinterDC, 1);
18293 return resultobj;
18294 fail:
18295 return NULL;
18296 }
18297
18298
18299 static PyObject * PrinterDC_swigregister(PyObject *, PyObject *args) {
18300 PyObject *obj;
18301 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18302 SWIG_TypeClientData(SWIGTYPE_p_wxPrinterDC, obj);
18303 Py_INCREF(obj);
18304 return Py_BuildValue((char *)"");
18305 }
18306 static PyObject *_wrap_new_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
18307 PyObject *resultobj;
18308 int arg1 ;
18309 int arg2 ;
18310 int arg3 = (int) true ;
18311 int arg4 = (int) 1 ;
18312 wxImageList *result;
18313 PyObject * obj0 = 0 ;
18314 PyObject * obj1 = 0 ;
18315 PyObject * obj2 = 0 ;
18316 PyObject * obj3 = 0 ;
18317 char *kwnames[] = {
18318 (char *) "width",(char *) "height",(char *) "mask",(char *) "initialCount", NULL
18319 };
18320
18321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_ImageList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
18322 {
18323 arg1 = (int)(SWIG_As_int(obj0));
18324 if (SWIG_arg_fail(1)) SWIG_fail;
18325 }
18326 {
18327 arg2 = (int)(SWIG_As_int(obj1));
18328 if (SWIG_arg_fail(2)) SWIG_fail;
18329 }
18330 if (obj2) {
18331 {
18332 arg3 = (int)(SWIG_As_int(obj2));
18333 if (SWIG_arg_fail(3)) SWIG_fail;
18334 }
18335 }
18336 if (obj3) {
18337 {
18338 arg4 = (int)(SWIG_As_int(obj3));
18339 if (SWIG_arg_fail(4)) SWIG_fail;
18340 }
18341 }
18342 {
18343 if (!wxPyCheckForApp()) SWIG_fail;
18344 PyThreadState* __tstate = wxPyBeginAllowThreads();
18345 result = (wxImageList *)new wxImageList(arg1,arg2,arg3,arg4);
18346
18347 wxPyEndAllowThreads(__tstate);
18348 if (PyErr_Occurred()) SWIG_fail;
18349 }
18350 {
18351 resultobj = wxPyMake_wxObject(result, 1);
18352 }
18353 return resultobj;
18354 fail:
18355 return NULL;
18356 }
18357
18358
18359 static PyObject *_wrap_delete_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
18360 PyObject *resultobj;
18361 wxImageList *arg1 = (wxImageList *) 0 ;
18362 PyObject * obj0 = 0 ;
18363 char *kwnames[] = {
18364 (char *) "self", NULL
18365 };
18366
18367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ImageList",kwnames,&obj0)) goto fail;
18368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18369 if (SWIG_arg_fail(1)) SWIG_fail;
18370 {
18371 PyThreadState* __tstate = wxPyBeginAllowThreads();
18372 delete arg1;
18373
18374 wxPyEndAllowThreads(__tstate);
18375 if (PyErr_Occurred()) SWIG_fail;
18376 }
18377 Py_INCREF(Py_None); resultobj = Py_None;
18378 return resultobj;
18379 fail:
18380 return NULL;
18381 }
18382
18383
18384 static PyObject *_wrap_ImageList_Add(PyObject *, PyObject *args, PyObject *kwargs) {
18385 PyObject *resultobj;
18386 wxImageList *arg1 = (wxImageList *) 0 ;
18387 wxBitmap *arg2 = 0 ;
18388 wxBitmap const &arg3_defvalue = wxNullBitmap ;
18389 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
18390 int result;
18391 PyObject * obj0 = 0 ;
18392 PyObject * obj1 = 0 ;
18393 PyObject * obj2 = 0 ;
18394 char *kwnames[] = {
18395 (char *) "self",(char *) "bitmap",(char *) "mask", NULL
18396 };
18397
18398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ImageList_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
18399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18400 if (SWIG_arg_fail(1)) SWIG_fail;
18401 {
18402 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18403 if (SWIG_arg_fail(2)) SWIG_fail;
18404 if (arg2 == NULL) {
18405 SWIG_null_ref("wxBitmap");
18406 }
18407 if (SWIG_arg_fail(2)) SWIG_fail;
18408 }
18409 if (obj2) {
18410 {
18411 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18412 if (SWIG_arg_fail(3)) SWIG_fail;
18413 if (arg3 == NULL) {
18414 SWIG_null_ref("wxBitmap");
18415 }
18416 if (SWIG_arg_fail(3)) SWIG_fail;
18417 }
18418 }
18419 {
18420 PyThreadState* __tstate = wxPyBeginAllowThreads();
18421 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
18422
18423 wxPyEndAllowThreads(__tstate);
18424 if (PyErr_Occurred()) SWIG_fail;
18425 }
18426 {
18427 resultobj = SWIG_From_int((int)(result));
18428 }
18429 return resultobj;
18430 fail:
18431 return NULL;
18432 }
18433
18434
18435 static PyObject *_wrap_ImageList_AddWithColourMask(PyObject *, PyObject *args, PyObject *kwargs) {
18436 PyObject *resultobj;
18437 wxImageList *arg1 = (wxImageList *) 0 ;
18438 wxBitmap *arg2 = 0 ;
18439 wxColour *arg3 = 0 ;
18440 int result;
18441 wxColour temp3 ;
18442 PyObject * obj0 = 0 ;
18443 PyObject * obj1 = 0 ;
18444 PyObject * obj2 = 0 ;
18445 char *kwnames[] = {
18446 (char *) "self",(char *) "bitmap",(char *) "maskColour", NULL
18447 };
18448
18449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_AddWithColourMask",kwnames,&obj0,&obj1,&obj2)) goto fail;
18450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18451 if (SWIG_arg_fail(1)) SWIG_fail;
18452 {
18453 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18454 if (SWIG_arg_fail(2)) SWIG_fail;
18455 if (arg2 == NULL) {
18456 SWIG_null_ref("wxBitmap");
18457 }
18458 if (SWIG_arg_fail(2)) SWIG_fail;
18459 }
18460 {
18461 arg3 = &temp3;
18462 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
18463 }
18464 {
18465 PyThreadState* __tstate = wxPyBeginAllowThreads();
18466 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxColour const &)*arg3);
18467
18468 wxPyEndAllowThreads(__tstate);
18469 if (PyErr_Occurred()) SWIG_fail;
18470 }
18471 {
18472 resultobj = SWIG_From_int((int)(result));
18473 }
18474 return resultobj;
18475 fail:
18476 return NULL;
18477 }
18478
18479
18480 static PyObject *_wrap_ImageList_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
18481 PyObject *resultobj;
18482 wxImageList *arg1 = (wxImageList *) 0 ;
18483 wxIcon *arg2 = 0 ;
18484 int result;
18485 PyObject * obj0 = 0 ;
18486 PyObject * obj1 = 0 ;
18487 char *kwnames[] = {
18488 (char *) "self",(char *) "icon", NULL
18489 };
18490
18491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_AddIcon",kwnames,&obj0,&obj1)) goto fail;
18492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18493 if (SWIG_arg_fail(1)) SWIG_fail;
18494 {
18495 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
18496 if (SWIG_arg_fail(2)) SWIG_fail;
18497 if (arg2 == NULL) {
18498 SWIG_null_ref("wxIcon");
18499 }
18500 if (SWIG_arg_fail(2)) SWIG_fail;
18501 }
18502 {
18503 PyThreadState* __tstate = wxPyBeginAllowThreads();
18504 result = (int)(arg1)->Add((wxIcon const &)*arg2);
18505
18506 wxPyEndAllowThreads(__tstate);
18507 if (PyErr_Occurred()) SWIG_fail;
18508 }
18509 {
18510 resultobj = SWIG_From_int((int)(result));
18511 }
18512 return resultobj;
18513 fail:
18514 return NULL;
18515 }
18516
18517
18518 static PyObject *_wrap_ImageList_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
18519 PyObject *resultobj;
18520 wxImageList *arg1 = (wxImageList *) 0 ;
18521 int arg2 ;
18522 SwigValueWrapper<wxBitmap > result;
18523 PyObject * obj0 = 0 ;
18524 PyObject * obj1 = 0 ;
18525 char *kwnames[] = {
18526 (char *) "self",(char *) "index", NULL
18527 };
18528
18529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetBitmap",kwnames,&obj0,&obj1)) goto fail;
18530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18531 if (SWIG_arg_fail(1)) SWIG_fail;
18532 {
18533 arg2 = (int)(SWIG_As_int(obj1));
18534 if (SWIG_arg_fail(2)) SWIG_fail;
18535 }
18536 {
18537 PyThreadState* __tstate = wxPyBeginAllowThreads();
18538 result = ((wxImageList const *)arg1)->GetBitmap(arg2);
18539
18540 wxPyEndAllowThreads(__tstate);
18541 if (PyErr_Occurred()) SWIG_fail;
18542 }
18543 {
18544 wxBitmap * resultptr;
18545 resultptr = new wxBitmap((wxBitmap &)(result));
18546 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
18547 }
18548 return resultobj;
18549 fail:
18550 return NULL;
18551 }
18552
18553
18554 static PyObject *_wrap_ImageList_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
18555 PyObject *resultobj;
18556 wxImageList *arg1 = (wxImageList *) 0 ;
18557 int arg2 ;
18558 wxIcon result;
18559 PyObject * obj0 = 0 ;
18560 PyObject * obj1 = 0 ;
18561 char *kwnames[] = {
18562 (char *) "self",(char *) "index", NULL
18563 };
18564
18565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetIcon",kwnames,&obj0,&obj1)) goto fail;
18566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18567 if (SWIG_arg_fail(1)) SWIG_fail;
18568 {
18569 arg2 = (int)(SWIG_As_int(obj1));
18570 if (SWIG_arg_fail(2)) SWIG_fail;
18571 }
18572 {
18573 PyThreadState* __tstate = wxPyBeginAllowThreads();
18574 result = ((wxImageList const *)arg1)->GetIcon(arg2);
18575
18576 wxPyEndAllowThreads(__tstate);
18577 if (PyErr_Occurred()) SWIG_fail;
18578 }
18579 {
18580 wxIcon * resultptr;
18581 resultptr = new wxIcon((wxIcon &)(result));
18582 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
18583 }
18584 return resultobj;
18585 fail:
18586 return NULL;
18587 }
18588
18589
18590 static PyObject *_wrap_ImageList_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
18591 PyObject *resultobj;
18592 wxImageList *arg1 = (wxImageList *) 0 ;
18593 int arg2 ;
18594 wxBitmap *arg3 = 0 ;
18595 bool result;
18596 PyObject * obj0 = 0 ;
18597 PyObject * obj1 = 0 ;
18598 PyObject * obj2 = 0 ;
18599 char *kwnames[] = {
18600 (char *) "self",(char *) "index",(char *) "bitmap", NULL
18601 };
18602
18603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_Replace",kwnames,&obj0,&obj1,&obj2)) goto fail;
18604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18605 if (SWIG_arg_fail(1)) SWIG_fail;
18606 {
18607 arg2 = (int)(SWIG_As_int(obj1));
18608 if (SWIG_arg_fail(2)) SWIG_fail;
18609 }
18610 {
18611 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18612 if (SWIG_arg_fail(3)) SWIG_fail;
18613 if (arg3 == NULL) {
18614 SWIG_null_ref("wxBitmap");
18615 }
18616 if (SWIG_arg_fail(3)) SWIG_fail;
18617 }
18618 {
18619 PyThreadState* __tstate = wxPyBeginAllowThreads();
18620 result = (bool)(arg1)->Replace(arg2,(wxBitmap const &)*arg3);
18621
18622 wxPyEndAllowThreads(__tstate);
18623 if (PyErr_Occurred()) SWIG_fail;
18624 }
18625 {
18626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18627 }
18628 return resultobj;
18629 fail:
18630 return NULL;
18631 }
18632
18633
18634 static PyObject *_wrap_ImageList_Draw(PyObject *, PyObject *args, PyObject *kwargs) {
18635 PyObject *resultobj;
18636 wxImageList *arg1 = (wxImageList *) 0 ;
18637 int arg2 ;
18638 wxDC *arg3 = 0 ;
18639 int arg4 ;
18640 int arg5 ;
18641 int arg6 = (int) wxIMAGELIST_DRAW_NORMAL ;
18642 bool arg7 = (bool) (bool)false ;
18643 bool result;
18644 PyObject * obj0 = 0 ;
18645 PyObject * obj1 = 0 ;
18646 PyObject * obj2 = 0 ;
18647 PyObject * obj3 = 0 ;
18648 PyObject * obj4 = 0 ;
18649 PyObject * obj5 = 0 ;
18650 PyObject * obj6 = 0 ;
18651 char *kwnames[] = {
18652 (char *) "self",(char *) "index",(char *) "dc",(char *) "x",(char *) "x",(char *) "flags",(char *) "solidBackground", NULL
18653 };
18654
18655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OO:ImageList_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
18656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18657 if (SWIG_arg_fail(1)) SWIG_fail;
18658 {
18659 arg2 = (int)(SWIG_As_int(obj1));
18660 if (SWIG_arg_fail(2)) SWIG_fail;
18661 }
18662 {
18663 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
18664 if (SWIG_arg_fail(3)) SWIG_fail;
18665 if (arg3 == NULL) {
18666 SWIG_null_ref("wxDC");
18667 }
18668 if (SWIG_arg_fail(3)) SWIG_fail;
18669 }
18670 {
18671 arg4 = (int)(SWIG_As_int(obj3));
18672 if (SWIG_arg_fail(4)) SWIG_fail;
18673 }
18674 {
18675 arg5 = (int)(SWIG_As_int(obj4));
18676 if (SWIG_arg_fail(5)) SWIG_fail;
18677 }
18678 if (obj5) {
18679 {
18680 arg6 = (int)(SWIG_As_int(obj5));
18681 if (SWIG_arg_fail(6)) SWIG_fail;
18682 }
18683 }
18684 if (obj6) {
18685 {
18686 arg7 = (bool const)(SWIG_As_bool(obj6));
18687 if (SWIG_arg_fail(7)) SWIG_fail;
18688 }
18689 }
18690 {
18691 PyThreadState* __tstate = wxPyBeginAllowThreads();
18692 result = (bool)(arg1)->Draw(arg2,*arg3,arg4,arg5,arg6,arg7);
18693
18694 wxPyEndAllowThreads(__tstate);
18695 if (PyErr_Occurred()) SWIG_fail;
18696 }
18697 {
18698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18699 }
18700 return resultobj;
18701 fail:
18702 return NULL;
18703 }
18704
18705
18706 static PyObject *_wrap_ImageList_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
18707 PyObject *resultobj;
18708 wxImageList *arg1 = (wxImageList *) 0 ;
18709 int result;
18710 PyObject * obj0 = 0 ;
18711 char *kwnames[] = {
18712 (char *) "self", NULL
18713 };
18714
18715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_GetImageCount",kwnames,&obj0)) goto fail;
18716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18717 if (SWIG_arg_fail(1)) SWIG_fail;
18718 {
18719 PyThreadState* __tstate = wxPyBeginAllowThreads();
18720 result = (int)(arg1)->GetImageCount();
18721
18722 wxPyEndAllowThreads(__tstate);
18723 if (PyErr_Occurred()) SWIG_fail;
18724 }
18725 {
18726 resultobj = SWIG_From_int((int)(result));
18727 }
18728 return resultobj;
18729 fail:
18730 return NULL;
18731 }
18732
18733
18734 static PyObject *_wrap_ImageList_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
18735 PyObject *resultobj;
18736 wxImageList *arg1 = (wxImageList *) 0 ;
18737 int arg2 ;
18738 bool result;
18739 PyObject * obj0 = 0 ;
18740 PyObject * obj1 = 0 ;
18741 char *kwnames[] = {
18742 (char *) "self",(char *) "index", NULL
18743 };
18744
18745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_Remove",kwnames,&obj0,&obj1)) goto fail;
18746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18747 if (SWIG_arg_fail(1)) SWIG_fail;
18748 {
18749 arg2 = (int)(SWIG_As_int(obj1));
18750 if (SWIG_arg_fail(2)) SWIG_fail;
18751 }
18752 {
18753 PyThreadState* __tstate = wxPyBeginAllowThreads();
18754 result = (bool)(arg1)->Remove(arg2);
18755
18756 wxPyEndAllowThreads(__tstate);
18757 if (PyErr_Occurred()) SWIG_fail;
18758 }
18759 {
18760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18761 }
18762 return resultobj;
18763 fail:
18764 return NULL;
18765 }
18766
18767
18768 static PyObject *_wrap_ImageList_RemoveAll(PyObject *, PyObject *args, PyObject *kwargs) {
18769 PyObject *resultobj;
18770 wxImageList *arg1 = (wxImageList *) 0 ;
18771 bool result;
18772 PyObject * obj0 = 0 ;
18773 char *kwnames[] = {
18774 (char *) "self", NULL
18775 };
18776
18777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_RemoveAll",kwnames,&obj0)) goto fail;
18778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18779 if (SWIG_arg_fail(1)) SWIG_fail;
18780 {
18781 PyThreadState* __tstate = wxPyBeginAllowThreads();
18782 result = (bool)(arg1)->RemoveAll();
18783
18784 wxPyEndAllowThreads(__tstate);
18785 if (PyErr_Occurred()) SWIG_fail;
18786 }
18787 {
18788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18789 }
18790 return resultobj;
18791 fail:
18792 return NULL;
18793 }
18794
18795
18796 static PyObject *_wrap_ImageList_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18797 PyObject *resultobj;
18798 wxImageList *arg1 = (wxImageList *) 0 ;
18799 int arg2 ;
18800 int *arg3 = 0 ;
18801 int *arg4 = 0 ;
18802 int temp3 ;
18803 int res3 = 0 ;
18804 int temp4 ;
18805 int res4 = 0 ;
18806 PyObject * obj0 = 0 ;
18807 PyObject * obj1 = 0 ;
18808 char *kwnames[] = {
18809 (char *) "self",(char *) "index", NULL
18810 };
18811
18812 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18813 arg4 = &temp4; res4 = SWIG_NEWOBJ;
18814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetSize",kwnames,&obj0,&obj1)) goto fail;
18815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18816 if (SWIG_arg_fail(1)) SWIG_fail;
18817 {
18818 arg2 = (int)(SWIG_As_int(obj1));
18819 if (SWIG_arg_fail(2)) SWIG_fail;
18820 }
18821 {
18822 PyThreadState* __tstate = wxPyBeginAllowThreads();
18823 (arg1)->GetSize(arg2,*arg3,*arg4);
18824
18825 wxPyEndAllowThreads(__tstate);
18826 if (PyErr_Occurred()) SWIG_fail;
18827 }
18828 Py_INCREF(Py_None); resultobj = Py_None;
18829 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18830 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
18831 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
18832 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
18833 return resultobj;
18834 fail:
18835 return NULL;
18836 }
18837
18838
18839 static PyObject * ImageList_swigregister(PyObject *, PyObject *args) {
18840 PyObject *obj;
18841 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18842 SWIG_TypeClientData(SWIGTYPE_p_wxImageList, obj);
18843 Py_INCREF(obj);
18844 return Py_BuildValue((char *)"");
18845 }
18846 static int _wrap_NORMAL_FONT_set(PyObject *) {
18847 PyErr_SetString(PyExc_TypeError,"Variable NORMAL_FONT is read-only.");
18848 return 1;
18849 }
18850
18851
18852 static PyObject *_wrap_NORMAL_FONT_get(void) {
18853 PyObject *pyobj;
18854
18855 pyobj = SWIG_NewPointerObj((void *)(wxNORMAL_FONT), SWIGTYPE_p_wxFont, 0);
18856 return pyobj;
18857 }
18858
18859
18860 static int _wrap_SMALL_FONT_set(PyObject *) {
18861 PyErr_SetString(PyExc_TypeError,"Variable SMALL_FONT is read-only.");
18862 return 1;
18863 }
18864
18865
18866 static PyObject *_wrap_SMALL_FONT_get(void) {
18867 PyObject *pyobj;
18868
18869 pyobj = SWIG_NewPointerObj((void *)(wxSMALL_FONT), SWIGTYPE_p_wxFont, 0);
18870 return pyobj;
18871 }
18872
18873
18874 static int _wrap_ITALIC_FONT_set(PyObject *) {
18875 PyErr_SetString(PyExc_TypeError,"Variable ITALIC_FONT is read-only.");
18876 return 1;
18877 }
18878
18879
18880 static PyObject *_wrap_ITALIC_FONT_get(void) {
18881 PyObject *pyobj;
18882
18883 pyobj = SWIG_NewPointerObj((void *)(wxITALIC_FONT), SWIGTYPE_p_wxFont, 0);
18884 return pyobj;
18885 }
18886
18887
18888 static int _wrap_SWISS_FONT_set(PyObject *) {
18889 PyErr_SetString(PyExc_TypeError,"Variable SWISS_FONT is read-only.");
18890 return 1;
18891 }
18892
18893
18894 static PyObject *_wrap_SWISS_FONT_get(void) {
18895 PyObject *pyobj;
18896
18897 pyobj = SWIG_NewPointerObj((void *)(wxSWISS_FONT), SWIGTYPE_p_wxFont, 0);
18898 return pyobj;
18899 }
18900
18901
18902 static int _wrap_RED_PEN_set(PyObject *) {
18903 PyErr_SetString(PyExc_TypeError,"Variable RED_PEN is read-only.");
18904 return 1;
18905 }
18906
18907
18908 static PyObject *_wrap_RED_PEN_get(void) {
18909 PyObject *pyobj;
18910
18911 pyobj = SWIG_NewPointerObj((void *)(wxRED_PEN), SWIGTYPE_p_wxPen, 0);
18912 return pyobj;
18913 }
18914
18915
18916 static int _wrap_CYAN_PEN_set(PyObject *) {
18917 PyErr_SetString(PyExc_TypeError,"Variable CYAN_PEN is read-only.");
18918 return 1;
18919 }
18920
18921
18922 static PyObject *_wrap_CYAN_PEN_get(void) {
18923 PyObject *pyobj;
18924
18925 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_PEN), SWIGTYPE_p_wxPen, 0);
18926 return pyobj;
18927 }
18928
18929
18930 static int _wrap_GREEN_PEN_set(PyObject *) {
18931 PyErr_SetString(PyExc_TypeError,"Variable GREEN_PEN is read-only.");
18932 return 1;
18933 }
18934
18935
18936 static PyObject *_wrap_GREEN_PEN_get(void) {
18937 PyObject *pyobj;
18938
18939 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_PEN), SWIGTYPE_p_wxPen, 0);
18940 return pyobj;
18941 }
18942
18943
18944 static int _wrap_BLACK_PEN_set(PyObject *) {
18945 PyErr_SetString(PyExc_TypeError,"Variable BLACK_PEN is read-only.");
18946 return 1;
18947 }
18948
18949
18950 static PyObject *_wrap_BLACK_PEN_get(void) {
18951 PyObject *pyobj;
18952
18953 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_PEN), SWIGTYPE_p_wxPen, 0);
18954 return pyobj;
18955 }
18956
18957
18958 static int _wrap_WHITE_PEN_set(PyObject *) {
18959 PyErr_SetString(PyExc_TypeError,"Variable WHITE_PEN is read-only.");
18960 return 1;
18961 }
18962
18963
18964 static PyObject *_wrap_WHITE_PEN_get(void) {
18965 PyObject *pyobj;
18966
18967 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_PEN), SWIGTYPE_p_wxPen, 0);
18968 return pyobj;
18969 }
18970
18971
18972 static int _wrap_TRANSPARENT_PEN_set(PyObject *) {
18973 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_PEN is read-only.");
18974 return 1;
18975 }
18976
18977
18978 static PyObject *_wrap_TRANSPARENT_PEN_get(void) {
18979 PyObject *pyobj;
18980
18981 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_PEN), SWIGTYPE_p_wxPen, 0);
18982 return pyobj;
18983 }
18984
18985
18986 static int _wrap_BLACK_DASHED_PEN_set(PyObject *) {
18987 PyErr_SetString(PyExc_TypeError,"Variable BLACK_DASHED_PEN is read-only.");
18988 return 1;
18989 }
18990
18991
18992 static PyObject *_wrap_BLACK_DASHED_PEN_get(void) {
18993 PyObject *pyobj;
18994
18995 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_DASHED_PEN), SWIGTYPE_p_wxPen, 0);
18996 return pyobj;
18997 }
18998
18999
19000 static int _wrap_GREY_PEN_set(PyObject *) {
19001 PyErr_SetString(PyExc_TypeError,"Variable GREY_PEN is read-only.");
19002 return 1;
19003 }
19004
19005
19006 static PyObject *_wrap_GREY_PEN_get(void) {
19007 PyObject *pyobj;
19008
19009 pyobj = SWIG_NewPointerObj((void *)(wxGREY_PEN), SWIGTYPE_p_wxPen, 0);
19010 return pyobj;
19011 }
19012
19013
19014 static int _wrap_MEDIUM_GREY_PEN_set(PyObject *) {
19015 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_PEN is read-only.");
19016 return 1;
19017 }
19018
19019
19020 static PyObject *_wrap_MEDIUM_GREY_PEN_get(void) {
19021 PyObject *pyobj;
19022
19023 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_PEN), SWIGTYPE_p_wxPen, 0);
19024 return pyobj;
19025 }
19026
19027
19028 static int _wrap_LIGHT_GREY_PEN_set(PyObject *) {
19029 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_PEN is read-only.");
19030 return 1;
19031 }
19032
19033
19034 static PyObject *_wrap_LIGHT_GREY_PEN_get(void) {
19035 PyObject *pyobj;
19036
19037 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_PEN), SWIGTYPE_p_wxPen, 0);
19038 return pyobj;
19039 }
19040
19041
19042 static int _wrap_BLUE_BRUSH_set(PyObject *) {
19043 PyErr_SetString(PyExc_TypeError,"Variable BLUE_BRUSH is read-only.");
19044 return 1;
19045 }
19046
19047
19048 static PyObject *_wrap_BLUE_BRUSH_get(void) {
19049 PyObject *pyobj;
19050
19051 pyobj = SWIG_NewPointerObj((void *)(wxBLUE_BRUSH), SWIGTYPE_p_wxBrush, 0);
19052 return pyobj;
19053 }
19054
19055
19056 static int _wrap_GREEN_BRUSH_set(PyObject *) {
19057 PyErr_SetString(PyExc_TypeError,"Variable GREEN_BRUSH is read-only.");
19058 return 1;
19059 }
19060
19061
19062 static PyObject *_wrap_GREEN_BRUSH_get(void) {
19063 PyObject *pyobj;
19064
19065 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_BRUSH), SWIGTYPE_p_wxBrush, 0);
19066 return pyobj;
19067 }
19068
19069
19070 static int _wrap_WHITE_BRUSH_set(PyObject *) {
19071 PyErr_SetString(PyExc_TypeError,"Variable WHITE_BRUSH is read-only.");
19072 return 1;
19073 }
19074
19075
19076 static PyObject *_wrap_WHITE_BRUSH_get(void) {
19077 PyObject *pyobj;
19078
19079 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_BRUSH), SWIGTYPE_p_wxBrush, 0);
19080 return pyobj;
19081 }
19082
19083
19084 static int _wrap_BLACK_BRUSH_set(PyObject *) {
19085 PyErr_SetString(PyExc_TypeError,"Variable BLACK_BRUSH is read-only.");
19086 return 1;
19087 }
19088
19089
19090 static PyObject *_wrap_BLACK_BRUSH_get(void) {
19091 PyObject *pyobj;
19092
19093 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_BRUSH), SWIGTYPE_p_wxBrush, 0);
19094 return pyobj;
19095 }
19096
19097
19098 static int _wrap_TRANSPARENT_BRUSH_set(PyObject *) {
19099 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_BRUSH is read-only.");
19100 return 1;
19101 }
19102
19103
19104 static PyObject *_wrap_TRANSPARENT_BRUSH_get(void) {
19105 PyObject *pyobj;
19106
19107 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_BRUSH), SWIGTYPE_p_wxBrush, 0);
19108 return pyobj;
19109 }
19110
19111
19112 static int _wrap_CYAN_BRUSH_set(PyObject *) {
19113 PyErr_SetString(PyExc_TypeError,"Variable CYAN_BRUSH is read-only.");
19114 return 1;
19115 }
19116
19117
19118 static PyObject *_wrap_CYAN_BRUSH_get(void) {
19119 PyObject *pyobj;
19120
19121 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_BRUSH), SWIGTYPE_p_wxBrush, 0);
19122 return pyobj;
19123 }
19124
19125
19126 static int _wrap_RED_BRUSH_set(PyObject *) {
19127 PyErr_SetString(PyExc_TypeError,"Variable RED_BRUSH is read-only.");
19128 return 1;
19129 }
19130
19131
19132 static PyObject *_wrap_RED_BRUSH_get(void) {
19133 PyObject *pyobj;
19134
19135 pyobj = SWIG_NewPointerObj((void *)(wxRED_BRUSH), SWIGTYPE_p_wxBrush, 0);
19136 return pyobj;
19137 }
19138
19139
19140 static int _wrap_GREY_BRUSH_set(PyObject *) {
19141 PyErr_SetString(PyExc_TypeError,"Variable GREY_BRUSH is read-only.");
19142 return 1;
19143 }
19144
19145
19146 static PyObject *_wrap_GREY_BRUSH_get(void) {
19147 PyObject *pyobj;
19148
19149 pyobj = SWIG_NewPointerObj((void *)(wxGREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19150 return pyobj;
19151 }
19152
19153
19154 static int _wrap_MEDIUM_GREY_BRUSH_set(PyObject *) {
19155 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_BRUSH is read-only.");
19156 return 1;
19157 }
19158
19159
19160 static PyObject *_wrap_MEDIUM_GREY_BRUSH_get(void) {
19161 PyObject *pyobj;
19162
19163 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19164 return pyobj;
19165 }
19166
19167
19168 static int _wrap_LIGHT_GREY_BRUSH_set(PyObject *) {
19169 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_BRUSH is read-only.");
19170 return 1;
19171 }
19172
19173
19174 static PyObject *_wrap_LIGHT_GREY_BRUSH_get(void) {
19175 PyObject *pyobj;
19176
19177 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19178 return pyobj;
19179 }
19180
19181
19182 static int _wrap_BLACK_set(PyObject *) {
19183 PyErr_SetString(PyExc_TypeError,"Variable BLACK is read-only.");
19184 return 1;
19185 }
19186
19187
19188 static PyObject *_wrap_BLACK_get(void) {
19189 PyObject *pyobj;
19190
19191 pyobj = SWIG_NewPointerObj((void *)(wxBLACK), SWIGTYPE_p_wxColour, 0);
19192 return pyobj;
19193 }
19194
19195
19196 static int _wrap_WHITE_set(PyObject *) {
19197 PyErr_SetString(PyExc_TypeError,"Variable WHITE is read-only.");
19198 return 1;
19199 }
19200
19201
19202 static PyObject *_wrap_WHITE_get(void) {
19203 PyObject *pyobj;
19204
19205 pyobj = SWIG_NewPointerObj((void *)(wxWHITE), SWIGTYPE_p_wxColour, 0);
19206 return pyobj;
19207 }
19208
19209
19210 static int _wrap_RED_set(PyObject *) {
19211 PyErr_SetString(PyExc_TypeError,"Variable RED is read-only.");
19212 return 1;
19213 }
19214
19215
19216 static PyObject *_wrap_RED_get(void) {
19217 PyObject *pyobj;
19218
19219 pyobj = SWIG_NewPointerObj((void *)(wxRED), SWIGTYPE_p_wxColour, 0);
19220 return pyobj;
19221 }
19222
19223
19224 static int _wrap_BLUE_set(PyObject *) {
19225 PyErr_SetString(PyExc_TypeError,"Variable BLUE is read-only.");
19226 return 1;
19227 }
19228
19229
19230 static PyObject *_wrap_BLUE_get(void) {
19231 PyObject *pyobj;
19232
19233 pyobj = SWIG_NewPointerObj((void *)(wxBLUE), SWIGTYPE_p_wxColour, 0);
19234 return pyobj;
19235 }
19236
19237
19238 static int _wrap_GREEN_set(PyObject *) {
19239 PyErr_SetString(PyExc_TypeError,"Variable GREEN is read-only.");
19240 return 1;
19241 }
19242
19243
19244 static PyObject *_wrap_GREEN_get(void) {
19245 PyObject *pyobj;
19246
19247 pyobj = SWIG_NewPointerObj((void *)(wxGREEN), SWIGTYPE_p_wxColour, 0);
19248 return pyobj;
19249 }
19250
19251
19252 static int _wrap_CYAN_set(PyObject *) {
19253 PyErr_SetString(PyExc_TypeError,"Variable CYAN is read-only.");
19254 return 1;
19255 }
19256
19257
19258 static PyObject *_wrap_CYAN_get(void) {
19259 PyObject *pyobj;
19260
19261 pyobj = SWIG_NewPointerObj((void *)(wxCYAN), SWIGTYPE_p_wxColour, 0);
19262 return pyobj;
19263 }
19264
19265
19266 static int _wrap_LIGHT_GREY_set(PyObject *) {
19267 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY is read-only.");
19268 return 1;
19269 }
19270
19271
19272 static PyObject *_wrap_LIGHT_GREY_get(void) {
19273 PyObject *pyobj;
19274
19275 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY), SWIGTYPE_p_wxColour, 0);
19276 return pyobj;
19277 }
19278
19279
19280 static int _wrap_STANDARD_CURSOR_set(PyObject *) {
19281 PyErr_SetString(PyExc_TypeError,"Variable STANDARD_CURSOR is read-only.");
19282 return 1;
19283 }
19284
19285
19286 static PyObject *_wrap_STANDARD_CURSOR_get(void) {
19287 PyObject *pyobj;
19288
19289 pyobj = SWIG_NewPointerObj((void *)(wxSTANDARD_CURSOR), SWIGTYPE_p_wxCursor, 0);
19290 return pyobj;
19291 }
19292
19293
19294 static int _wrap_HOURGLASS_CURSOR_set(PyObject *) {
19295 PyErr_SetString(PyExc_TypeError,"Variable HOURGLASS_CURSOR is read-only.");
19296 return 1;
19297 }
19298
19299
19300 static PyObject *_wrap_HOURGLASS_CURSOR_get(void) {
19301 PyObject *pyobj;
19302
19303 pyobj = SWIG_NewPointerObj((void *)(wxHOURGLASS_CURSOR), SWIGTYPE_p_wxCursor, 0);
19304 return pyobj;
19305 }
19306
19307
19308 static int _wrap_CROSS_CURSOR_set(PyObject *) {
19309 PyErr_SetString(PyExc_TypeError,"Variable CROSS_CURSOR is read-only.");
19310 return 1;
19311 }
19312
19313
19314 static PyObject *_wrap_CROSS_CURSOR_get(void) {
19315 PyObject *pyobj;
19316
19317 pyobj = SWIG_NewPointerObj((void *)(wxCROSS_CURSOR), SWIGTYPE_p_wxCursor, 0);
19318 return pyobj;
19319 }
19320
19321
19322 static int _wrap_NullBitmap_set(PyObject *) {
19323 PyErr_SetString(PyExc_TypeError,"Variable NullBitmap is read-only.");
19324 return 1;
19325 }
19326
19327
19328 static PyObject *_wrap_NullBitmap_get(void) {
19329 PyObject *pyobj;
19330
19331 pyobj = SWIG_NewPointerObj((void *)(&wxNullBitmap), SWIGTYPE_p_wxBitmap, 0);
19332 return pyobj;
19333 }
19334
19335
19336 static int _wrap_NullIcon_set(PyObject *) {
19337 PyErr_SetString(PyExc_TypeError,"Variable NullIcon is read-only.");
19338 return 1;
19339 }
19340
19341
19342 static PyObject *_wrap_NullIcon_get(void) {
19343 PyObject *pyobj;
19344
19345 pyobj = SWIG_NewPointerObj((void *)(&wxNullIcon), SWIGTYPE_p_wxIcon, 0);
19346 return pyobj;
19347 }
19348
19349
19350 static int _wrap_NullCursor_set(PyObject *) {
19351 PyErr_SetString(PyExc_TypeError,"Variable NullCursor is read-only.");
19352 return 1;
19353 }
19354
19355
19356 static PyObject *_wrap_NullCursor_get(void) {
19357 PyObject *pyobj;
19358
19359 pyobj = SWIG_NewPointerObj((void *)(&wxNullCursor), SWIGTYPE_p_wxCursor, 0);
19360 return pyobj;
19361 }
19362
19363
19364 static int _wrap_NullPen_set(PyObject *) {
19365 PyErr_SetString(PyExc_TypeError,"Variable NullPen is read-only.");
19366 return 1;
19367 }
19368
19369
19370 static PyObject *_wrap_NullPen_get(void) {
19371 PyObject *pyobj;
19372
19373 pyobj = SWIG_NewPointerObj((void *)(&wxNullPen), SWIGTYPE_p_wxPen, 0);
19374 return pyobj;
19375 }
19376
19377
19378 static int _wrap_NullBrush_set(PyObject *) {
19379 PyErr_SetString(PyExc_TypeError,"Variable NullBrush is read-only.");
19380 return 1;
19381 }
19382
19383
19384 static PyObject *_wrap_NullBrush_get(void) {
19385 PyObject *pyobj;
19386
19387 pyobj = SWIG_NewPointerObj((void *)(&wxNullBrush), SWIGTYPE_p_wxBrush, 0);
19388 return pyobj;
19389 }
19390
19391
19392 static int _wrap_NullPalette_set(PyObject *) {
19393 PyErr_SetString(PyExc_TypeError,"Variable NullPalette is read-only.");
19394 return 1;
19395 }
19396
19397
19398 static PyObject *_wrap_NullPalette_get(void) {
19399 PyObject *pyobj;
19400
19401 pyobj = SWIG_NewPointerObj((void *)(&wxNullPalette), SWIGTYPE_p_wxPalette, 0);
19402 return pyobj;
19403 }
19404
19405
19406 static int _wrap_NullFont_set(PyObject *) {
19407 PyErr_SetString(PyExc_TypeError,"Variable NullFont is read-only.");
19408 return 1;
19409 }
19410
19411
19412 static PyObject *_wrap_NullFont_get(void) {
19413 PyObject *pyobj;
19414
19415 pyobj = SWIG_NewPointerObj((void *)(&wxNullFont), SWIGTYPE_p_wxFont, 0);
19416 return pyobj;
19417 }
19418
19419
19420 static int _wrap_NullColour_set(PyObject *) {
19421 PyErr_SetString(PyExc_TypeError,"Variable NullColour is read-only.");
19422 return 1;
19423 }
19424
19425
19426 static PyObject *_wrap_NullColour_get(void) {
19427 PyObject *pyobj;
19428
19429 pyobj = SWIG_NewPointerObj((void *)(&wxNullColour), SWIGTYPE_p_wxColour, 0);
19430 return pyobj;
19431 }
19432
19433
19434 static PyObject *_wrap_PenList_AddPen(PyObject *, PyObject *args, PyObject *kwargs) {
19435 PyObject *resultobj;
19436 wxPenList *arg1 = (wxPenList *) 0 ;
19437 wxPen *arg2 = (wxPen *) 0 ;
19438 PyObject * obj0 = 0 ;
19439 PyObject * obj1 = 0 ;
19440 char *kwnames[] = {
19441 (char *) "self",(char *) "pen", NULL
19442 };
19443
19444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_AddPen",kwnames,&obj0,&obj1)) goto fail;
19445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19446 if (SWIG_arg_fail(1)) SWIG_fail;
19447 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
19448 if (SWIG_arg_fail(2)) SWIG_fail;
19449 {
19450 PyThreadState* __tstate = wxPyBeginAllowThreads();
19451 (arg1)->AddPen(arg2);
19452
19453 wxPyEndAllowThreads(__tstate);
19454 if (PyErr_Occurred()) SWIG_fail;
19455 }
19456 Py_INCREF(Py_None); resultobj = Py_None;
19457 return resultobj;
19458 fail:
19459 return NULL;
19460 }
19461
19462
19463 static PyObject *_wrap_PenList_FindOrCreatePen(PyObject *, PyObject *args, PyObject *kwargs) {
19464 PyObject *resultobj;
19465 wxPenList *arg1 = (wxPenList *) 0 ;
19466 wxColour *arg2 = 0 ;
19467 int arg3 ;
19468 int arg4 ;
19469 wxPen *result;
19470 wxColour temp2 ;
19471 PyObject * obj0 = 0 ;
19472 PyObject * obj1 = 0 ;
19473 PyObject * obj2 = 0 ;
19474 PyObject * obj3 = 0 ;
19475 char *kwnames[] = {
19476 (char *) "self",(char *) "colour",(char *) "width",(char *) "style", NULL
19477 };
19478
19479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PenList_FindOrCreatePen",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19481 if (SWIG_arg_fail(1)) SWIG_fail;
19482 {
19483 arg2 = &temp2;
19484 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19485 }
19486 {
19487 arg3 = (int)(SWIG_As_int(obj2));
19488 if (SWIG_arg_fail(3)) SWIG_fail;
19489 }
19490 {
19491 arg4 = (int)(SWIG_As_int(obj3));
19492 if (SWIG_arg_fail(4)) SWIG_fail;
19493 }
19494 {
19495 PyThreadState* __tstate = wxPyBeginAllowThreads();
19496 result = (wxPen *)(arg1)->FindOrCreatePen((wxColour const &)*arg2,arg3,arg4);
19497
19498 wxPyEndAllowThreads(__tstate);
19499 if (PyErr_Occurred()) SWIG_fail;
19500 }
19501 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 0);
19502 return resultobj;
19503 fail:
19504 return NULL;
19505 }
19506
19507
19508 static PyObject *_wrap_PenList_RemovePen(PyObject *, PyObject *args, PyObject *kwargs) {
19509 PyObject *resultobj;
19510 wxPenList *arg1 = (wxPenList *) 0 ;
19511 wxPen *arg2 = (wxPen *) 0 ;
19512 PyObject * obj0 = 0 ;
19513 PyObject * obj1 = 0 ;
19514 char *kwnames[] = {
19515 (char *) "self",(char *) "pen", NULL
19516 };
19517
19518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_RemovePen",kwnames,&obj0,&obj1)) goto fail;
19519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19520 if (SWIG_arg_fail(1)) SWIG_fail;
19521 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
19522 if (SWIG_arg_fail(2)) SWIG_fail;
19523 {
19524 PyThreadState* __tstate = wxPyBeginAllowThreads();
19525 (arg1)->RemovePen(arg2);
19526
19527 wxPyEndAllowThreads(__tstate);
19528 if (PyErr_Occurred()) SWIG_fail;
19529 }
19530 Py_INCREF(Py_None); resultobj = Py_None;
19531 return resultobj;
19532 fail:
19533 return NULL;
19534 }
19535
19536
19537 static PyObject *_wrap_PenList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
19538 PyObject *resultobj;
19539 wxPenList *arg1 = (wxPenList *) 0 ;
19540 int result;
19541 PyObject * obj0 = 0 ;
19542 char *kwnames[] = {
19543 (char *) "self", NULL
19544 };
19545
19546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PenList_GetCount",kwnames,&obj0)) goto fail;
19547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19548 if (SWIG_arg_fail(1)) SWIG_fail;
19549 {
19550 PyThreadState* __tstate = wxPyBeginAllowThreads();
19551 result = (int)(arg1)->GetCount();
19552
19553 wxPyEndAllowThreads(__tstate);
19554 if (PyErr_Occurred()) SWIG_fail;
19555 }
19556 {
19557 resultobj = SWIG_From_int((int)(result));
19558 }
19559 return resultobj;
19560 fail:
19561 return NULL;
19562 }
19563
19564
19565 static PyObject * PenList_swigregister(PyObject *, PyObject *args) {
19566 PyObject *obj;
19567 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19568 SWIG_TypeClientData(SWIGTYPE_p_wxPenList, obj);
19569 Py_INCREF(obj);
19570 return Py_BuildValue((char *)"");
19571 }
19572 static PyObject *_wrap_BrushList_AddBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19573 PyObject *resultobj;
19574 wxBrushList *arg1 = (wxBrushList *) 0 ;
19575 wxBrush *arg2 = (wxBrush *) 0 ;
19576 PyObject * obj0 = 0 ;
19577 PyObject * obj1 = 0 ;
19578 char *kwnames[] = {
19579 (char *) "self",(char *) "brush", NULL
19580 };
19581
19582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_AddBrush",kwnames,&obj0,&obj1)) goto fail;
19583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19584 if (SWIG_arg_fail(1)) SWIG_fail;
19585 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
19586 if (SWIG_arg_fail(2)) SWIG_fail;
19587 {
19588 PyThreadState* __tstate = wxPyBeginAllowThreads();
19589 (arg1)->AddBrush(arg2);
19590
19591 wxPyEndAllowThreads(__tstate);
19592 if (PyErr_Occurred()) SWIG_fail;
19593 }
19594 Py_INCREF(Py_None); resultobj = Py_None;
19595 return resultobj;
19596 fail:
19597 return NULL;
19598 }
19599
19600
19601 static PyObject *_wrap_BrushList_FindOrCreateBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19602 PyObject *resultobj;
19603 wxBrushList *arg1 = (wxBrushList *) 0 ;
19604 wxColour *arg2 = 0 ;
19605 int arg3 ;
19606 wxBrush *result;
19607 wxColour temp2 ;
19608 PyObject * obj0 = 0 ;
19609 PyObject * obj1 = 0 ;
19610 PyObject * obj2 = 0 ;
19611 char *kwnames[] = {
19612 (char *) "self",(char *) "colour",(char *) "style", NULL
19613 };
19614
19615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:BrushList_FindOrCreateBrush",kwnames,&obj0,&obj1,&obj2)) goto fail;
19616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19617 if (SWIG_arg_fail(1)) SWIG_fail;
19618 {
19619 arg2 = &temp2;
19620 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19621 }
19622 {
19623 arg3 = (int)(SWIG_As_int(obj2));
19624 if (SWIG_arg_fail(3)) SWIG_fail;
19625 }
19626 {
19627 PyThreadState* __tstate = wxPyBeginAllowThreads();
19628 result = (wxBrush *)(arg1)->FindOrCreateBrush((wxColour const &)*arg2,arg3);
19629
19630 wxPyEndAllowThreads(__tstate);
19631 if (PyErr_Occurred()) SWIG_fail;
19632 }
19633 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 0);
19634 return resultobj;
19635 fail:
19636 return NULL;
19637 }
19638
19639
19640 static PyObject *_wrap_BrushList_RemoveBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19641 PyObject *resultobj;
19642 wxBrushList *arg1 = (wxBrushList *) 0 ;
19643 wxBrush *arg2 = (wxBrush *) 0 ;
19644 PyObject * obj0 = 0 ;
19645 PyObject * obj1 = 0 ;
19646 char *kwnames[] = {
19647 (char *) "self",(char *) "brush", NULL
19648 };
19649
19650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_RemoveBrush",kwnames,&obj0,&obj1)) goto fail;
19651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19652 if (SWIG_arg_fail(1)) SWIG_fail;
19653 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
19654 if (SWIG_arg_fail(2)) SWIG_fail;
19655 {
19656 PyThreadState* __tstate = wxPyBeginAllowThreads();
19657 (arg1)->RemoveBrush(arg2);
19658
19659 wxPyEndAllowThreads(__tstate);
19660 if (PyErr_Occurred()) SWIG_fail;
19661 }
19662 Py_INCREF(Py_None); resultobj = Py_None;
19663 return resultobj;
19664 fail:
19665 return NULL;
19666 }
19667
19668
19669 static PyObject *_wrap_BrushList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
19670 PyObject *resultobj;
19671 wxBrushList *arg1 = (wxBrushList *) 0 ;
19672 int result;
19673 PyObject * obj0 = 0 ;
19674 char *kwnames[] = {
19675 (char *) "self", NULL
19676 };
19677
19678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BrushList_GetCount",kwnames,&obj0)) goto fail;
19679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19680 if (SWIG_arg_fail(1)) SWIG_fail;
19681 {
19682 PyThreadState* __tstate = wxPyBeginAllowThreads();
19683 result = (int)(arg1)->GetCount();
19684
19685 wxPyEndAllowThreads(__tstate);
19686 if (PyErr_Occurred()) SWIG_fail;
19687 }
19688 {
19689 resultobj = SWIG_From_int((int)(result));
19690 }
19691 return resultobj;
19692 fail:
19693 return NULL;
19694 }
19695
19696
19697 static PyObject * BrushList_swigregister(PyObject *, PyObject *args) {
19698 PyObject *obj;
19699 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19700 SWIG_TypeClientData(SWIGTYPE_p_wxBrushList, obj);
19701 Py_INCREF(obj);
19702 return Py_BuildValue((char *)"");
19703 }
19704 static PyObject *_wrap_new_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
19705 PyObject *resultobj;
19706 wxColourDatabase *result;
19707 char *kwnames[] = {
19708 NULL
19709 };
19710
19711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ColourDatabase",kwnames)) goto fail;
19712 {
19713 if (!wxPyCheckForApp()) SWIG_fail;
19714 PyThreadState* __tstate = wxPyBeginAllowThreads();
19715 result = (wxColourDatabase *)new wxColourDatabase();
19716
19717 wxPyEndAllowThreads(__tstate);
19718 if (PyErr_Occurred()) SWIG_fail;
19719 }
19720 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColourDatabase, 1);
19721 return resultobj;
19722 fail:
19723 return NULL;
19724 }
19725
19726
19727 static PyObject *_wrap_delete_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
19728 PyObject *resultobj;
19729 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19730 PyObject * obj0 = 0 ;
19731 char *kwnames[] = {
19732 (char *) "self", NULL
19733 };
19734
19735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ColourDatabase",kwnames,&obj0)) goto fail;
19736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19737 if (SWIG_arg_fail(1)) SWIG_fail;
19738 {
19739 PyThreadState* __tstate = wxPyBeginAllowThreads();
19740 delete arg1;
19741
19742 wxPyEndAllowThreads(__tstate);
19743 if (PyErr_Occurred()) SWIG_fail;
19744 }
19745 Py_INCREF(Py_None); resultobj = Py_None;
19746 return resultobj;
19747 fail:
19748 return NULL;
19749 }
19750
19751
19752 static PyObject *_wrap_ColourDatabase_Find(PyObject *, PyObject *args, PyObject *kwargs) {
19753 PyObject *resultobj;
19754 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19755 wxString *arg2 = 0 ;
19756 wxColour result;
19757 bool temp2 = false ;
19758 PyObject * obj0 = 0 ;
19759 PyObject * obj1 = 0 ;
19760 char *kwnames[] = {
19761 (char *) "self",(char *) "name", NULL
19762 };
19763
19764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_Find",kwnames,&obj0,&obj1)) goto fail;
19765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19766 if (SWIG_arg_fail(1)) SWIG_fail;
19767 {
19768 arg2 = wxString_in_helper(obj1);
19769 if (arg2 == NULL) SWIG_fail;
19770 temp2 = true;
19771 }
19772 {
19773 PyThreadState* __tstate = wxPyBeginAllowThreads();
19774 result = ((wxColourDatabase const *)arg1)->Find((wxString const &)*arg2);
19775
19776 wxPyEndAllowThreads(__tstate);
19777 if (PyErr_Occurred()) SWIG_fail;
19778 }
19779 {
19780 wxColour * resultptr;
19781 resultptr = new wxColour((wxColour &)(result));
19782 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
19783 }
19784 {
19785 if (temp2)
19786 delete arg2;
19787 }
19788 return resultobj;
19789 fail:
19790 {
19791 if (temp2)
19792 delete arg2;
19793 }
19794 return NULL;
19795 }
19796
19797
19798 static PyObject *_wrap_ColourDatabase_FindName(PyObject *, PyObject *args, PyObject *kwargs) {
19799 PyObject *resultobj;
19800 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19801 wxColour *arg2 = 0 ;
19802 wxString result;
19803 wxColour temp2 ;
19804 PyObject * obj0 = 0 ;
19805 PyObject * obj1 = 0 ;
19806 char *kwnames[] = {
19807 (char *) "self",(char *) "colour", NULL
19808 };
19809
19810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_FindName",kwnames,&obj0,&obj1)) goto fail;
19811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19812 if (SWIG_arg_fail(1)) SWIG_fail;
19813 {
19814 arg2 = &temp2;
19815 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19816 }
19817 {
19818 PyThreadState* __tstate = wxPyBeginAllowThreads();
19819 result = ((wxColourDatabase const *)arg1)->FindName((wxColour const &)*arg2);
19820
19821 wxPyEndAllowThreads(__tstate);
19822 if (PyErr_Occurred()) SWIG_fail;
19823 }
19824 {
19825 #if wxUSE_UNICODE
19826 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19827 #else
19828 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19829 #endif
19830 }
19831 return resultobj;
19832 fail:
19833 return NULL;
19834 }
19835
19836
19837 static PyObject *_wrap_ColourDatabase_AddColour(PyObject *, PyObject *args, PyObject *kwargs) {
19838 PyObject *resultobj;
19839 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19840 wxString *arg2 = 0 ;
19841 wxColour *arg3 = 0 ;
19842 bool temp2 = false ;
19843 wxColour temp3 ;
19844 PyObject * obj0 = 0 ;
19845 PyObject * obj1 = 0 ;
19846 PyObject * obj2 = 0 ;
19847 char *kwnames[] = {
19848 (char *) "self",(char *) "name",(char *) "colour", NULL
19849 };
19850
19851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ColourDatabase_AddColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
19852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19853 if (SWIG_arg_fail(1)) SWIG_fail;
19854 {
19855 arg2 = wxString_in_helper(obj1);
19856 if (arg2 == NULL) SWIG_fail;
19857 temp2 = true;
19858 }
19859 {
19860 arg3 = &temp3;
19861 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
19862 }
19863 {
19864 PyThreadState* __tstate = wxPyBeginAllowThreads();
19865 (arg1)->AddColour((wxString const &)*arg2,(wxColour const &)*arg3);
19866
19867 wxPyEndAllowThreads(__tstate);
19868 if (PyErr_Occurred()) SWIG_fail;
19869 }
19870 Py_INCREF(Py_None); resultobj = Py_None;
19871 {
19872 if (temp2)
19873 delete arg2;
19874 }
19875 return resultobj;
19876 fail:
19877 {
19878 if (temp2)
19879 delete arg2;
19880 }
19881 return NULL;
19882 }
19883
19884
19885 static PyObject *_wrap_ColourDatabase_Append(PyObject *, PyObject *args, PyObject *kwargs) {
19886 PyObject *resultobj;
19887 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19888 wxString *arg2 = 0 ;
19889 int arg3 ;
19890 int arg4 ;
19891 int arg5 ;
19892 bool temp2 = false ;
19893 PyObject * obj0 = 0 ;
19894 PyObject * obj1 = 0 ;
19895 PyObject * obj2 = 0 ;
19896 PyObject * obj3 = 0 ;
19897 PyObject * obj4 = 0 ;
19898 char *kwnames[] = {
19899 (char *) "self",(char *) "name",(char *) "red",(char *) "green",(char *) "blue", NULL
19900 };
19901
19902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:ColourDatabase_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19904 if (SWIG_arg_fail(1)) SWIG_fail;
19905 {
19906 arg2 = wxString_in_helper(obj1);
19907 if (arg2 == NULL) SWIG_fail;
19908 temp2 = true;
19909 }
19910 {
19911 arg3 = (int)(SWIG_As_int(obj2));
19912 if (SWIG_arg_fail(3)) SWIG_fail;
19913 }
19914 {
19915 arg4 = (int)(SWIG_As_int(obj3));
19916 if (SWIG_arg_fail(4)) SWIG_fail;
19917 }
19918 {
19919 arg5 = (int)(SWIG_As_int(obj4));
19920 if (SWIG_arg_fail(5)) SWIG_fail;
19921 }
19922 {
19923 PyThreadState* __tstate = wxPyBeginAllowThreads();
19924 wxColourDatabase_Append(arg1,(wxString const &)*arg2,arg3,arg4,arg5);
19925
19926 wxPyEndAllowThreads(__tstate);
19927 if (PyErr_Occurred()) SWIG_fail;
19928 }
19929 Py_INCREF(Py_None); resultobj = Py_None;
19930 {
19931 if (temp2)
19932 delete arg2;
19933 }
19934 return resultobj;
19935 fail:
19936 {
19937 if (temp2)
19938 delete arg2;
19939 }
19940 return NULL;
19941 }
19942
19943
19944 static PyObject * ColourDatabase_swigregister(PyObject *, PyObject *args) {
19945 PyObject *obj;
19946 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19947 SWIG_TypeClientData(SWIGTYPE_p_wxColourDatabase, obj);
19948 Py_INCREF(obj);
19949 return Py_BuildValue((char *)"");
19950 }
19951 static PyObject *_wrap_FontList_AddFont(PyObject *, PyObject *args, PyObject *kwargs) {
19952 PyObject *resultobj;
19953 wxFontList *arg1 = (wxFontList *) 0 ;
19954 wxFont *arg2 = (wxFont *) 0 ;
19955 PyObject * obj0 = 0 ;
19956 PyObject * obj1 = 0 ;
19957 char *kwnames[] = {
19958 (char *) "self",(char *) "font", NULL
19959 };
19960
19961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_AddFont",kwnames,&obj0,&obj1)) goto fail;
19962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
19963 if (SWIG_arg_fail(1)) SWIG_fail;
19964 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
19965 if (SWIG_arg_fail(2)) SWIG_fail;
19966 {
19967 PyThreadState* __tstate = wxPyBeginAllowThreads();
19968 (arg1)->AddFont(arg2);
19969
19970 wxPyEndAllowThreads(__tstate);
19971 if (PyErr_Occurred()) SWIG_fail;
19972 }
19973 Py_INCREF(Py_None); resultobj = Py_None;
19974 return resultobj;
19975 fail:
19976 return NULL;
19977 }
19978
19979
19980 static PyObject *_wrap_FontList_FindOrCreateFont(PyObject *, PyObject *args, PyObject *kwargs) {
19981 PyObject *resultobj;
19982 wxFontList *arg1 = (wxFontList *) 0 ;
19983 int arg2 ;
19984 int arg3 ;
19985 int arg4 ;
19986 int arg5 ;
19987 bool arg6 = (bool) false ;
19988 wxString const &arg7_defvalue = wxPyEmptyString ;
19989 wxString *arg7 = (wxString *) &arg7_defvalue ;
19990 wxFontEncoding arg8 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
19991 wxFont *result;
19992 bool temp7 = false ;
19993 PyObject * obj0 = 0 ;
19994 PyObject * obj1 = 0 ;
19995 PyObject * obj2 = 0 ;
19996 PyObject * obj3 = 0 ;
19997 PyObject * obj4 = 0 ;
19998 PyObject * obj5 = 0 ;
19999 PyObject * obj6 = 0 ;
20000 PyObject * obj7 = 0 ;
20001 char *kwnames[] = {
20002 (char *) "self",(char *) "point_size",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "facename",(char *) "encoding", NULL
20003 };
20004
20005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:FontList_FindOrCreateFont",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
20006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20007 if (SWIG_arg_fail(1)) SWIG_fail;
20008 {
20009 arg2 = (int)(SWIG_As_int(obj1));
20010 if (SWIG_arg_fail(2)) SWIG_fail;
20011 }
20012 {
20013 arg3 = (int)(SWIG_As_int(obj2));
20014 if (SWIG_arg_fail(3)) SWIG_fail;
20015 }
20016 {
20017 arg4 = (int)(SWIG_As_int(obj3));
20018 if (SWIG_arg_fail(4)) SWIG_fail;
20019 }
20020 {
20021 arg5 = (int)(SWIG_As_int(obj4));
20022 if (SWIG_arg_fail(5)) SWIG_fail;
20023 }
20024 if (obj5) {
20025 {
20026 arg6 = (bool)(SWIG_As_bool(obj5));
20027 if (SWIG_arg_fail(6)) SWIG_fail;
20028 }
20029 }
20030 if (obj6) {
20031 {
20032 arg7 = wxString_in_helper(obj6);
20033 if (arg7 == NULL) SWIG_fail;
20034 temp7 = true;
20035 }
20036 }
20037 if (obj7) {
20038 {
20039 arg8 = (wxFontEncoding)(SWIG_As_int(obj7));
20040 if (SWIG_arg_fail(8)) SWIG_fail;
20041 }
20042 }
20043 {
20044 PyThreadState* __tstate = wxPyBeginAllowThreads();
20045 result = (wxFont *)(arg1)->FindOrCreateFont(arg2,arg3,arg4,arg5,arg6,(wxString const &)*arg7,(wxFontEncoding )arg8);
20046
20047 wxPyEndAllowThreads(__tstate);
20048 if (PyErr_Occurred()) SWIG_fail;
20049 }
20050 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
20051 {
20052 if (temp7)
20053 delete arg7;
20054 }
20055 return resultobj;
20056 fail:
20057 {
20058 if (temp7)
20059 delete arg7;
20060 }
20061 return NULL;
20062 }
20063
20064
20065 static PyObject *_wrap_FontList_RemoveFont(PyObject *, PyObject *args, PyObject *kwargs) {
20066 PyObject *resultobj;
20067 wxFontList *arg1 = (wxFontList *) 0 ;
20068 wxFont *arg2 = (wxFont *) 0 ;
20069 PyObject * obj0 = 0 ;
20070 PyObject * obj1 = 0 ;
20071 char *kwnames[] = {
20072 (char *) "self",(char *) "font", NULL
20073 };
20074
20075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_RemoveFont",kwnames,&obj0,&obj1)) goto fail;
20076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20077 if (SWIG_arg_fail(1)) SWIG_fail;
20078 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
20079 if (SWIG_arg_fail(2)) SWIG_fail;
20080 {
20081 PyThreadState* __tstate = wxPyBeginAllowThreads();
20082 (arg1)->RemoveFont(arg2);
20083
20084 wxPyEndAllowThreads(__tstate);
20085 if (PyErr_Occurred()) SWIG_fail;
20086 }
20087 Py_INCREF(Py_None); resultobj = Py_None;
20088 return resultobj;
20089 fail:
20090 return NULL;
20091 }
20092
20093
20094 static PyObject *_wrap_FontList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
20095 PyObject *resultobj;
20096 wxFontList *arg1 = (wxFontList *) 0 ;
20097 int result;
20098 PyObject * obj0 = 0 ;
20099 char *kwnames[] = {
20100 (char *) "self", NULL
20101 };
20102
20103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontList_GetCount",kwnames,&obj0)) goto fail;
20104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20105 if (SWIG_arg_fail(1)) SWIG_fail;
20106 {
20107 PyThreadState* __tstate = wxPyBeginAllowThreads();
20108 result = (int)(arg1)->GetCount();
20109
20110 wxPyEndAllowThreads(__tstate);
20111 if (PyErr_Occurred()) SWIG_fail;
20112 }
20113 {
20114 resultobj = SWIG_From_int((int)(result));
20115 }
20116 return resultobj;
20117 fail:
20118 return NULL;
20119 }
20120
20121
20122 static PyObject * FontList_swigregister(PyObject *, PyObject *args) {
20123 PyObject *obj;
20124 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20125 SWIG_TypeClientData(SWIGTYPE_p_wxFontList, obj);
20126 Py_INCREF(obj);
20127 return Py_BuildValue((char *)"");
20128 }
20129 static int _wrap_TheFontList_set(PyObject *) {
20130 PyErr_SetString(PyExc_TypeError,"Variable TheFontList is read-only.");
20131 return 1;
20132 }
20133
20134
20135 static PyObject *_wrap_TheFontList_get(void) {
20136 PyObject *pyobj;
20137
20138 pyobj = SWIG_NewPointerObj((void *)(wxTheFontList), SWIGTYPE_p_wxFontList, 0);
20139 return pyobj;
20140 }
20141
20142
20143 static int _wrap_ThePenList_set(PyObject *) {
20144 PyErr_SetString(PyExc_TypeError,"Variable ThePenList is read-only.");
20145 return 1;
20146 }
20147
20148
20149 static PyObject *_wrap_ThePenList_get(void) {
20150 PyObject *pyobj;
20151
20152 pyobj = SWIG_NewPointerObj((void *)(wxThePenList), SWIGTYPE_p_wxPenList, 0);
20153 return pyobj;
20154 }
20155
20156
20157 static int _wrap_TheBrushList_set(PyObject *) {
20158 PyErr_SetString(PyExc_TypeError,"Variable TheBrushList is read-only.");
20159 return 1;
20160 }
20161
20162
20163 static PyObject *_wrap_TheBrushList_get(void) {
20164 PyObject *pyobj;
20165
20166 pyobj = SWIG_NewPointerObj((void *)(wxTheBrushList), SWIGTYPE_p_wxBrushList, 0);
20167 return pyobj;
20168 }
20169
20170
20171 static int _wrap_TheColourDatabase_set(PyObject *) {
20172 PyErr_SetString(PyExc_TypeError,"Variable TheColourDatabase is read-only.");
20173 return 1;
20174 }
20175
20176
20177 static PyObject *_wrap_TheColourDatabase_get(void) {
20178 PyObject *pyobj;
20179
20180 pyobj = SWIG_NewPointerObj((void *)(wxTheColourDatabase), SWIGTYPE_p_wxColourDatabase, 0);
20181 return pyobj;
20182 }
20183
20184
20185 static PyObject *_wrap_new_Effects(PyObject *, PyObject *args, PyObject *kwargs) {
20186 PyObject *resultobj;
20187 wxEffects *result;
20188 char *kwnames[] = {
20189 NULL
20190 };
20191
20192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Effects",kwnames)) goto fail;
20193 {
20194 PyThreadState* __tstate = wxPyBeginAllowThreads();
20195 result = (wxEffects *)new wxEffects();
20196
20197 wxPyEndAllowThreads(__tstate);
20198 if (PyErr_Occurred()) SWIG_fail;
20199 }
20200 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEffects, 1);
20201 return resultobj;
20202 fail:
20203 return NULL;
20204 }
20205
20206
20207 static PyObject *_wrap_Effects_GetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
20208 PyObject *resultobj;
20209 wxEffects *arg1 = (wxEffects *) 0 ;
20210 wxColour result;
20211 PyObject * obj0 = 0 ;
20212 char *kwnames[] = {
20213 (char *) "self", NULL
20214 };
20215
20216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetHighlightColour",kwnames,&obj0)) goto fail;
20217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20218 if (SWIG_arg_fail(1)) SWIG_fail;
20219 {
20220 PyThreadState* __tstate = wxPyBeginAllowThreads();
20221 result = ((wxEffects const *)arg1)->GetHighlightColour();
20222
20223 wxPyEndAllowThreads(__tstate);
20224 if (PyErr_Occurred()) SWIG_fail;
20225 }
20226 {
20227 wxColour * resultptr;
20228 resultptr = new wxColour((wxColour &)(result));
20229 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20230 }
20231 return resultobj;
20232 fail:
20233 return NULL;
20234 }
20235
20236
20237 static PyObject *_wrap_Effects_GetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20238 PyObject *resultobj;
20239 wxEffects *arg1 = (wxEffects *) 0 ;
20240 wxColour result;
20241 PyObject * obj0 = 0 ;
20242 char *kwnames[] = {
20243 (char *) "self", NULL
20244 };
20245
20246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetLightShadow",kwnames,&obj0)) goto fail;
20247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20248 if (SWIG_arg_fail(1)) SWIG_fail;
20249 {
20250 PyThreadState* __tstate = wxPyBeginAllowThreads();
20251 result = ((wxEffects const *)arg1)->GetLightShadow();
20252
20253 wxPyEndAllowThreads(__tstate);
20254 if (PyErr_Occurred()) SWIG_fail;
20255 }
20256 {
20257 wxColour * resultptr;
20258 resultptr = new wxColour((wxColour &)(result));
20259 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20260 }
20261 return resultobj;
20262 fail:
20263 return NULL;
20264 }
20265
20266
20267 static PyObject *_wrap_Effects_GetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
20268 PyObject *resultobj;
20269 wxEffects *arg1 = (wxEffects *) 0 ;
20270 wxColour result;
20271 PyObject * obj0 = 0 ;
20272 char *kwnames[] = {
20273 (char *) "self", NULL
20274 };
20275
20276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetFaceColour",kwnames,&obj0)) goto fail;
20277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20278 if (SWIG_arg_fail(1)) SWIG_fail;
20279 {
20280 PyThreadState* __tstate = wxPyBeginAllowThreads();
20281 result = ((wxEffects const *)arg1)->GetFaceColour();
20282
20283 wxPyEndAllowThreads(__tstate);
20284 if (PyErr_Occurred()) SWIG_fail;
20285 }
20286 {
20287 wxColour * resultptr;
20288 resultptr = new wxColour((wxColour &)(result));
20289 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20290 }
20291 return resultobj;
20292 fail:
20293 return NULL;
20294 }
20295
20296
20297 static PyObject *_wrap_Effects_GetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20298 PyObject *resultobj;
20299 wxEffects *arg1 = (wxEffects *) 0 ;
20300 wxColour result;
20301 PyObject * obj0 = 0 ;
20302 char *kwnames[] = {
20303 (char *) "self", NULL
20304 };
20305
20306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetMediumShadow",kwnames,&obj0)) goto fail;
20307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20308 if (SWIG_arg_fail(1)) SWIG_fail;
20309 {
20310 PyThreadState* __tstate = wxPyBeginAllowThreads();
20311 result = ((wxEffects const *)arg1)->GetMediumShadow();
20312
20313 wxPyEndAllowThreads(__tstate);
20314 if (PyErr_Occurred()) SWIG_fail;
20315 }
20316 {
20317 wxColour * resultptr;
20318 resultptr = new wxColour((wxColour &)(result));
20319 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20320 }
20321 return resultobj;
20322 fail:
20323 return NULL;
20324 }
20325
20326
20327 static PyObject *_wrap_Effects_GetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20328 PyObject *resultobj;
20329 wxEffects *arg1 = (wxEffects *) 0 ;
20330 wxColour result;
20331 PyObject * obj0 = 0 ;
20332 char *kwnames[] = {
20333 (char *) "self", NULL
20334 };
20335
20336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetDarkShadow",kwnames,&obj0)) goto fail;
20337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20338 if (SWIG_arg_fail(1)) SWIG_fail;
20339 {
20340 PyThreadState* __tstate = wxPyBeginAllowThreads();
20341 result = ((wxEffects const *)arg1)->GetDarkShadow();
20342
20343 wxPyEndAllowThreads(__tstate);
20344 if (PyErr_Occurred()) SWIG_fail;
20345 }
20346 {
20347 wxColour * resultptr;
20348 resultptr = new wxColour((wxColour &)(result));
20349 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20350 }
20351 return resultobj;
20352 fail:
20353 return NULL;
20354 }
20355
20356
20357 static PyObject *_wrap_Effects_SetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
20358 PyObject *resultobj;
20359 wxEffects *arg1 = (wxEffects *) 0 ;
20360 wxColour *arg2 = 0 ;
20361 wxColour temp2 ;
20362 PyObject * obj0 = 0 ;
20363 PyObject * obj1 = 0 ;
20364 char *kwnames[] = {
20365 (char *) "self",(char *) "c", NULL
20366 };
20367
20368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetHighlightColour",kwnames,&obj0,&obj1)) goto fail;
20369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20370 if (SWIG_arg_fail(1)) SWIG_fail;
20371 {
20372 arg2 = &temp2;
20373 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20374 }
20375 {
20376 PyThreadState* __tstate = wxPyBeginAllowThreads();
20377 (arg1)->SetHighlightColour((wxColour const &)*arg2);
20378
20379 wxPyEndAllowThreads(__tstate);
20380 if (PyErr_Occurred()) SWIG_fail;
20381 }
20382 Py_INCREF(Py_None); resultobj = Py_None;
20383 return resultobj;
20384 fail:
20385 return NULL;
20386 }
20387
20388
20389 static PyObject *_wrap_Effects_SetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20390 PyObject *resultobj;
20391 wxEffects *arg1 = (wxEffects *) 0 ;
20392 wxColour *arg2 = 0 ;
20393 wxColour temp2 ;
20394 PyObject * obj0 = 0 ;
20395 PyObject * obj1 = 0 ;
20396 char *kwnames[] = {
20397 (char *) "self",(char *) "c", NULL
20398 };
20399
20400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetLightShadow",kwnames,&obj0,&obj1)) goto fail;
20401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20402 if (SWIG_arg_fail(1)) SWIG_fail;
20403 {
20404 arg2 = &temp2;
20405 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20406 }
20407 {
20408 PyThreadState* __tstate = wxPyBeginAllowThreads();
20409 (arg1)->SetLightShadow((wxColour const &)*arg2);
20410
20411 wxPyEndAllowThreads(__tstate);
20412 if (PyErr_Occurred()) SWIG_fail;
20413 }
20414 Py_INCREF(Py_None); resultobj = Py_None;
20415 return resultobj;
20416 fail:
20417 return NULL;
20418 }
20419
20420
20421 static PyObject *_wrap_Effects_SetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
20422 PyObject *resultobj;
20423 wxEffects *arg1 = (wxEffects *) 0 ;
20424 wxColour *arg2 = 0 ;
20425 wxColour temp2 ;
20426 PyObject * obj0 = 0 ;
20427 PyObject * obj1 = 0 ;
20428 char *kwnames[] = {
20429 (char *) "self",(char *) "c", NULL
20430 };
20431
20432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetFaceColour",kwnames,&obj0,&obj1)) goto fail;
20433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20434 if (SWIG_arg_fail(1)) SWIG_fail;
20435 {
20436 arg2 = &temp2;
20437 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20438 }
20439 {
20440 PyThreadState* __tstate = wxPyBeginAllowThreads();
20441 (arg1)->SetFaceColour((wxColour const &)*arg2);
20442
20443 wxPyEndAllowThreads(__tstate);
20444 if (PyErr_Occurred()) SWIG_fail;
20445 }
20446 Py_INCREF(Py_None); resultobj = Py_None;
20447 return resultobj;
20448 fail:
20449 return NULL;
20450 }
20451
20452
20453 static PyObject *_wrap_Effects_SetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20454 PyObject *resultobj;
20455 wxEffects *arg1 = (wxEffects *) 0 ;
20456 wxColour *arg2 = 0 ;
20457 wxColour temp2 ;
20458 PyObject * obj0 = 0 ;
20459 PyObject * obj1 = 0 ;
20460 char *kwnames[] = {
20461 (char *) "self",(char *) "c", NULL
20462 };
20463
20464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetMediumShadow",kwnames,&obj0,&obj1)) goto fail;
20465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20466 if (SWIG_arg_fail(1)) SWIG_fail;
20467 {
20468 arg2 = &temp2;
20469 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20470 }
20471 {
20472 PyThreadState* __tstate = wxPyBeginAllowThreads();
20473 (arg1)->SetMediumShadow((wxColour const &)*arg2);
20474
20475 wxPyEndAllowThreads(__tstate);
20476 if (PyErr_Occurred()) SWIG_fail;
20477 }
20478 Py_INCREF(Py_None); resultobj = Py_None;
20479 return resultobj;
20480 fail:
20481 return NULL;
20482 }
20483
20484
20485 static PyObject *_wrap_Effects_SetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20486 PyObject *resultobj;
20487 wxEffects *arg1 = (wxEffects *) 0 ;
20488 wxColour *arg2 = 0 ;
20489 wxColour temp2 ;
20490 PyObject * obj0 = 0 ;
20491 PyObject * obj1 = 0 ;
20492 char *kwnames[] = {
20493 (char *) "self",(char *) "c", NULL
20494 };
20495
20496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetDarkShadow",kwnames,&obj0,&obj1)) goto fail;
20497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20498 if (SWIG_arg_fail(1)) SWIG_fail;
20499 {
20500 arg2 = &temp2;
20501 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20502 }
20503 {
20504 PyThreadState* __tstate = wxPyBeginAllowThreads();
20505 (arg1)->SetDarkShadow((wxColour const &)*arg2);
20506
20507 wxPyEndAllowThreads(__tstate);
20508 if (PyErr_Occurred()) SWIG_fail;
20509 }
20510 Py_INCREF(Py_None); resultobj = Py_None;
20511 return resultobj;
20512 fail:
20513 return NULL;
20514 }
20515
20516
20517 static PyObject *_wrap_Effects_Set(PyObject *, PyObject *args, PyObject *kwargs) {
20518 PyObject *resultobj;
20519 wxEffects *arg1 = (wxEffects *) 0 ;
20520 wxColour *arg2 = 0 ;
20521 wxColour *arg3 = 0 ;
20522 wxColour *arg4 = 0 ;
20523 wxColour *arg5 = 0 ;
20524 wxColour *arg6 = 0 ;
20525 wxColour temp2 ;
20526 wxColour temp3 ;
20527 wxColour temp4 ;
20528 wxColour temp5 ;
20529 wxColour temp6 ;
20530 PyObject * obj0 = 0 ;
20531 PyObject * obj1 = 0 ;
20532 PyObject * obj2 = 0 ;
20533 PyObject * obj3 = 0 ;
20534 PyObject * obj4 = 0 ;
20535 PyObject * obj5 = 0 ;
20536 char *kwnames[] = {
20537 (char *) "self",(char *) "highlightColour",(char *) "lightShadow",(char *) "faceColour",(char *) "mediumShadow",(char *) "darkShadow", NULL
20538 };
20539
20540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Effects_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
20541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20542 if (SWIG_arg_fail(1)) SWIG_fail;
20543 {
20544 arg2 = &temp2;
20545 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20546 }
20547 {
20548 arg3 = &temp3;
20549 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
20550 }
20551 {
20552 arg4 = &temp4;
20553 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
20554 }
20555 {
20556 arg5 = &temp5;
20557 if ( ! wxColour_helper(obj4, &arg5)) SWIG_fail;
20558 }
20559 {
20560 arg6 = &temp6;
20561 if ( ! wxColour_helper(obj5, &arg6)) SWIG_fail;
20562 }
20563 {
20564 PyThreadState* __tstate = wxPyBeginAllowThreads();
20565 (arg1)->Set((wxColour const &)*arg2,(wxColour const &)*arg3,(wxColour const &)*arg4,(wxColour const &)*arg5,(wxColour const &)*arg6);
20566
20567 wxPyEndAllowThreads(__tstate);
20568 if (PyErr_Occurred()) SWIG_fail;
20569 }
20570 Py_INCREF(Py_None); resultobj = Py_None;
20571 return resultobj;
20572 fail:
20573 return NULL;
20574 }
20575
20576
20577 static PyObject *_wrap_Effects_DrawSunkenEdge(PyObject *, PyObject *args, PyObject *kwargs) {
20578 PyObject *resultobj;
20579 wxEffects *arg1 = (wxEffects *) 0 ;
20580 wxDC *arg2 = 0 ;
20581 wxRect *arg3 = 0 ;
20582 int arg4 = (int) 1 ;
20583 wxRect temp3 ;
20584 PyObject * obj0 = 0 ;
20585 PyObject * obj1 = 0 ;
20586 PyObject * obj2 = 0 ;
20587 PyObject * obj3 = 0 ;
20588 char *kwnames[] = {
20589 (char *) "self",(char *) "dc",(char *) "rect",(char *) "borderSize", NULL
20590 };
20591
20592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Effects_DrawSunkenEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20594 if (SWIG_arg_fail(1)) SWIG_fail;
20595 {
20596 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20597 if (SWIG_arg_fail(2)) SWIG_fail;
20598 if (arg2 == NULL) {
20599 SWIG_null_ref("wxDC");
20600 }
20601 if (SWIG_arg_fail(2)) SWIG_fail;
20602 }
20603 {
20604 arg3 = &temp3;
20605 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
20606 }
20607 if (obj3) {
20608 {
20609 arg4 = (int)(SWIG_As_int(obj3));
20610 if (SWIG_arg_fail(4)) SWIG_fail;
20611 }
20612 }
20613 {
20614 PyThreadState* __tstate = wxPyBeginAllowThreads();
20615 (arg1)->DrawSunkenEdge(*arg2,(wxRect const &)*arg3,arg4);
20616
20617 wxPyEndAllowThreads(__tstate);
20618 if (PyErr_Occurred()) SWIG_fail;
20619 }
20620 Py_INCREF(Py_None); resultobj = Py_None;
20621 return resultobj;
20622 fail:
20623 return NULL;
20624 }
20625
20626
20627 static PyObject *_wrap_Effects_TileBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
20628 PyObject *resultobj;
20629 wxEffects *arg1 = (wxEffects *) 0 ;
20630 wxRect *arg2 = 0 ;
20631 wxDC *arg3 = 0 ;
20632 wxBitmap *arg4 = 0 ;
20633 bool result;
20634 wxRect temp2 ;
20635 PyObject * obj0 = 0 ;
20636 PyObject * obj1 = 0 ;
20637 PyObject * obj2 = 0 ;
20638 PyObject * obj3 = 0 ;
20639 char *kwnames[] = {
20640 (char *) "self",(char *) "rect",(char *) "dc",(char *) "bitmap", NULL
20641 };
20642
20643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Effects_TileBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20645 if (SWIG_arg_fail(1)) SWIG_fail;
20646 {
20647 arg2 = &temp2;
20648 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
20649 }
20650 {
20651 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20652 if (SWIG_arg_fail(3)) SWIG_fail;
20653 if (arg3 == NULL) {
20654 SWIG_null_ref("wxDC");
20655 }
20656 if (SWIG_arg_fail(3)) SWIG_fail;
20657 }
20658 {
20659 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
20660 if (SWIG_arg_fail(4)) SWIG_fail;
20661 if (arg4 == NULL) {
20662 SWIG_null_ref("wxBitmap");
20663 }
20664 if (SWIG_arg_fail(4)) SWIG_fail;
20665 }
20666 {
20667 PyThreadState* __tstate = wxPyBeginAllowThreads();
20668 result = (bool)(arg1)->TileBitmap((wxRect const &)*arg2,*arg3,*arg4);
20669
20670 wxPyEndAllowThreads(__tstate);
20671 if (PyErr_Occurred()) SWIG_fail;
20672 }
20673 {
20674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20675 }
20676 return resultobj;
20677 fail:
20678 return NULL;
20679 }
20680
20681
20682 static PyObject * Effects_swigregister(PyObject *, PyObject *args) {
20683 PyObject *obj;
20684 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20685 SWIG_TypeClientData(SWIGTYPE_p_wxEffects, obj);
20686 Py_INCREF(obj);
20687 return Py_BuildValue((char *)"");
20688 }
20689 static PyMethodDef SwigMethods[] = {
20690 { (char *)"new_GDIObject", (PyCFunction) _wrap_new_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
20691 { (char *)"delete_GDIObject", (PyCFunction) _wrap_delete_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
20692 { (char *)"GDIObject_GetVisible", (PyCFunction) _wrap_GDIObject_GetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20693 { (char *)"GDIObject_SetVisible", (PyCFunction) _wrap_GDIObject_SetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20694 { (char *)"GDIObject_IsNull", (PyCFunction) _wrap_GDIObject_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
20695 { (char *)"GDIObject_swigregister", GDIObject_swigregister, METH_VARARGS, NULL},
20696 { (char *)"new_Colour", (PyCFunction) _wrap_new_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
20697 { (char *)"new_NamedColour", (PyCFunction) _wrap_new_NamedColour, METH_VARARGS | METH_KEYWORDS, NULL},
20698 { (char *)"new_ColourRGB", (PyCFunction) _wrap_new_ColourRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20699 { (char *)"delete_Colour", (PyCFunction) _wrap_delete_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
20700 { (char *)"Colour_Red", (PyCFunction) _wrap_Colour_Red, METH_VARARGS | METH_KEYWORDS, NULL},
20701 { (char *)"Colour_Green", (PyCFunction) _wrap_Colour_Green, METH_VARARGS | METH_KEYWORDS, NULL},
20702 { (char *)"Colour_Blue", (PyCFunction) _wrap_Colour_Blue, METH_VARARGS | METH_KEYWORDS, NULL},
20703 { (char *)"Colour_Ok", (PyCFunction) _wrap_Colour_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20704 { (char *)"Colour_Set", (PyCFunction) _wrap_Colour_Set, METH_VARARGS | METH_KEYWORDS, NULL},
20705 { (char *)"Colour_SetRGB", (PyCFunction) _wrap_Colour_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20706 { (char *)"Colour_SetFromName", (PyCFunction) _wrap_Colour_SetFromName, METH_VARARGS | METH_KEYWORDS, NULL},
20707 { (char *)"Colour_GetPixel", (PyCFunction) _wrap_Colour_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
20708 { (char *)"Colour___eq__", (PyCFunction) _wrap_Colour___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20709 { (char *)"Colour___ne__", (PyCFunction) _wrap_Colour___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20710 { (char *)"Colour_Get", (PyCFunction) _wrap_Colour_Get, METH_VARARGS | METH_KEYWORDS, NULL},
20711 { (char *)"Colour_GetRGB", (PyCFunction) _wrap_Colour_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20712 { (char *)"Colour_swigregister", Colour_swigregister, METH_VARARGS, NULL},
20713 { (char *)"new_Palette", (PyCFunction) _wrap_new_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
20714 { (char *)"delete_Palette", (PyCFunction) _wrap_delete_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
20715 { (char *)"Palette_GetPixel", (PyCFunction) _wrap_Palette_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
20716 { (char *)"Palette_GetRGB", (PyCFunction) _wrap_Palette_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20717 { (char *)"Palette_GetColoursCount", (PyCFunction) _wrap_Palette_GetColoursCount, METH_VARARGS | METH_KEYWORDS, NULL},
20718 { (char *)"Palette_Ok", (PyCFunction) _wrap_Palette_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20719 { (char *)"Palette_swigregister", Palette_swigregister, METH_VARARGS, NULL},
20720 { (char *)"new_Pen", (PyCFunction) _wrap_new_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
20721 { (char *)"delete_Pen", (PyCFunction) _wrap_delete_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
20722 { (char *)"Pen_GetCap", (PyCFunction) _wrap_Pen_GetCap, METH_VARARGS | METH_KEYWORDS, NULL},
20723 { (char *)"Pen_GetColour", (PyCFunction) _wrap_Pen_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20724 { (char *)"Pen_GetJoin", (PyCFunction) _wrap_Pen_GetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
20725 { (char *)"Pen_GetStyle", (PyCFunction) _wrap_Pen_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20726 { (char *)"Pen_GetWidth", (PyCFunction) _wrap_Pen_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20727 { (char *)"Pen_Ok", (PyCFunction) _wrap_Pen_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20728 { (char *)"Pen_SetCap", (PyCFunction) _wrap_Pen_SetCap, METH_VARARGS | METH_KEYWORDS, NULL},
20729 { (char *)"Pen_SetColour", (PyCFunction) _wrap_Pen_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20730 { (char *)"Pen_SetJoin", (PyCFunction) _wrap_Pen_SetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
20731 { (char *)"Pen_SetStyle", (PyCFunction) _wrap_Pen_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20732 { (char *)"Pen_SetWidth", (PyCFunction) _wrap_Pen_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20733 { (char *)"Pen_SetDashes", (PyCFunction) _wrap_Pen_SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
20734 { (char *)"Pen_GetDashes", (PyCFunction) _wrap_Pen_GetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
20735 { (char *)"Pen__SetDashes", (PyCFunction) _wrap_Pen__SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
20736 { (char *)"Pen___eq__", (PyCFunction) _wrap_Pen___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20737 { (char *)"Pen___ne__", (PyCFunction) _wrap_Pen___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20738 { (char *)"Pen_swigregister", Pen_swigregister, METH_VARARGS, NULL},
20739 { (char *)"new_Brush", (PyCFunction) _wrap_new_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
20740 { (char *)"delete_Brush", (PyCFunction) _wrap_delete_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
20741 { (char *)"Brush_SetColour", (PyCFunction) _wrap_Brush_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20742 { (char *)"Brush_SetStyle", (PyCFunction) _wrap_Brush_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20743 { (char *)"Brush_SetStipple", (PyCFunction) _wrap_Brush_SetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
20744 { (char *)"Brush_GetColour", (PyCFunction) _wrap_Brush_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20745 { (char *)"Brush_GetStyle", (PyCFunction) _wrap_Brush_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20746 { (char *)"Brush_GetStipple", (PyCFunction) _wrap_Brush_GetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
20747 { (char *)"Brush_IsHatch", (PyCFunction) _wrap_Brush_IsHatch, METH_VARARGS | METH_KEYWORDS, NULL},
20748 { (char *)"Brush_Ok", (PyCFunction) _wrap_Brush_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20749 { (char *)"Brush_MacGetTheme", (PyCFunction) _wrap_Brush_MacGetTheme, METH_VARARGS | METH_KEYWORDS, NULL},
20750 { (char *)"Brush_MacSetTheme", (PyCFunction) _wrap_Brush_MacSetTheme, METH_VARARGS | METH_KEYWORDS, NULL},
20751 { (char *)"Brush_swigregister", Brush_swigregister, METH_VARARGS, NULL},
20752 { (char *)"new_Bitmap", (PyCFunction) _wrap_new_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20753 { (char *)"delete_Bitmap", (PyCFunction) _wrap_delete_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20754 { (char *)"new_EmptyBitmap", (PyCFunction) _wrap_new_EmptyBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20755 { (char *)"new_BitmapFromIcon", (PyCFunction) _wrap_new_BitmapFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20756 { (char *)"new_BitmapFromImage", (PyCFunction) _wrap_new_BitmapFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
20757 { (char *)"new_BitmapFromXPMData", (PyCFunction) _wrap_new_BitmapFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
20758 { (char *)"new_BitmapFromBits", (PyCFunction) _wrap_new_BitmapFromBits, METH_VARARGS | METH_KEYWORDS, NULL},
20759 { (char *)"Bitmap_Ok", (PyCFunction) _wrap_Bitmap_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20760 { (char *)"Bitmap_GetWidth", (PyCFunction) _wrap_Bitmap_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20761 { (char *)"Bitmap_GetHeight", (PyCFunction) _wrap_Bitmap_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20762 { (char *)"Bitmap_GetDepth", (PyCFunction) _wrap_Bitmap_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20763 { (char *)"Bitmap_GetSize", (PyCFunction) _wrap_Bitmap_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20764 { (char *)"Bitmap_ConvertToImage", (PyCFunction) _wrap_Bitmap_ConvertToImage, METH_VARARGS | METH_KEYWORDS, NULL},
20765 { (char *)"Bitmap_GetMask", (PyCFunction) _wrap_Bitmap_GetMask, METH_VARARGS | METH_KEYWORDS, NULL},
20766 { (char *)"Bitmap_SetMask", (PyCFunction) _wrap_Bitmap_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
20767 { (char *)"Bitmap_SetMaskColour", (PyCFunction) _wrap_Bitmap_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
20768 { (char *)"Bitmap_GetSubBitmap", (PyCFunction) _wrap_Bitmap_GetSubBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20769 { (char *)"Bitmap_SaveFile", (PyCFunction) _wrap_Bitmap_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
20770 { (char *)"Bitmap_LoadFile", (PyCFunction) _wrap_Bitmap_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
20771 { (char *)"Bitmap_GetPalette", (PyCFunction) _wrap_Bitmap_GetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
20772 { (char *)"Bitmap_CopyFromIcon", (PyCFunction) _wrap_Bitmap_CopyFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20773 { (char *)"Bitmap_SetHeight", (PyCFunction) _wrap_Bitmap_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20774 { (char *)"Bitmap_SetWidth", (PyCFunction) _wrap_Bitmap_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20775 { (char *)"Bitmap_SetDepth", (PyCFunction) _wrap_Bitmap_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20776 { (char *)"Bitmap_SetSize", (PyCFunction) _wrap_Bitmap_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20777 { (char *)"Bitmap___eq__", (PyCFunction) _wrap_Bitmap___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20778 { (char *)"Bitmap___ne__", (PyCFunction) _wrap_Bitmap___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20779 { (char *)"Bitmap_swigregister", Bitmap_swigregister, METH_VARARGS, NULL},
20780 { (char *)"new_Mask", (PyCFunction) _wrap_new_Mask, METH_VARARGS | METH_KEYWORDS, NULL},
20781 { (char *)"Mask_swigregister", Mask_swigregister, METH_VARARGS, NULL},
20782 { (char *)"new_Icon", (PyCFunction) _wrap_new_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
20783 { (char *)"delete_Icon", (PyCFunction) _wrap_delete_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
20784 { (char *)"new_EmptyIcon", (PyCFunction) _wrap_new_EmptyIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20785 { (char *)"new_IconFromLocation", (PyCFunction) _wrap_new_IconFromLocation, METH_VARARGS | METH_KEYWORDS, NULL},
20786 { (char *)"new_IconFromBitmap", (PyCFunction) _wrap_new_IconFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20787 { (char *)"new_IconFromXPMData", (PyCFunction) _wrap_new_IconFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
20788 { (char *)"Icon_Ok", (PyCFunction) _wrap_Icon_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20789 { (char *)"Icon_GetWidth", (PyCFunction) _wrap_Icon_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20790 { (char *)"Icon_GetHeight", (PyCFunction) _wrap_Icon_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20791 { (char *)"Icon_GetDepth", (PyCFunction) _wrap_Icon_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20792 { (char *)"Icon_SetWidth", (PyCFunction) _wrap_Icon_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20793 { (char *)"Icon_SetHeight", (PyCFunction) _wrap_Icon_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20794 { (char *)"Icon_SetDepth", (PyCFunction) _wrap_Icon_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20795 { (char *)"Icon_CopyFromBitmap", (PyCFunction) _wrap_Icon_CopyFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20796 { (char *)"Icon_swigregister", Icon_swigregister, METH_VARARGS, NULL},
20797 { (char *)"new_IconLocation", (PyCFunction) _wrap_new_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
20798 { (char *)"delete_IconLocation", (PyCFunction) _wrap_delete_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
20799 { (char *)"IconLocation_IsOk", (PyCFunction) _wrap_IconLocation_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
20800 { (char *)"IconLocation_SetFileName", (PyCFunction) _wrap_IconLocation_SetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
20801 { (char *)"IconLocation_GetFileName", (PyCFunction) _wrap_IconLocation_GetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
20802 { (char *)"IconLocation_SetIndex", (PyCFunction) _wrap_IconLocation_SetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
20803 { (char *)"IconLocation_GetIndex", (PyCFunction) _wrap_IconLocation_GetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
20804 { (char *)"IconLocation_swigregister", IconLocation_swigregister, METH_VARARGS, NULL},
20805 { (char *)"new_IconBundle", (PyCFunction) _wrap_new_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
20806 { (char *)"new_IconBundleFromFile", (PyCFunction) _wrap_new_IconBundleFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
20807 { (char *)"new_IconBundleFromIcon", (PyCFunction) _wrap_new_IconBundleFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20808 { (char *)"delete_IconBundle", (PyCFunction) _wrap_delete_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
20809 { (char *)"IconBundle_AddIcon", (PyCFunction) _wrap_IconBundle_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20810 { (char *)"IconBundle_AddIconFromFile", (PyCFunction) _wrap_IconBundle_AddIconFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
20811 { (char *)"IconBundle_GetIcon", (PyCFunction) _wrap_IconBundle_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20812 { (char *)"IconBundle_swigregister", IconBundle_swigregister, METH_VARARGS, NULL},
20813 { (char *)"new_Cursor", (PyCFunction) _wrap_new_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
20814 { (char *)"delete_Cursor", (PyCFunction) _wrap_delete_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
20815 { (char *)"new_StockCursor", (PyCFunction) _wrap_new_StockCursor, METH_VARARGS | METH_KEYWORDS, NULL},
20816 { (char *)"new_CursorFromImage", (PyCFunction) _wrap_new_CursorFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
20817 { (char *)"Cursor_Ok", (PyCFunction) _wrap_Cursor_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20818 { (char *)"Cursor_swigregister", Cursor_swigregister, METH_VARARGS, NULL},
20819 { (char *)"new_Region", (PyCFunction) _wrap_new_Region, METH_VARARGS | METH_KEYWORDS, NULL},
20820 { (char *)"new_RegionFromBitmap", (PyCFunction) _wrap_new_RegionFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20821 { (char *)"new_RegionFromBitmapColour", (PyCFunction) _wrap_new_RegionFromBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
20822 { (char *)"new_RegionFromPoints", (PyCFunction) _wrap_new_RegionFromPoints, METH_VARARGS | METH_KEYWORDS, NULL},
20823 { (char *)"delete_Region", (PyCFunction) _wrap_delete_Region, METH_VARARGS | METH_KEYWORDS, NULL},
20824 { (char *)"Region_Clear", (PyCFunction) _wrap_Region_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
20825 { (char *)"Region_Offset", (PyCFunction) _wrap_Region_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
20826 { (char *)"Region_Contains", (PyCFunction) _wrap_Region_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
20827 { (char *)"Region_ContainsPoint", (PyCFunction) _wrap_Region_ContainsPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20828 { (char *)"Region_ContainsRect", (PyCFunction) _wrap_Region_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
20829 { (char *)"Region_ContainsRectDim", (PyCFunction) _wrap_Region_ContainsRectDim, METH_VARARGS | METH_KEYWORDS, NULL},
20830 { (char *)"Region_GetBox", (PyCFunction) _wrap_Region_GetBox, METH_VARARGS | METH_KEYWORDS, NULL},
20831 { (char *)"Region_Intersect", (PyCFunction) _wrap_Region_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
20832 { (char *)"Region_IntersectRect", (PyCFunction) _wrap_Region_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
20833 { (char *)"Region_IntersectRegion", (PyCFunction) _wrap_Region_IntersectRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20834 { (char *)"Region_IsEmpty", (PyCFunction) _wrap_Region_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
20835 { (char *)"Region_Union", (PyCFunction) _wrap_Region_Union, METH_VARARGS | METH_KEYWORDS, NULL},
20836 { (char *)"Region_UnionRect", (PyCFunction) _wrap_Region_UnionRect, METH_VARARGS | METH_KEYWORDS, NULL},
20837 { (char *)"Region_UnionRegion", (PyCFunction) _wrap_Region_UnionRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20838 { (char *)"Region_Subtract", (PyCFunction) _wrap_Region_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
20839 { (char *)"Region_SubtractRect", (PyCFunction) _wrap_Region_SubtractRect, METH_VARARGS | METH_KEYWORDS, NULL},
20840 { (char *)"Region_SubtractRegion", (PyCFunction) _wrap_Region_SubtractRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20841 { (char *)"Region_Xor", (PyCFunction) _wrap_Region_Xor, METH_VARARGS | METH_KEYWORDS, NULL},
20842 { (char *)"Region_XorRect", (PyCFunction) _wrap_Region_XorRect, METH_VARARGS | METH_KEYWORDS, NULL},
20843 { (char *)"Region_XorRegion", (PyCFunction) _wrap_Region_XorRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20844 { (char *)"Region_ConvertToBitmap", (PyCFunction) _wrap_Region_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20845 { (char *)"Region_UnionBitmap", (PyCFunction) _wrap_Region_UnionBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20846 { (char *)"Region_UnionBitmapColour", (PyCFunction) _wrap_Region_UnionBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
20847 { (char *)"Region_swigregister", Region_swigregister, METH_VARARGS, NULL},
20848 { (char *)"new_RegionIterator", (PyCFunction) _wrap_new_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
20849 { (char *)"delete_RegionIterator", (PyCFunction) _wrap_delete_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
20850 { (char *)"RegionIterator_GetX", (PyCFunction) _wrap_RegionIterator_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
20851 { (char *)"RegionIterator_GetY", (PyCFunction) _wrap_RegionIterator_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
20852 { (char *)"RegionIterator_GetW", (PyCFunction) _wrap_RegionIterator_GetW, METH_VARARGS | METH_KEYWORDS, NULL},
20853 { (char *)"RegionIterator_GetWidth", (PyCFunction) _wrap_RegionIterator_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20854 { (char *)"RegionIterator_GetH", (PyCFunction) _wrap_RegionIterator_GetH, METH_VARARGS | METH_KEYWORDS, NULL},
20855 { (char *)"RegionIterator_GetHeight", (PyCFunction) _wrap_RegionIterator_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20856 { (char *)"RegionIterator_GetRect", (PyCFunction) _wrap_RegionIterator_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
20857 { (char *)"RegionIterator_HaveRects", (PyCFunction) _wrap_RegionIterator_HaveRects, METH_VARARGS | METH_KEYWORDS, NULL},
20858 { (char *)"RegionIterator_Reset", (PyCFunction) _wrap_RegionIterator_Reset, METH_VARARGS | METH_KEYWORDS, NULL},
20859 { (char *)"RegionIterator_Next", (PyCFunction) _wrap_RegionIterator_Next, METH_VARARGS | METH_KEYWORDS, NULL},
20860 { (char *)"RegionIterator___nonzero__", (PyCFunction) _wrap_RegionIterator___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
20861 { (char *)"RegionIterator_swigregister", RegionIterator_swigregister, METH_VARARGS, NULL},
20862 { (char *)"new_NativeFontInfo", (PyCFunction) _wrap_new_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20863 { (char *)"delete_NativeFontInfo", (PyCFunction) _wrap_delete_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20864 { (char *)"NativeFontInfo_Init", (PyCFunction) _wrap_NativeFontInfo_Init, METH_VARARGS | METH_KEYWORDS, NULL},
20865 { (char *)"NativeFontInfo_InitFromFont", (PyCFunction) _wrap_NativeFontInfo_InitFromFont, METH_VARARGS | METH_KEYWORDS, NULL},
20866 { (char *)"NativeFontInfo_GetPointSize", (PyCFunction) _wrap_NativeFontInfo_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20867 { (char *)"NativeFontInfo_GetStyle", (PyCFunction) _wrap_NativeFontInfo_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20868 { (char *)"NativeFontInfo_GetWeight", (PyCFunction) _wrap_NativeFontInfo_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20869 { (char *)"NativeFontInfo_GetUnderlined", (PyCFunction) _wrap_NativeFontInfo_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20870 { (char *)"NativeFontInfo_GetFaceName", (PyCFunction) _wrap_NativeFontInfo_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20871 { (char *)"NativeFontInfo_GetFamily", (PyCFunction) _wrap_NativeFontInfo_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20872 { (char *)"NativeFontInfo_GetEncoding", (PyCFunction) _wrap_NativeFontInfo_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20873 { (char *)"NativeFontInfo_SetPointSize", (PyCFunction) _wrap_NativeFontInfo_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20874 { (char *)"NativeFontInfo_SetStyle", (PyCFunction) _wrap_NativeFontInfo_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20875 { (char *)"NativeFontInfo_SetWeight", (PyCFunction) _wrap_NativeFontInfo_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20876 { (char *)"NativeFontInfo_SetUnderlined", (PyCFunction) _wrap_NativeFontInfo_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20877 { (char *)"NativeFontInfo_SetFaceName", (PyCFunction) _wrap_NativeFontInfo_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20878 { (char *)"NativeFontInfo_SetFamily", (PyCFunction) _wrap_NativeFontInfo_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20879 { (char *)"NativeFontInfo_SetEncoding", (PyCFunction) _wrap_NativeFontInfo_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20880 { (char *)"NativeFontInfo_FromString", (PyCFunction) _wrap_NativeFontInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
20881 { (char *)"NativeFontInfo_ToString", (PyCFunction) _wrap_NativeFontInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
20882 { (char *)"NativeFontInfo___str__", (PyCFunction) _wrap_NativeFontInfo___str__, METH_VARARGS | METH_KEYWORDS, NULL},
20883 { (char *)"NativeFontInfo_FromUserString", (PyCFunction) _wrap_NativeFontInfo_FromUserString, METH_VARARGS | METH_KEYWORDS, NULL},
20884 { (char *)"NativeFontInfo_ToUserString", (PyCFunction) _wrap_NativeFontInfo_ToUserString, METH_VARARGS | METH_KEYWORDS, NULL},
20885 { (char *)"NativeFontInfo_swigregister", NativeFontInfo_swigregister, METH_VARARGS, NULL},
20886 { (char *)"NativeEncodingInfo_facename_set", (PyCFunction) _wrap_NativeEncodingInfo_facename_set, METH_VARARGS | METH_KEYWORDS, NULL},
20887 { (char *)"NativeEncodingInfo_facename_get", (PyCFunction) _wrap_NativeEncodingInfo_facename_get, METH_VARARGS | METH_KEYWORDS, NULL},
20888 { (char *)"NativeEncodingInfo_encoding_set", (PyCFunction) _wrap_NativeEncodingInfo_encoding_set, METH_VARARGS | METH_KEYWORDS, NULL},
20889 { (char *)"NativeEncodingInfo_encoding_get", (PyCFunction) _wrap_NativeEncodingInfo_encoding_get, METH_VARARGS | METH_KEYWORDS, NULL},
20890 { (char *)"new_NativeEncodingInfo", (PyCFunction) _wrap_new_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20891 { (char *)"delete_NativeEncodingInfo", (PyCFunction) _wrap_delete_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20892 { (char *)"NativeEncodingInfo_FromString", (PyCFunction) _wrap_NativeEncodingInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
20893 { (char *)"NativeEncodingInfo_ToString", (PyCFunction) _wrap_NativeEncodingInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
20894 { (char *)"NativeEncodingInfo_swigregister", NativeEncodingInfo_swigregister, METH_VARARGS, NULL},
20895 { (char *)"GetNativeFontEncoding", (PyCFunction) _wrap_GetNativeFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20896 { (char *)"TestFontEncoding", (PyCFunction) _wrap_TestFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20897 { (char *)"new_FontMapper", (PyCFunction) _wrap_new_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
20898 { (char *)"delete_FontMapper", (PyCFunction) _wrap_delete_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
20899 { (char *)"FontMapper_Get", (PyCFunction) _wrap_FontMapper_Get, METH_VARARGS | METH_KEYWORDS, NULL},
20900 { (char *)"FontMapper_Set", (PyCFunction) _wrap_FontMapper_Set, METH_VARARGS | METH_KEYWORDS, NULL},
20901 { (char *)"FontMapper_CharsetToEncoding", (PyCFunction) _wrap_FontMapper_CharsetToEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20902 { (char *)"FontMapper_GetSupportedEncodingsCount", (PyCFunction) _wrap_FontMapper_GetSupportedEncodingsCount, METH_VARARGS | METH_KEYWORDS, NULL},
20903 { (char *)"FontMapper_GetEncoding", (PyCFunction) _wrap_FontMapper_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20904 { (char *)"FontMapper_GetEncodingName", (PyCFunction) _wrap_FontMapper_GetEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
20905 { (char *)"FontMapper_GetEncodingDescription", (PyCFunction) _wrap_FontMapper_GetEncodingDescription, METH_VARARGS | METH_KEYWORDS, NULL},
20906 { (char *)"FontMapper_GetEncodingFromName", (PyCFunction) _wrap_FontMapper_GetEncodingFromName, METH_VARARGS | METH_KEYWORDS, NULL},
20907 { (char *)"FontMapper_SetConfig", (PyCFunction) _wrap_FontMapper_SetConfig, METH_VARARGS | METH_KEYWORDS, NULL},
20908 { (char *)"FontMapper_SetConfigPath", (PyCFunction) _wrap_FontMapper_SetConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
20909 { (char *)"FontMapper_GetDefaultConfigPath", (PyCFunction) _wrap_FontMapper_GetDefaultConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
20910 { (char *)"FontMapper_GetAltForEncoding", (PyCFunction) _wrap_FontMapper_GetAltForEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20911 { (char *)"FontMapper_IsEncodingAvailable", (PyCFunction) _wrap_FontMapper_IsEncodingAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
20912 { (char *)"FontMapper_SetDialogParent", (PyCFunction) _wrap_FontMapper_SetDialogParent, METH_VARARGS | METH_KEYWORDS, NULL},
20913 { (char *)"FontMapper_SetDialogTitle", (PyCFunction) _wrap_FontMapper_SetDialogTitle, METH_VARARGS | METH_KEYWORDS, NULL},
20914 { (char *)"FontMapper_swigregister", FontMapper_swigregister, METH_VARARGS, NULL},
20915 { (char *)"new_Font", (PyCFunction) _wrap_new_Font, METH_VARARGS | METH_KEYWORDS, NULL},
20916 { (char *)"delete_Font", (PyCFunction) _wrap_delete_Font, METH_VARARGS | METH_KEYWORDS, NULL},
20917 { (char *)"new_FontFromNativeInfo", (PyCFunction) _wrap_new_FontFromNativeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20918 { (char *)"new_FontFromNativeInfoString", (PyCFunction) _wrap_new_FontFromNativeInfoString, METH_VARARGS | METH_KEYWORDS, NULL},
20919 { (char *)"new_Font2", (PyCFunction) _wrap_new_Font2, METH_VARARGS | METH_KEYWORDS, NULL},
20920 { (char *)"new_FontFromPixelSize", (PyCFunction) _wrap_new_FontFromPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20921 { (char *)"Font_Ok", (PyCFunction) _wrap_Font_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20922 { (char *)"Font___eq__", (PyCFunction) _wrap_Font___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20923 { (char *)"Font___ne__", (PyCFunction) _wrap_Font___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20924 { (char *)"Font_GetPointSize", (PyCFunction) _wrap_Font_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20925 { (char *)"Font_GetPixelSize", (PyCFunction) _wrap_Font_GetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20926 { (char *)"Font_IsUsingSizeInPixels", (PyCFunction) _wrap_Font_IsUsingSizeInPixels, METH_VARARGS | METH_KEYWORDS, NULL},
20927 { (char *)"Font_GetFamily", (PyCFunction) _wrap_Font_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20928 { (char *)"Font_GetStyle", (PyCFunction) _wrap_Font_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20929 { (char *)"Font_GetWeight", (PyCFunction) _wrap_Font_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20930 { (char *)"Font_GetUnderlined", (PyCFunction) _wrap_Font_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20931 { (char *)"Font_GetFaceName", (PyCFunction) _wrap_Font_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20932 { (char *)"Font_GetEncoding", (PyCFunction) _wrap_Font_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20933 { (char *)"Font_GetNativeFontInfo", (PyCFunction) _wrap_Font_GetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20934 { (char *)"Font_IsFixedWidth", (PyCFunction) _wrap_Font_IsFixedWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20935 { (char *)"Font_GetNativeFontInfoDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoDesc, METH_VARARGS | METH_KEYWORDS, NULL},
20936 { (char *)"Font_GetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
20937 { (char *)"Font_SetPointSize", (PyCFunction) _wrap_Font_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20938 { (char *)"Font_SetPixelSize", (PyCFunction) _wrap_Font_SetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20939 { (char *)"Font_SetFamily", (PyCFunction) _wrap_Font_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20940 { (char *)"Font_SetStyle", (PyCFunction) _wrap_Font_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20941 { (char *)"Font_SetWeight", (PyCFunction) _wrap_Font_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20942 { (char *)"Font_SetFaceName", (PyCFunction) _wrap_Font_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20943 { (char *)"Font_SetUnderlined", (PyCFunction) _wrap_Font_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20944 { (char *)"Font_SetEncoding", (PyCFunction) _wrap_Font_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20945 { (char *)"Font_SetNativeFontInfo", (PyCFunction) _wrap_Font_SetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20946 { (char *)"Font_SetNativeFontInfoFromString", (PyCFunction) _wrap_Font_SetNativeFontInfoFromString, METH_VARARGS | METH_KEYWORDS, NULL},
20947 { (char *)"Font_SetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_SetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
20948 { (char *)"Font_GetFamilyString", (PyCFunction) _wrap_Font_GetFamilyString, METH_VARARGS | METH_KEYWORDS, NULL},
20949 { (char *)"Font_GetStyleString", (PyCFunction) _wrap_Font_GetStyleString, METH_VARARGS | METH_KEYWORDS, NULL},
20950 { (char *)"Font_GetWeightString", (PyCFunction) _wrap_Font_GetWeightString, METH_VARARGS | METH_KEYWORDS, NULL},
20951 { (char *)"Font_SetNoAntiAliasing", (PyCFunction) _wrap_Font_SetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
20952 { (char *)"Font_GetNoAntiAliasing", (PyCFunction) _wrap_Font_GetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
20953 { (char *)"Font_GetDefaultEncoding", (PyCFunction) _wrap_Font_GetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20954 { (char *)"Font_SetDefaultEncoding", (PyCFunction) _wrap_Font_SetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20955 { (char *)"Font_swigregister", Font_swigregister, METH_VARARGS, NULL},
20956 { (char *)"new_FontEnumerator", (PyCFunction) _wrap_new_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
20957 { (char *)"delete_FontEnumerator", (PyCFunction) _wrap_delete_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
20958 { (char *)"FontEnumerator__setCallbackInfo", (PyCFunction) _wrap_FontEnumerator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20959 { (char *)"FontEnumerator_EnumerateFacenames", (PyCFunction) _wrap_FontEnumerator_EnumerateFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
20960 { (char *)"FontEnumerator_EnumerateEncodings", (PyCFunction) _wrap_FontEnumerator_EnumerateEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
20961 { (char *)"FontEnumerator_GetEncodings", (PyCFunction) _wrap_FontEnumerator_GetEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
20962 { (char *)"FontEnumerator_GetFacenames", (PyCFunction) _wrap_FontEnumerator_GetFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
20963 { (char *)"FontEnumerator_swigregister", FontEnumerator_swigregister, METH_VARARGS, NULL},
20964 { (char *)"LanguageInfo_Language_set", (PyCFunction) _wrap_LanguageInfo_Language_set, METH_VARARGS | METH_KEYWORDS, NULL},
20965 { (char *)"LanguageInfo_Language_get", (PyCFunction) _wrap_LanguageInfo_Language_get, METH_VARARGS | METH_KEYWORDS, NULL},
20966 { (char *)"LanguageInfo_CanonicalName_set", (PyCFunction) _wrap_LanguageInfo_CanonicalName_set, METH_VARARGS | METH_KEYWORDS, NULL},
20967 { (char *)"LanguageInfo_CanonicalName_get", (PyCFunction) _wrap_LanguageInfo_CanonicalName_get, METH_VARARGS | METH_KEYWORDS, NULL},
20968 { (char *)"LanguageInfo_Description_set", (PyCFunction) _wrap_LanguageInfo_Description_set, METH_VARARGS | METH_KEYWORDS, NULL},
20969 { (char *)"LanguageInfo_Description_get", (PyCFunction) _wrap_LanguageInfo_Description_get, METH_VARARGS | METH_KEYWORDS, NULL},
20970 { (char *)"LanguageInfo_swigregister", LanguageInfo_swigregister, METH_VARARGS, NULL},
20971 { (char *)"new_Locale", (PyCFunction) _wrap_new_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
20972 { (char *)"delete_Locale", (PyCFunction) _wrap_delete_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
20973 { (char *)"Locale_Init1", (PyCFunction) _wrap_Locale_Init1, METH_VARARGS | METH_KEYWORDS, NULL},
20974 { (char *)"Locale_Init2", (PyCFunction) _wrap_Locale_Init2, METH_VARARGS | METH_KEYWORDS, NULL},
20975 { (char *)"Locale_GetSystemLanguage", (PyCFunction) _wrap_Locale_GetSystemLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
20976 { (char *)"Locale_GetSystemEncoding", (PyCFunction) _wrap_Locale_GetSystemEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20977 { (char *)"Locale_GetSystemEncodingName", (PyCFunction) _wrap_Locale_GetSystemEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
20978 { (char *)"Locale_IsOk", (PyCFunction) _wrap_Locale_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
20979 { (char *)"Locale_GetLocale", (PyCFunction) _wrap_Locale_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
20980 { (char *)"Locale_GetLanguage", (PyCFunction) _wrap_Locale_GetLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
20981 { (char *)"Locale_GetSysName", (PyCFunction) _wrap_Locale_GetSysName, METH_VARARGS | METH_KEYWORDS, NULL},
20982 { (char *)"Locale_GetCanonicalName", (PyCFunction) _wrap_Locale_GetCanonicalName, METH_VARARGS | METH_KEYWORDS, NULL},
20983 { (char *)"Locale_AddCatalogLookupPathPrefix", (PyCFunction) _wrap_Locale_AddCatalogLookupPathPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
20984 { (char *)"Locale_AddCatalog", (PyCFunction) _wrap_Locale_AddCatalog, METH_VARARGS | METH_KEYWORDS, NULL},
20985 { (char *)"Locale_IsLoaded", (PyCFunction) _wrap_Locale_IsLoaded, METH_VARARGS | METH_KEYWORDS, NULL},
20986 { (char *)"Locale_GetLanguageInfo", (PyCFunction) _wrap_Locale_GetLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20987 { (char *)"Locale_GetLanguageName", (PyCFunction) _wrap_Locale_GetLanguageName, METH_VARARGS | METH_KEYWORDS, NULL},
20988 { (char *)"Locale_FindLanguageInfo", (PyCFunction) _wrap_Locale_FindLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20989 { (char *)"Locale_AddLanguage", (PyCFunction) _wrap_Locale_AddLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
20990 { (char *)"Locale_GetString", (PyCFunction) _wrap_Locale_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
20991 { (char *)"Locale_GetName", (PyCFunction) _wrap_Locale_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
20992 { (char *)"Locale_swigregister", Locale_swigregister, METH_VARARGS, NULL},
20993 { (char *)"GetLocale", (PyCFunction) _wrap_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
20994 { (char *)"GetTranslation", _wrap_GetTranslation, METH_VARARGS, NULL},
20995 { (char *)"new_EncodingConverter", (PyCFunction) _wrap_new_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
20996 { (char *)"delete_EncodingConverter", (PyCFunction) _wrap_delete_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
20997 { (char *)"EncodingConverter_Init", (PyCFunction) _wrap_EncodingConverter_Init, METH_VARARGS | METH_KEYWORDS, NULL},
20998 { (char *)"EncodingConverter_Convert", (PyCFunction) _wrap_EncodingConverter_Convert, METH_VARARGS | METH_KEYWORDS, NULL},
20999 { (char *)"EncodingConverter_GetPlatformEquivalents", (PyCFunction) _wrap_EncodingConverter_GetPlatformEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
21000 { (char *)"EncodingConverter_GetAllEquivalents", (PyCFunction) _wrap_EncodingConverter_GetAllEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
21001 { (char *)"EncodingConverter_CanConvert", (PyCFunction) _wrap_EncodingConverter_CanConvert, METH_VARARGS | METH_KEYWORDS, NULL},
21002 { (char *)"EncodingConverter_swigregister", EncodingConverter_swigregister, METH_VARARGS, NULL},
21003 { (char *)"delete_DC", (PyCFunction) _wrap_delete_DC, METH_VARARGS | METH_KEYWORDS, NULL},
21004 { (char *)"DC_BeginDrawing", (PyCFunction) _wrap_DC_BeginDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
21005 { (char *)"DC_EndDrawing", (PyCFunction) _wrap_DC_EndDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
21006 { (char *)"DC_FloodFill", (PyCFunction) _wrap_DC_FloodFill, METH_VARARGS | METH_KEYWORDS, NULL},
21007 { (char *)"DC_FloodFillPoint", (PyCFunction) _wrap_DC_FloodFillPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21008 { (char *)"DC_GetPixel", (PyCFunction) _wrap_DC_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
21009 { (char *)"DC_GetPixelPoint", (PyCFunction) _wrap_DC_GetPixelPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21010 { (char *)"DC_DrawLine", (PyCFunction) _wrap_DC_DrawLine, METH_VARARGS | METH_KEYWORDS, NULL},
21011 { (char *)"DC_DrawLinePoint", (PyCFunction) _wrap_DC_DrawLinePoint, METH_VARARGS | METH_KEYWORDS, NULL},
21012 { (char *)"DC_CrossHair", (PyCFunction) _wrap_DC_CrossHair, METH_VARARGS | METH_KEYWORDS, NULL},
21013 { (char *)"DC_CrossHairPoint", (PyCFunction) _wrap_DC_CrossHairPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21014 { (char *)"DC_DrawArc", (PyCFunction) _wrap_DC_DrawArc, METH_VARARGS | METH_KEYWORDS, NULL},
21015 { (char *)"DC_DrawArcPoint", (PyCFunction) _wrap_DC_DrawArcPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21016 { (char *)"DC_DrawCheckMark", (PyCFunction) _wrap_DC_DrawCheckMark, METH_VARARGS | METH_KEYWORDS, NULL},
21017 { (char *)"DC_DrawCheckMarkRect", (PyCFunction) _wrap_DC_DrawCheckMarkRect, METH_VARARGS | METH_KEYWORDS, NULL},
21018 { (char *)"DC_DrawEllipticArc", (PyCFunction) _wrap_DC_DrawEllipticArc, METH_VARARGS | METH_KEYWORDS, NULL},
21019 { (char *)"DC_DrawEllipticArcPointSize", (PyCFunction) _wrap_DC_DrawEllipticArcPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21020 { (char *)"DC_DrawPoint", (PyCFunction) _wrap_DC_DrawPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21021 { (char *)"DC_DrawPointPoint", (PyCFunction) _wrap_DC_DrawPointPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21022 { (char *)"DC_DrawRectangle", (PyCFunction) _wrap_DC_DrawRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
21023 { (char *)"DC_DrawRectangleRect", (PyCFunction) _wrap_DC_DrawRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
21024 { (char *)"DC_DrawRectanglePointSize", (PyCFunction) _wrap_DC_DrawRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21025 { (char *)"DC_DrawRoundedRectangle", (PyCFunction) _wrap_DC_DrawRoundedRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
21026 { (char *)"DC_DrawRoundedRectangleRect", (PyCFunction) _wrap_DC_DrawRoundedRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
21027 { (char *)"DC_DrawRoundedRectanglePointSize", (PyCFunction) _wrap_DC_DrawRoundedRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21028 { (char *)"DC_DrawCircle", (PyCFunction) _wrap_DC_DrawCircle, METH_VARARGS | METH_KEYWORDS, NULL},
21029 { (char *)"DC_DrawCirclePoint", (PyCFunction) _wrap_DC_DrawCirclePoint, METH_VARARGS | METH_KEYWORDS, NULL},
21030 { (char *)"DC_DrawEllipse", (PyCFunction) _wrap_DC_DrawEllipse, METH_VARARGS | METH_KEYWORDS, NULL},
21031 { (char *)"DC_DrawEllipseRect", (PyCFunction) _wrap_DC_DrawEllipseRect, METH_VARARGS | METH_KEYWORDS, NULL},
21032 { (char *)"DC_DrawEllipsePointSize", (PyCFunction) _wrap_DC_DrawEllipsePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21033 { (char *)"DC_DrawIcon", (PyCFunction) _wrap_DC_DrawIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21034 { (char *)"DC_DrawIconPoint", (PyCFunction) _wrap_DC_DrawIconPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21035 { (char *)"DC_DrawBitmap", (PyCFunction) _wrap_DC_DrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21036 { (char *)"DC_DrawBitmapPoint", (PyCFunction) _wrap_DC_DrawBitmapPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21037 { (char *)"DC_DrawText", (PyCFunction) _wrap_DC_DrawText, METH_VARARGS | METH_KEYWORDS, NULL},
21038 { (char *)"DC_DrawTextPoint", (PyCFunction) _wrap_DC_DrawTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21039 { (char *)"DC_DrawRotatedText", (PyCFunction) _wrap_DC_DrawRotatedText, METH_VARARGS | METH_KEYWORDS, NULL},
21040 { (char *)"DC_DrawRotatedTextPoint", (PyCFunction) _wrap_DC_DrawRotatedTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21041 { (char *)"DC_Blit", (PyCFunction) _wrap_DC_Blit, METH_VARARGS | METH_KEYWORDS, NULL},
21042 { (char *)"DC_BlitPointSize", (PyCFunction) _wrap_DC_BlitPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21043 { (char *)"DC_SetClippingRegion", (PyCFunction) _wrap_DC_SetClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21044 { (char *)"DC_SetClippingRegionPointSize", (PyCFunction) _wrap_DC_SetClippingRegionPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21045 { (char *)"DC_SetClippingRegionAsRegion", (PyCFunction) _wrap_DC_SetClippingRegionAsRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21046 { (char *)"DC_SetClippingRect", (PyCFunction) _wrap_DC_SetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
21047 { (char *)"DC_DrawLines", (PyCFunction) _wrap_DC_DrawLines, METH_VARARGS | METH_KEYWORDS, NULL},
21048 { (char *)"DC_DrawPolygon", (PyCFunction) _wrap_DC_DrawPolygon, METH_VARARGS | METH_KEYWORDS, NULL},
21049 { (char *)"DC_DrawLabel", (PyCFunction) _wrap_DC_DrawLabel, METH_VARARGS | METH_KEYWORDS, NULL},
21050 { (char *)"DC_DrawImageLabel", (PyCFunction) _wrap_DC_DrawImageLabel, METH_VARARGS | METH_KEYWORDS, NULL},
21051 { (char *)"DC_DrawSpline", (PyCFunction) _wrap_DC_DrawSpline, METH_VARARGS | METH_KEYWORDS, NULL},
21052 { (char *)"DC_Clear", (PyCFunction) _wrap_DC_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
21053 { (char *)"DC_StartDoc", (PyCFunction) _wrap_DC_StartDoc, METH_VARARGS | METH_KEYWORDS, NULL},
21054 { (char *)"DC_EndDoc", (PyCFunction) _wrap_DC_EndDoc, METH_VARARGS | METH_KEYWORDS, NULL},
21055 { (char *)"DC_StartPage", (PyCFunction) _wrap_DC_StartPage, METH_VARARGS | METH_KEYWORDS, NULL},
21056 { (char *)"DC_EndPage", (PyCFunction) _wrap_DC_EndPage, METH_VARARGS | METH_KEYWORDS, NULL},
21057 { (char *)"DC_SetFont", (PyCFunction) _wrap_DC_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
21058 { (char *)"DC_SetPen", (PyCFunction) _wrap_DC_SetPen, METH_VARARGS | METH_KEYWORDS, NULL},
21059 { (char *)"DC_SetBrush", (PyCFunction) _wrap_DC_SetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21060 { (char *)"DC_SetBackground", (PyCFunction) _wrap_DC_SetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21061 { (char *)"DC_SetBackgroundMode", (PyCFunction) _wrap_DC_SetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
21062 { (char *)"DC_SetPalette", (PyCFunction) _wrap_DC_SetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
21063 { (char *)"DC_DestroyClippingRegion", (PyCFunction) _wrap_DC_DestroyClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21064 { (char *)"DC_GetClippingBox", (PyCFunction) _wrap_DC_GetClippingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21065 { (char *)"DC_GetClippingRect", (PyCFunction) _wrap_DC_GetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
21066 { (char *)"DC_GetCharHeight", (PyCFunction) _wrap_DC_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21067 { (char *)"DC_GetCharWidth", (PyCFunction) _wrap_DC_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21068 { (char *)"DC_GetTextExtent", (PyCFunction) _wrap_DC_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21069 { (char *)"DC_GetFullTextExtent", (PyCFunction) _wrap_DC_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21070 { (char *)"DC_GetMultiLineTextExtent", (PyCFunction) _wrap_DC_GetMultiLineTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21071 { (char *)"DC_GetPartialTextExtents", (PyCFunction) _wrap_DC_GetPartialTextExtents, METH_VARARGS | METH_KEYWORDS, NULL},
21072 { (char *)"DC_GetSize", (PyCFunction) _wrap_DC_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21073 { (char *)"DC_GetSizeTuple", (PyCFunction) _wrap_DC_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21074 { (char *)"DC_GetSizeMM", (PyCFunction) _wrap_DC_GetSizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
21075 { (char *)"DC_GetSizeMMTuple", (PyCFunction) _wrap_DC_GetSizeMMTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21076 { (char *)"DC_DeviceToLogicalX", (PyCFunction) _wrap_DC_DeviceToLogicalX, METH_VARARGS | METH_KEYWORDS, NULL},
21077 { (char *)"DC_DeviceToLogicalY", (PyCFunction) _wrap_DC_DeviceToLogicalY, METH_VARARGS | METH_KEYWORDS, NULL},
21078 { (char *)"DC_DeviceToLogicalXRel", (PyCFunction) _wrap_DC_DeviceToLogicalXRel, METH_VARARGS | METH_KEYWORDS, NULL},
21079 { (char *)"DC_DeviceToLogicalYRel", (PyCFunction) _wrap_DC_DeviceToLogicalYRel, METH_VARARGS | METH_KEYWORDS, NULL},
21080 { (char *)"DC_LogicalToDeviceX", (PyCFunction) _wrap_DC_LogicalToDeviceX, METH_VARARGS | METH_KEYWORDS, NULL},
21081 { (char *)"DC_LogicalToDeviceY", (PyCFunction) _wrap_DC_LogicalToDeviceY, METH_VARARGS | METH_KEYWORDS, NULL},
21082 { (char *)"DC_LogicalToDeviceXRel", (PyCFunction) _wrap_DC_LogicalToDeviceXRel, METH_VARARGS | METH_KEYWORDS, NULL},
21083 { (char *)"DC_LogicalToDeviceYRel", (PyCFunction) _wrap_DC_LogicalToDeviceYRel, METH_VARARGS | METH_KEYWORDS, NULL},
21084 { (char *)"DC_CanDrawBitmap", (PyCFunction) _wrap_DC_CanDrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21085 { (char *)"DC_CanGetTextExtent", (PyCFunction) _wrap_DC_CanGetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21086 { (char *)"DC_GetDepth", (PyCFunction) _wrap_DC_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21087 { (char *)"DC_GetPPI", (PyCFunction) _wrap_DC_GetPPI, METH_VARARGS | METH_KEYWORDS, NULL},
21088 { (char *)"DC_Ok", (PyCFunction) _wrap_DC_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21089 { (char *)"DC_GetBackgroundMode", (PyCFunction) _wrap_DC_GetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
21090 { (char *)"DC_GetBackground", (PyCFunction) _wrap_DC_GetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21091 { (char *)"DC_GetBrush", (PyCFunction) _wrap_DC_GetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21092 { (char *)"DC_GetFont", (PyCFunction) _wrap_DC_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
21093 { (char *)"DC_GetPen", (PyCFunction) _wrap_DC_GetPen, METH_VARARGS | METH_KEYWORDS, NULL},
21094 { (char *)"DC_GetTextBackground", (PyCFunction) _wrap_DC_GetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21095 { (char *)"DC_GetTextForeground", (PyCFunction) _wrap_DC_GetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
21096 { (char *)"DC_SetTextForeground", (PyCFunction) _wrap_DC_SetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
21097 { (char *)"DC_SetTextBackground", (PyCFunction) _wrap_DC_SetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21098 { (char *)"DC_GetMapMode", (PyCFunction) _wrap_DC_GetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
21099 { (char *)"DC_SetMapMode", (PyCFunction) _wrap_DC_SetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
21100 { (char *)"DC_GetUserScale", (PyCFunction) _wrap_DC_GetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
21101 { (char *)"DC_SetUserScale", (PyCFunction) _wrap_DC_SetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
21102 { (char *)"DC_GetLogicalScale", (PyCFunction) _wrap_DC_GetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
21103 { (char *)"DC_SetLogicalScale", (PyCFunction) _wrap_DC_SetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
21104 { (char *)"DC_GetLogicalOrigin", (PyCFunction) _wrap_DC_GetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21105 { (char *)"DC_GetLogicalOriginTuple", (PyCFunction) _wrap_DC_GetLogicalOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21106 { (char *)"DC_SetLogicalOrigin", (PyCFunction) _wrap_DC_SetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21107 { (char *)"DC_SetLogicalOriginPoint", (PyCFunction) _wrap_DC_SetLogicalOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21108 { (char *)"DC_GetDeviceOrigin", (PyCFunction) _wrap_DC_GetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21109 { (char *)"DC_GetDeviceOriginTuple", (PyCFunction) _wrap_DC_GetDeviceOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21110 { (char *)"DC_SetDeviceOrigin", (PyCFunction) _wrap_DC_SetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21111 { (char *)"DC_SetDeviceOriginPoint", (PyCFunction) _wrap_DC_SetDeviceOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21112 { (char *)"DC_SetAxisOrientation", (PyCFunction) _wrap_DC_SetAxisOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
21113 { (char *)"DC_GetLogicalFunction", (PyCFunction) _wrap_DC_GetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
21114 { (char *)"DC_SetLogicalFunction", (PyCFunction) _wrap_DC_SetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
21115 { (char *)"DC_ComputeScaleAndOrigin", (PyCFunction) _wrap_DC_ComputeScaleAndOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21116 { (char *)"DC_CalcBoundingBox", (PyCFunction) _wrap_DC_CalcBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21117 { (char *)"DC_CalcBoundingBoxPoint", (PyCFunction) _wrap_DC_CalcBoundingBoxPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21118 { (char *)"DC_ResetBoundingBox", (PyCFunction) _wrap_DC_ResetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21119 { (char *)"DC_MinX", (PyCFunction) _wrap_DC_MinX, METH_VARARGS | METH_KEYWORDS, NULL},
21120 { (char *)"DC_MaxX", (PyCFunction) _wrap_DC_MaxX, METH_VARARGS | METH_KEYWORDS, NULL},
21121 { (char *)"DC_MinY", (PyCFunction) _wrap_DC_MinY, METH_VARARGS | METH_KEYWORDS, NULL},
21122 { (char *)"DC_MaxY", (PyCFunction) _wrap_DC_MaxY, METH_VARARGS | METH_KEYWORDS, NULL},
21123 { (char *)"DC_GetBoundingBox", (PyCFunction) _wrap_DC_GetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21124 { (char *)"DC__DrawPointList", (PyCFunction) _wrap_DC__DrawPointList, METH_VARARGS | METH_KEYWORDS, NULL},
21125 { (char *)"DC__DrawLineList", (PyCFunction) _wrap_DC__DrawLineList, METH_VARARGS | METH_KEYWORDS, NULL},
21126 { (char *)"DC__DrawRectangleList", (PyCFunction) _wrap_DC__DrawRectangleList, METH_VARARGS | METH_KEYWORDS, NULL},
21127 { (char *)"DC__DrawEllipseList", (PyCFunction) _wrap_DC__DrawEllipseList, METH_VARARGS | METH_KEYWORDS, NULL},
21128 { (char *)"DC__DrawPolygonList", (PyCFunction) _wrap_DC__DrawPolygonList, METH_VARARGS | METH_KEYWORDS, NULL},
21129 { (char *)"DC__DrawTextList", (PyCFunction) _wrap_DC__DrawTextList, METH_VARARGS | METH_KEYWORDS, NULL},
21130 { (char *)"DC_swigregister", DC_swigregister, METH_VARARGS, NULL},
21131 { (char *)"new_MemoryDC", (PyCFunction) _wrap_new_MemoryDC, METH_VARARGS | METH_KEYWORDS, NULL},
21132 { (char *)"new_MemoryDCFromDC", (PyCFunction) _wrap_new_MemoryDCFromDC, METH_VARARGS | METH_KEYWORDS, NULL},
21133 { (char *)"MemoryDC_SelectObject", (PyCFunction) _wrap_MemoryDC_SelectObject, METH_VARARGS | METH_KEYWORDS, NULL},
21134 { (char *)"MemoryDC_swigregister", MemoryDC_swigregister, METH_VARARGS, NULL},
21135 { (char *)"new_BufferedDC", _wrap_new_BufferedDC, METH_VARARGS, NULL},
21136 { (char *)"delete_BufferedDC", (PyCFunction) _wrap_delete_BufferedDC, METH_VARARGS | METH_KEYWORDS, NULL},
21137 { (char *)"BufferedDC_UnMask", (PyCFunction) _wrap_BufferedDC_UnMask, METH_VARARGS | METH_KEYWORDS, NULL},
21138 { (char *)"BufferedDC_swigregister", BufferedDC_swigregister, METH_VARARGS, NULL},
21139 { (char *)"new_BufferedPaintDC", (PyCFunction) _wrap_new_BufferedPaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
21140 { (char *)"BufferedPaintDC_swigregister", BufferedPaintDC_swigregister, METH_VARARGS, NULL},
21141 { (char *)"new_ScreenDC", (PyCFunction) _wrap_new_ScreenDC, METH_VARARGS | METH_KEYWORDS, NULL},
21142 { (char *)"ScreenDC_StartDrawingOnTopWin", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTopWin, METH_VARARGS | METH_KEYWORDS, NULL},
21143 { (char *)"ScreenDC_StartDrawingOnTop", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
21144 { (char *)"ScreenDC_EndDrawingOnTop", (PyCFunction) _wrap_ScreenDC_EndDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
21145 { (char *)"ScreenDC_swigregister", ScreenDC_swigregister, METH_VARARGS, NULL},
21146 { (char *)"new_ClientDC", (PyCFunction) _wrap_new_ClientDC, METH_VARARGS | METH_KEYWORDS, NULL},
21147 { (char *)"ClientDC_swigregister", ClientDC_swigregister, METH_VARARGS, NULL},
21148 { (char *)"new_PaintDC", (PyCFunction) _wrap_new_PaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
21149 { (char *)"PaintDC_swigregister", PaintDC_swigregister, METH_VARARGS, NULL},
21150 { (char *)"new_WindowDC", (PyCFunction) _wrap_new_WindowDC, METH_VARARGS | METH_KEYWORDS, NULL},
21151 { (char *)"WindowDC_swigregister", WindowDC_swigregister, METH_VARARGS, NULL},
21152 { (char *)"new_MirrorDC", (PyCFunction) _wrap_new_MirrorDC, METH_VARARGS | METH_KEYWORDS, NULL},
21153 { (char *)"MirrorDC_swigregister", MirrorDC_swigregister, METH_VARARGS, NULL},
21154 { (char *)"new_PostScriptDC", (PyCFunction) _wrap_new_PostScriptDC, METH_VARARGS | METH_KEYWORDS, NULL},
21155 { (char *)"PostScriptDC_GetPrintData", (PyCFunction) _wrap_PostScriptDC_GetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
21156 { (char *)"PostScriptDC_SetPrintData", (PyCFunction) _wrap_PostScriptDC_SetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
21157 { (char *)"PostScriptDC_SetResolution", (PyCFunction) _wrap_PostScriptDC_SetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
21158 { (char *)"PostScriptDC_GetResolution", (PyCFunction) _wrap_PostScriptDC_GetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
21159 { (char *)"PostScriptDC_swigregister", PostScriptDC_swigregister, METH_VARARGS, NULL},
21160 { (char *)"new_MetaFile", (PyCFunction) _wrap_new_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
21161 { (char *)"delete_MetaFile", (PyCFunction) _wrap_delete_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
21162 { (char *)"MetaFile_Ok", (PyCFunction) _wrap_MetaFile_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21163 { (char *)"MetaFile_SetClipboard", (PyCFunction) _wrap_MetaFile_SetClipboard, METH_VARARGS | METH_KEYWORDS, NULL},
21164 { (char *)"MetaFile_GetSize", (PyCFunction) _wrap_MetaFile_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21165 { (char *)"MetaFile_GetWidth", (PyCFunction) _wrap_MetaFile_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21166 { (char *)"MetaFile_GetHeight", (PyCFunction) _wrap_MetaFile_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21167 { (char *)"MetaFile_swigregister", MetaFile_swigregister, METH_VARARGS, NULL},
21168 { (char *)"new_MetaFileDC", (PyCFunction) _wrap_new_MetaFileDC, METH_VARARGS | METH_KEYWORDS, NULL},
21169 { (char *)"MetaFileDC_Close", (PyCFunction) _wrap_MetaFileDC_Close, METH_VARARGS | METH_KEYWORDS, NULL},
21170 { (char *)"MetaFileDC_swigregister", MetaFileDC_swigregister, METH_VARARGS, NULL},
21171 { (char *)"new_PrinterDC", (PyCFunction) _wrap_new_PrinterDC, METH_VARARGS | METH_KEYWORDS, NULL},
21172 { (char *)"PrinterDC_swigregister", PrinterDC_swigregister, METH_VARARGS, NULL},
21173 { (char *)"new_ImageList", (PyCFunction) _wrap_new_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
21174 { (char *)"delete_ImageList", (PyCFunction) _wrap_delete_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
21175 { (char *)"ImageList_Add", (PyCFunction) _wrap_ImageList_Add, METH_VARARGS | METH_KEYWORDS, NULL},
21176 { (char *)"ImageList_AddWithColourMask", (PyCFunction) _wrap_ImageList_AddWithColourMask, METH_VARARGS | METH_KEYWORDS, NULL},
21177 { (char *)"ImageList_AddIcon", (PyCFunction) _wrap_ImageList_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21178 { (char *)"ImageList_GetBitmap", (PyCFunction) _wrap_ImageList_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21179 { (char *)"ImageList_GetIcon", (PyCFunction) _wrap_ImageList_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21180 { (char *)"ImageList_Replace", (PyCFunction) _wrap_ImageList_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
21181 { (char *)"ImageList_Draw", (PyCFunction) _wrap_ImageList_Draw, METH_VARARGS | METH_KEYWORDS, NULL},
21182 { (char *)"ImageList_GetImageCount", (PyCFunction) _wrap_ImageList_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
21183 { (char *)"ImageList_Remove", (PyCFunction) _wrap_ImageList_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
21184 { (char *)"ImageList_RemoveAll", (PyCFunction) _wrap_ImageList_RemoveAll, METH_VARARGS | METH_KEYWORDS, NULL},
21185 { (char *)"ImageList_GetSize", (PyCFunction) _wrap_ImageList_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21186 { (char *)"ImageList_swigregister", ImageList_swigregister, METH_VARARGS, NULL},
21187 { (char *)"PenList_AddPen", (PyCFunction) _wrap_PenList_AddPen, METH_VARARGS | METH_KEYWORDS, NULL},
21188 { (char *)"PenList_FindOrCreatePen", (PyCFunction) _wrap_PenList_FindOrCreatePen, METH_VARARGS | METH_KEYWORDS, NULL},
21189 { (char *)"PenList_RemovePen", (PyCFunction) _wrap_PenList_RemovePen, METH_VARARGS | METH_KEYWORDS, NULL},
21190 { (char *)"PenList_GetCount", (PyCFunction) _wrap_PenList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
21191 { (char *)"PenList_swigregister", PenList_swigregister, METH_VARARGS, NULL},
21192 { (char *)"BrushList_AddBrush", (PyCFunction) _wrap_BrushList_AddBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21193 { (char *)"BrushList_FindOrCreateBrush", (PyCFunction) _wrap_BrushList_FindOrCreateBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21194 { (char *)"BrushList_RemoveBrush", (PyCFunction) _wrap_BrushList_RemoveBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21195 { (char *)"BrushList_GetCount", (PyCFunction) _wrap_BrushList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
21196 { (char *)"BrushList_swigregister", BrushList_swigregister, METH_VARARGS, NULL},
21197 { (char *)"new_ColourDatabase", (PyCFunction) _wrap_new_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
21198 { (char *)"delete_ColourDatabase", (PyCFunction) _wrap_delete_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
21199 { (char *)"ColourDatabase_Find", (PyCFunction) _wrap_ColourDatabase_Find, METH_VARARGS | METH_KEYWORDS, NULL},
21200 { (char *)"ColourDatabase_FindName", (PyCFunction) _wrap_ColourDatabase_FindName, METH_VARARGS | METH_KEYWORDS, NULL},
21201 { (char *)"ColourDatabase_AddColour", (PyCFunction) _wrap_ColourDatabase_AddColour, METH_VARARGS | METH_KEYWORDS, NULL},
21202 { (char *)"ColourDatabase_Append", (PyCFunction) _wrap_ColourDatabase_Append, METH_VARARGS | METH_KEYWORDS, NULL},
21203 { (char *)"ColourDatabase_swigregister", ColourDatabase_swigregister, METH_VARARGS, NULL},
21204 { (char *)"FontList_AddFont", (PyCFunction) _wrap_FontList_AddFont, METH_VARARGS | METH_KEYWORDS, NULL},
21205 { (char *)"FontList_FindOrCreateFont", (PyCFunction) _wrap_FontList_FindOrCreateFont, METH_VARARGS | METH_KEYWORDS, NULL},
21206 { (char *)"FontList_RemoveFont", (PyCFunction) _wrap_FontList_RemoveFont, METH_VARARGS | METH_KEYWORDS, NULL},
21207 { (char *)"FontList_GetCount", (PyCFunction) _wrap_FontList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
21208 { (char *)"FontList_swigregister", FontList_swigregister, METH_VARARGS, NULL},
21209 { (char *)"new_Effects", (PyCFunction) _wrap_new_Effects, METH_VARARGS | METH_KEYWORDS, NULL},
21210 { (char *)"Effects_GetHighlightColour", (PyCFunction) _wrap_Effects_GetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
21211 { (char *)"Effects_GetLightShadow", (PyCFunction) _wrap_Effects_GetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21212 { (char *)"Effects_GetFaceColour", (PyCFunction) _wrap_Effects_GetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
21213 { (char *)"Effects_GetMediumShadow", (PyCFunction) _wrap_Effects_GetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21214 { (char *)"Effects_GetDarkShadow", (PyCFunction) _wrap_Effects_GetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21215 { (char *)"Effects_SetHighlightColour", (PyCFunction) _wrap_Effects_SetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
21216 { (char *)"Effects_SetLightShadow", (PyCFunction) _wrap_Effects_SetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21217 { (char *)"Effects_SetFaceColour", (PyCFunction) _wrap_Effects_SetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
21218 { (char *)"Effects_SetMediumShadow", (PyCFunction) _wrap_Effects_SetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21219 { (char *)"Effects_SetDarkShadow", (PyCFunction) _wrap_Effects_SetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21220 { (char *)"Effects_Set", (PyCFunction) _wrap_Effects_Set, METH_VARARGS | METH_KEYWORDS, NULL},
21221 { (char *)"Effects_DrawSunkenEdge", (PyCFunction) _wrap_Effects_DrawSunkenEdge, METH_VARARGS | METH_KEYWORDS, NULL},
21222 { (char *)"Effects_TileBitmap", (PyCFunction) _wrap_Effects_TileBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21223 { (char *)"Effects_swigregister", Effects_swigregister, METH_VARARGS, NULL},
21224 { NULL, NULL, 0, NULL }
21225 };
21226
21227
21228 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
21229
21230 static void *_p_wxBufferedDCTo_p_wxMemoryDC(void *x) {
21231 return (void *)((wxMemoryDC *) ((wxBufferedDC *) x));
21232 }
21233 static void *_p_wxBufferedPaintDCTo_p_wxMemoryDC(void *x) {
21234 return (void *)((wxMemoryDC *) (wxBufferedDC *) ((wxBufferedPaintDC *) x));
21235 }
21236 static void *_p_wxIconTo_p_wxGDIObject(void *x) {
21237 return (void *)((wxGDIObject *) ((wxIcon *) x));
21238 }
21239 static void *_p_wxPaletteTo_p_wxGDIObject(void *x) {
21240 return (void *)((wxGDIObject *) ((wxPalette *) x));
21241 }
21242 static void *_p_wxPenTo_p_wxGDIObject(void *x) {
21243 return (void *)((wxGDIObject *) ((wxPen *) x));
21244 }
21245 static void *_p_wxFontTo_p_wxGDIObject(void *x) {
21246 return (void *)((wxGDIObject *) ((wxFont *) x));
21247 }
21248 static void *_p_wxCursorTo_p_wxGDIObject(void *x) {
21249 return (void *)((wxGDIObject *) ((wxCursor *) x));
21250 }
21251 static void *_p_wxBitmapTo_p_wxGDIObject(void *x) {
21252 return (void *)((wxGDIObject *) ((wxBitmap *) x));
21253 }
21254 static void *_p_wxRegionTo_p_wxGDIObject(void *x) {
21255 return (void *)((wxGDIObject *) ((wxRegion *) x));
21256 }
21257 static void *_p_wxBrushTo_p_wxGDIObject(void *x) {
21258 return (void *)((wxGDIObject *) ((wxBrush *) x));
21259 }
21260 static void *_p_wxBufferedDCTo_p_wxDC(void *x) {
21261 return (void *)((wxDC *) (wxMemoryDC *) ((wxBufferedDC *) x));
21262 }
21263 static void *_p_wxScreenDCTo_p_wxDC(void *x) {
21264 return (void *)((wxDC *) ((wxScreenDC *) x));
21265 }
21266 static void *_p_wxMirrorDCTo_p_wxDC(void *x) {
21267 return (void *)((wxDC *) ((wxMirrorDC *) x));
21268 }
21269 static void *_p_wxMemoryDCTo_p_wxDC(void *x) {
21270 return (void *)((wxDC *) ((wxMemoryDC *) x));
21271 }
21272 static void *_p_wxWindowDCTo_p_wxDC(void *x) {
21273 return (void *)((wxDC *) ((wxWindowDC *) x));
21274 }
21275 static void *_p_wxMetaFileDCTo_p_wxDC(void *x) {
21276 return (void *)((wxDC *) ((wxMetaFileDC *) x));
21277 }
21278 static void *_p_wxBufferedPaintDCTo_p_wxDC(void *x) {
21279 return (void *)((wxDC *) (wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
21280 }
21281 static void *_p_wxClientDCTo_p_wxDC(void *x) {
21282 return (void *)((wxDC *) ((wxClientDC *) x));
21283 }
21284 static void *_p_wxPaintDCTo_p_wxDC(void *x) {
21285 return (void *)((wxDC *) ((wxPaintDC *) x));
21286 }
21287 static void *_p_wxPostScriptDCTo_p_wxDC(void *x) {
21288 return (void *)((wxDC *) ((wxPostScriptDC *) x));
21289 }
21290 static void *_p_wxPrinterDCTo_p_wxDC(void *x) {
21291 return (void *)((wxDC *) ((wxPrinterDC *) x));
21292 }
21293 static void *_p_wxBufferedPaintDCTo_p_wxBufferedDC(void *x) {
21294 return (void *)((wxBufferedDC *) ((wxBufferedPaintDC *) x));
21295 }
21296 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
21297 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
21298 }
21299 static void *_p_wxPenTo_p_wxObject(void *x) {
21300 return (void *)((wxObject *) (wxGDIObject *) ((wxPen *) x));
21301 }
21302 static void *_p_wxRegionIteratorTo_p_wxObject(void *x) {
21303 return (void *)((wxObject *) ((wxRegionIterator *) x));
21304 }
21305 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
21306 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
21307 }
21308 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
21309 return (void *)((wxObject *) ((wxSizerItem *) x));
21310 }
21311 static void *_p_wxColourDatabaseTo_p_wxObject(void *x) {
21312 return (void *)((wxObject *) ((wxColourDatabase *) x));
21313 }
21314 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
21315 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
21316 }
21317 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
21318 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
21319 }
21320 static void *_p_wxIconTo_p_wxObject(void *x) {
21321 return (void *)((wxObject *) (wxGDIObject *) ((wxIcon *) x));
21322 }
21323 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
21324 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
21325 }
21326 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
21327 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
21328 }
21329 static void *_p_wxSizerTo_p_wxObject(void *x) {
21330 return (void *)((wxObject *) ((wxSizer *) x));
21331 }
21332 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
21333 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
21334 }
21335 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
21336 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
21337 }
21338 static void *_p_wxPenListTo_p_wxObject(void *x) {
21339 return (void *)((wxObject *) ((wxPenList *) x));
21340 }
21341 static void *_p_wxEventTo_p_wxObject(void *x) {
21342 return (void *)((wxObject *) ((wxEvent *) x));
21343 }
21344 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
21345 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
21346 }
21347 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
21348 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
21349 }
21350 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
21351 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
21352 }
21353 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
21354 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
21355 }
21356 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
21357 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
21358 }
21359 static void *_p_wxDCTo_p_wxObject(void *x) {
21360 return (void *)((wxObject *) ((wxDC *) x));
21361 }
21362 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
21363 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
21364 }
21365 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
21366 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
21367 }
21368 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
21369 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
21370 }
21371 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
21372 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
21373 }
21374 static void *_p_wxControlTo_p_wxObject(void *x) {
21375 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
21376 }
21377 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
21378 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
21379 }
21380 static void *_p_wxClientDCTo_p_wxObject(void *x) {
21381 return (void *)((wxObject *) (wxDC *) ((wxClientDC *) x));
21382 }
21383 static void *_p_wxFSFileTo_p_wxObject(void *x) {
21384 return (void *)((wxObject *) ((wxFSFile *) x));
21385 }
21386 static void *_p_wxMemoryDCTo_p_wxObject(void *x) {
21387 return (void *)((wxObject *) (wxDC *) ((wxMemoryDC *) x));
21388 }
21389 static void *_p_wxRegionTo_p_wxObject(void *x) {
21390 return (void *)((wxObject *) (wxGDIObject *) ((wxRegion *) x));
21391 }
21392 static void *_p_wxPySizerTo_p_wxObject(void *x) {
21393 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
21394 }
21395 static void *_p_wxWindowDCTo_p_wxObject(void *x) {
21396 return (void *)((wxObject *) (wxDC *) ((wxWindowDC *) x));
21397 }
21398 static void *_p_wxGDIObjectTo_p_wxObject(void *x) {
21399 return (void *)((wxObject *) ((wxGDIObject *) x));
21400 }
21401 static void *_p_wxEffectsTo_p_wxObject(void *x) {
21402 return (void *)((wxObject *) ((wxEffects *) x));
21403 }
21404 static void *_p_wxPyEventTo_p_wxObject(void *x) {
21405 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
21406 }
21407 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
21408 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
21409 }
21410 static void *_p_wxPostScriptDCTo_p_wxObject(void *x) {
21411 return (void *)((wxObject *) (wxDC *) ((wxPostScriptDC *) x));
21412 }
21413 static void *_p_wxShowEventTo_p_wxObject(void *x) {
21414 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
21415 }
21416 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
21417 return (void *)((wxObject *) ((wxMenuItem *) x));
21418 }
21419 static void *_p_wxDateEventTo_p_wxObject(void *x) {
21420 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
21421 }
21422 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
21423 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
21424 }
21425 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
21426 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
21427 }
21428 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
21429 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
21430 }
21431 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
21432 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
21433 }
21434 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
21435 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
21436 }
21437 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
21438 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
21439 }
21440 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
21441 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
21442 }
21443 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
21444 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
21445 }
21446 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
21447 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
21448 }
21449 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
21450 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
21451 }
21452 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
21453 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
21454 }
21455 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
21456 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
21457 }
21458 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
21459 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
21460 }
21461 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
21462 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
21463 }
21464 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
21465 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
21466 }
21467 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
21468 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
21469 }
21470 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
21471 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
21472 }
21473 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
21474 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
21475 }
21476 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
21477 return (void *)((wxObject *) ((wxImageHandler *) x));
21478 }
21479 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
21480 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
21481 }
21482 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
21483 return (void *)((wxObject *) ((wxEvtHandler *) x));
21484 }
21485 static void *_p_wxBufferedPaintDCTo_p_wxObject(void *x) {
21486 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
21487 }
21488 static void *_p_wxPaintDCTo_p_wxObject(void *x) {
21489 return (void *)((wxObject *) (wxDC *) ((wxPaintDC *) x));
21490 }
21491 static void *_p_wxPrinterDCTo_p_wxObject(void *x) {
21492 return (void *)((wxObject *) (wxDC *) ((wxPrinterDC *) x));
21493 }
21494 static void *_p_wxScreenDCTo_p_wxObject(void *x) {
21495 return (void *)((wxObject *) (wxDC *) ((wxScreenDC *) x));
21496 }
21497 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
21498 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
21499 }
21500 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
21501 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
21502 }
21503 static void *_p_wxImageTo_p_wxObject(void *x) {
21504 return (void *)((wxObject *) ((wxImage *) x));
21505 }
21506 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
21507 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
21508 }
21509 static void *_p_wxPaletteTo_p_wxObject(void *x) {
21510 return (void *)((wxObject *) (wxGDIObject *) ((wxPalette *) x));
21511 }
21512 static void *_p_wxBufferedDCTo_p_wxObject(void *x) {
21513 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *) ((wxBufferedDC *) x));
21514 }
21515 static void *_p_wxImageListTo_p_wxObject(void *x) {
21516 return (void *)((wxObject *) ((wxImageList *) x));
21517 }
21518 static void *_p_wxCursorTo_p_wxObject(void *x) {
21519 return (void *)((wxObject *) (wxGDIObject *) ((wxCursor *) x));
21520 }
21521 static void *_p_wxEncodingConverterTo_p_wxObject(void *x) {
21522 return (void *)((wxObject *) ((wxEncodingConverter *) x));
21523 }
21524 static void *_p_wxMirrorDCTo_p_wxObject(void *x) {
21525 return (void *)((wxObject *) (wxDC *) ((wxMirrorDC *) x));
21526 }
21527 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
21528 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21529 }
21530 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
21531 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
21532 }
21533 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
21534 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
21535 }
21536 static void *_p_wxWindowTo_p_wxObject(void *x) {
21537 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
21538 }
21539 static void *_p_wxMenuTo_p_wxObject(void *x) {
21540 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
21541 }
21542 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
21543 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
21544 }
21545 static void *_p_wxMetaFileDCTo_p_wxObject(void *x) {
21546 return (void *)((wxObject *) (wxDC *) ((wxMetaFileDC *) x));
21547 }
21548 static void *_p_wxBrushListTo_p_wxObject(void *x) {
21549 return (void *)((wxObject *) ((wxBrushList *) x));
21550 }
21551 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
21552 return (void *)((wxObject *) ((wxFileSystem *) x));
21553 }
21554 static void *_p_wxBitmapTo_p_wxObject(void *x) {
21555 return (void *)((wxObject *) (wxGDIObject *) ((wxBitmap *) x));
21556 }
21557 static void *_p_wxMaskTo_p_wxObject(void *x) {
21558 return (void *)((wxObject *) ((wxMask *) x));
21559 }
21560 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
21561 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
21562 }
21563 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
21564 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
21565 }
21566 static void *_p_wxPyAppTo_p_wxObject(void *x) {
21567 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
21568 }
21569 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
21570 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
21571 }
21572 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
21573 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
21574 }
21575 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
21576 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
21577 }
21578 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
21579 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
21580 }
21581 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
21582 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
21583 }
21584 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
21585 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
21586 }
21587 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
21588 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
21589 }
21590 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
21591 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
21592 }
21593 static void *_p_wxFontTo_p_wxObject(void *x) {
21594 return (void *)((wxObject *) (wxGDIObject *) ((wxFont *) x));
21595 }
21596 static void *_p_wxBrushTo_p_wxObject(void *x) {
21597 return (void *)((wxObject *) (wxGDIObject *) ((wxBrush *) x));
21598 }
21599 static void *_p_wxMetaFileTo_p_wxObject(void *x) {
21600 return (void *)((wxObject *) ((wxMetaFile *) x));
21601 }
21602 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
21603 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
21604 }
21605 static void *_p_wxColourTo_p_wxObject(void *x) {
21606 return (void *)((wxObject *) ((wxColour *) x));
21607 }
21608 static void *_p_wxFontListTo_p_wxObject(void *x) {
21609 return (void *)((wxObject *) ((wxFontList *) x));
21610 }
21611 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
21612 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
21613 }
21614 static void *_p_wxValidatorTo_p_wxObject(void *x) {
21615 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
21616 }
21617 static void *_p_wxControlTo_p_wxWindow(void *x) {
21618 return (void *)((wxWindow *) ((wxControl *) x));
21619 }
21620 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
21621 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
21622 }
21623 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
21624 return (void *)((wxWindow *) ((wxMenuBar *) x));
21625 }
21626 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}};
21627 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}};
21628 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}};
21629 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}};
21630 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}};
21631 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}};
21632 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}};
21633 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}};
21634 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}};
21635 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}};
21636 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}};
21637 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}};
21638 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}};
21639 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}};
21640 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}};
21641 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}};
21642 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}};
21643 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}};
21644 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}};
21645 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}};
21646 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}};
21647 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}};
21648 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}};
21649 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}};
21650 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}};
21651 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}};
21652 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}};
21653 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}};
21654 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}};
21655 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}};
21656 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}};
21657 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}};
21658 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}};
21659 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}};
21660 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}};
21661 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}};
21662 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}};
21663 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}};
21664 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}};
21665 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}};
21666 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}};
21667 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}};
21668 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}};
21669 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}};
21670 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}};
21671 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}};
21672 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}};
21673 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}};
21674 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}};
21675 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}};
21676 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}};
21677 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}};
21678 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}};
21679 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}};
21680 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}};
21681 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}};
21682 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}};
21683 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}};
21684 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}};
21685 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}};
21686 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}};
21687 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}};
21688
21689 static swig_type_info *swig_types_initial[] = {
21690 _swigt__p_wxPostScriptDC,
21691 _swigt__p_wxBrush,
21692 _swigt__p_wxColour,
21693 _swigt__p_wxDC,
21694 _swigt__p_wxMirrorDC,
21695 _swigt__p_form_ops_t,
21696 _swigt__p_wxDuplexMode,
21697 _swigt__p_wxPyFontEnumerator,
21698 _swigt__p_char,
21699 _swigt__p_wxIconLocation,
21700 _swigt__p_wxImage,
21701 _swigt__p_wxMetaFileDC,
21702 _swigt__p_wxMask,
21703 _swigt__p_wxSize,
21704 _swigt__p_wxFont,
21705 _swigt__p_wxWindow,
21706 _swigt__p_double,
21707 _swigt__p_wxMemoryDC,
21708 _swigt__p_wxFontMapper,
21709 _swigt__p_wxEffects,
21710 _swigt__p_wxNativeEncodingInfo,
21711 _swigt__p_wxPalette,
21712 _swigt__p_wxBitmap,
21713 _swigt__p_wxObject,
21714 _swigt__p_wxRegionIterator,
21715 _swigt__p_wxRect,
21716 _swigt__p_wxPaperSize,
21717 _swigt__p_wxString,
21718 _swigt__unsigned_int,
21719 _swigt__p_unsigned_int,
21720 _swigt__p_wxPrinterDC,
21721 _swigt__p_wxIconBundle,
21722 _swigt__p_wxPoint,
21723 _swigt__p_wxDash,
21724 _swigt__p_wxScreenDC,
21725 _swigt__p_wxCursor,
21726 _swigt__p_wxClientDC,
21727 _swigt__p_wxBufferedDC,
21728 _swigt__p_wxImageList,
21729 _swigt__p_unsigned_char,
21730 _swigt__p_wxGDIObject,
21731 _swigt__p_wxIcon,
21732 _swigt__p_wxLocale,
21733 _swigt__ptrdiff_t,
21734 _swigt__std__ptrdiff_t,
21735 _swigt__p_wxRegion,
21736 _swigt__p_wxConfigBase,
21737 _swigt__p_wxLanguageInfo,
21738 _swigt__p_wxWindowDC,
21739 _swigt__p_wxPrintData,
21740 _swigt__p_wxBrushList,
21741 _swigt__p_wxFontList,
21742 _swigt__p_wxPen,
21743 _swigt__p_wxBufferedPaintDC,
21744 _swigt__p_wxPaintDC,
21745 _swigt__p_wxPenList,
21746 _swigt__p_int,
21747 _swigt__p_wxMetaFile,
21748 _swigt__p_unsigned_long,
21749 _swigt__p_wxNativeFontInfo,
21750 _swigt__p_wxEncodingConverter,
21751 _swigt__p_wxColourDatabase,
21752 0
21753 };
21754
21755
21756 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
21757
21758 static swig_const_info swig_const_table[] = {
21759 {0, 0, 0, 0.0, 0, 0}};
21760
21761 #ifdef __cplusplus
21762 }
21763 #endif
21764
21765
21766 #ifdef __cplusplus
21767 extern "C" {
21768 #endif
21769
21770 /* Python-specific SWIG API */
21771 #define SWIG_newvarlink() SWIG_Python_newvarlink()
21772 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
21773 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
21774
21775 /* -----------------------------------------------------------------------------
21776 * global variable support code.
21777 * ----------------------------------------------------------------------------- */
21778
21779 typedef struct swig_globalvar {
21780 char *name; /* Name of global variable */
21781 PyObject *(*get_attr)(); /* Return the current value */
21782 int (*set_attr)(PyObject *); /* Set the value */
21783 struct swig_globalvar *next;
21784 } swig_globalvar;
21785
21786 typedef struct swig_varlinkobject {
21787 PyObject_HEAD
21788 swig_globalvar *vars;
21789 } swig_varlinkobject;
21790
21791 static PyObject *
21792 swig_varlink_repr(swig_varlinkobject *v) {
21793 v = v;
21794 return PyString_FromString("<Swig global variables>");
21795 }
21796
21797 static int
21798 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
21799 swig_globalvar *var;
21800 flags = flags;
21801 fprintf(fp,"Swig global variables { ");
21802 for (var = v->vars; var; var=var->next) {
21803 fprintf(fp,"%s", var->name);
21804 if (var->next) fprintf(fp,", ");
21805 }
21806 fprintf(fp," }\n");
21807 return 0;
21808 }
21809
21810 static PyObject *
21811 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
21812 swig_globalvar *var = v->vars;
21813 while (var) {
21814 if (strcmp(var->name,n) == 0) {
21815 return (*var->get_attr)();
21816 }
21817 var = var->next;
21818 }
21819 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
21820 return NULL;
21821 }
21822
21823 static int
21824 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
21825 swig_globalvar *var = v->vars;
21826 while (var) {
21827 if (strcmp(var->name,n) == 0) {
21828 return (*var->set_attr)(p);
21829 }
21830 var = var->next;
21831 }
21832 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
21833 return 1;
21834 }
21835
21836 static PyTypeObject varlinktype = {
21837 PyObject_HEAD_INIT(0)
21838 0, /* Number of items in variable part (ob_size) */
21839 (char *)"swigvarlink", /* Type name (tp_name) */
21840 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
21841 0, /* Itemsize (tp_itemsize) */
21842 0, /* Deallocator (tp_dealloc) */
21843 (printfunc) swig_varlink_print, /* Print (tp_print) */
21844 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
21845 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
21846 0, /* tp_compare */
21847 (reprfunc) swig_varlink_repr, /* tp_repr */
21848 0, /* tp_as_number */
21849 0, /* tp_as_sequence */
21850 0, /* tp_as_mapping */
21851 0, /* tp_hash */
21852 0, /* tp_call */
21853 0, /* tp_str */
21854 0, /* tp_getattro */
21855 0, /* tp_setattro */
21856 0, /* tp_as_buffer */
21857 0, /* tp_flags */
21858 0, /* tp_doc */
21859 #if PY_VERSION_HEX >= 0x02000000
21860 0, /* tp_traverse */
21861 0, /* tp_clear */
21862 #endif
21863 #if PY_VERSION_HEX >= 0x02010000
21864 0, /* tp_richcompare */
21865 0, /* tp_weaklistoffset */
21866 #endif
21867 #if PY_VERSION_HEX >= 0x02020000
21868 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
21869 #endif
21870 #if PY_VERSION_HEX >= 0x02030000
21871 0, /* tp_del */
21872 #endif
21873 #ifdef COUNT_ALLOCS
21874 0,0,0,0 /* tp_alloc -> tp_next */
21875 #endif
21876 };
21877
21878 /* Create a variable linking object for use later */
21879 static PyObject *
21880 SWIG_Python_newvarlink(void) {
21881 swig_varlinkobject *result = 0;
21882 result = PyMem_NEW(swig_varlinkobject,1);
21883 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
21884 result->ob_type = &varlinktype;
21885 result->vars = 0;
21886 result->ob_refcnt = 0;
21887 Py_XINCREF((PyObject *) result);
21888 return ((PyObject*) result);
21889 }
21890
21891 static void
21892 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
21893 swig_varlinkobject *v;
21894 swig_globalvar *gv;
21895 v= (swig_varlinkobject *) p;
21896 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
21897 gv->name = (char *) malloc(strlen(name)+1);
21898 strcpy(gv->name,name);
21899 gv->get_attr = get_attr;
21900 gv->set_attr = set_attr;
21901 gv->next = v->vars;
21902 v->vars = gv;
21903 }
21904
21905 /* -----------------------------------------------------------------------------
21906 * constants/methods manipulation
21907 * ----------------------------------------------------------------------------- */
21908
21909 /* Install Constants */
21910 static void
21911 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
21912 PyObject *obj = 0;
21913 size_t i;
21914 for (i = 0; constants[i].type; i++) {
21915 switch(constants[i].type) {
21916 case SWIG_PY_INT:
21917 obj = PyInt_FromLong(constants[i].lvalue);
21918 break;
21919 case SWIG_PY_FLOAT:
21920 obj = PyFloat_FromDouble(constants[i].dvalue);
21921 break;
21922 case SWIG_PY_STRING:
21923 if (constants[i].pvalue) {
21924 obj = PyString_FromString((char *) constants[i].pvalue);
21925 } else {
21926 Py_INCREF(Py_None);
21927 obj = Py_None;
21928 }
21929 break;
21930 case SWIG_PY_POINTER:
21931 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
21932 break;
21933 case SWIG_PY_BINARY:
21934 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
21935 break;
21936 default:
21937 obj = 0;
21938 break;
21939 }
21940 if (obj) {
21941 PyDict_SetItemString(d,constants[i].name,obj);
21942 Py_DECREF(obj);
21943 }
21944 }
21945 }
21946
21947 /* -----------------------------------------------------------------------------*/
21948 /* Fix SwigMethods to carry the callback ptrs when needed */
21949 /* -----------------------------------------------------------------------------*/
21950
21951 static void
21952 SWIG_Python_FixMethods(PyMethodDef *methods,
21953 swig_const_info *const_table,
21954 swig_type_info **types,
21955 swig_type_info **types_initial) {
21956 size_t i;
21957 for (i = 0; methods[i].ml_name; ++i) {
21958 char *c = methods[i].ml_doc;
21959 if (c && (c = strstr(c, "swig_ptr: "))) {
21960 int j;
21961 swig_const_info *ci = 0;
21962 char *name = c + 10;
21963 for (j = 0; const_table[j].type; j++) {
21964 if (strncmp(const_table[j].name, name,
21965 strlen(const_table[j].name)) == 0) {
21966 ci = &(const_table[j]);
21967 break;
21968 }
21969 }
21970 if (ci) {
21971 size_t shift = (ci->ptype) - types;
21972 swig_type_info *ty = types_initial[shift];
21973 size_t ldoc = (c - methods[i].ml_doc);
21974 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
21975 char *ndoc = (char*)malloc(ldoc + lptr + 10);
21976 char *buff = ndoc;
21977 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
21978 strncpy(buff, methods[i].ml_doc, ldoc);
21979 buff += ldoc;
21980 strncpy(buff, "swig_ptr: ", 10);
21981 buff += 10;
21982 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
21983 methods[i].ml_doc = ndoc;
21984 }
21985 }
21986 }
21987 }
21988
21989 /* -----------------------------------------------------------------------------*
21990 * Initialize type list
21991 * -----------------------------------------------------------------------------*/
21992
21993 #if PY_MAJOR_VERSION < 2
21994 /* PyModule_AddObject function was introduced in Python 2.0. The following function
21995 is copied out of Python/modsupport.c in python version 2.3.4 */
21996 static int
21997 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
21998 {
21999 PyObject *dict;
22000 if (!PyModule_Check(m)) {
22001 PyErr_SetString(PyExc_TypeError,
22002 "PyModule_AddObject() needs module as first arg");
22003 return -1;
22004 }
22005 if (!o) {
22006 PyErr_SetString(PyExc_TypeError,
22007 "PyModule_AddObject() needs non-NULL value");
22008 return -1;
22009 }
22010
22011 dict = PyModule_GetDict(m);
22012 if (dict == NULL) {
22013 /* Internal error -- modules must have a dict! */
22014 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
22015 PyModule_GetName(m));
22016 return -1;
22017 }
22018 if (PyDict_SetItemString(dict, name, o))
22019 return -1;
22020 Py_DECREF(o);
22021 return 0;
22022 }
22023 #endif
22024
22025 static swig_type_info **
22026 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
22027 static PyMethodDef swig_empty_runtime_method_table[] = {
22028 {
22029 NULL, NULL, 0, NULL
22030 }
22031 };/* Sentinel */
22032
22033 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
22034 swig_empty_runtime_method_table);
22035 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
22036 if (pointer && module) {
22037 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
22038 }
22039 return type_list_handle;
22040 }
22041
22042 static swig_type_info **
22043 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
22044 swig_type_info **type_pointer;
22045
22046 /* first check if module already created */
22047 type_pointer = SWIG_Python_GetTypeListHandle();
22048 if (type_pointer) {
22049 return type_pointer;
22050 } else {
22051 /* create a new module and variable */
22052 return SWIG_Python_SetTypeListHandle(type_list_handle);
22053 }
22054 }
22055
22056 #ifdef __cplusplus
22057 }
22058 #endif
22059
22060 /* -----------------------------------------------------------------------------*
22061 * Partial Init method
22062 * -----------------------------------------------------------------------------*/
22063
22064 #ifdef SWIG_LINK_RUNTIME
22065 #ifdef __cplusplus
22066 extern "C"
22067 #endif
22068 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
22069 #endif
22070
22071 #ifdef __cplusplus
22072 extern "C"
22073 #endif
22074 SWIGEXPORT(void) SWIG_init(void) {
22075 static PyObject *SWIG_globals = 0;
22076 static int typeinit = 0;
22077 PyObject *m, *d;
22078 int i;
22079 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
22080
22081 /* Fix SwigMethods to carry the callback ptrs when needed */
22082 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
22083
22084 m = Py_InitModule((char *) SWIG_name, SwigMethods);
22085 d = PyModule_GetDict(m);
22086
22087 if (!typeinit) {
22088 #ifdef SWIG_LINK_RUNTIME
22089 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
22090 #else
22091 # ifndef SWIG_STATIC_RUNTIME
22092 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
22093 # endif
22094 #endif
22095 for (i = 0; swig_types_initial[i]; i++) {
22096 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
22097 }
22098 typeinit = 1;
22099 }
22100 SWIG_InstallConstants(d,swig_const_table);
22101
22102 {
22103 PyDict_SetItemString(d,"OutRegion", SWIG_From_int((int)(wxOutRegion)));
22104 }
22105 {
22106 PyDict_SetItemString(d,"PartRegion", SWIG_From_int((int)(wxPartRegion)));
22107 }
22108 {
22109 PyDict_SetItemString(d,"InRegion", SWIG_From_int((int)(wxInRegion)));
22110 }
22111 {
22112 PyDict_SetItemString(d,"FONTFAMILY_DEFAULT", SWIG_From_int((int)(wxFONTFAMILY_DEFAULT)));
22113 }
22114 {
22115 PyDict_SetItemString(d,"FONTFAMILY_DECORATIVE", SWIG_From_int((int)(wxFONTFAMILY_DECORATIVE)));
22116 }
22117 {
22118 PyDict_SetItemString(d,"FONTFAMILY_ROMAN", SWIG_From_int((int)(wxFONTFAMILY_ROMAN)));
22119 }
22120 {
22121 PyDict_SetItemString(d,"FONTFAMILY_SCRIPT", SWIG_From_int((int)(wxFONTFAMILY_SCRIPT)));
22122 }
22123 {
22124 PyDict_SetItemString(d,"FONTFAMILY_SWISS", SWIG_From_int((int)(wxFONTFAMILY_SWISS)));
22125 }
22126 {
22127 PyDict_SetItemString(d,"FONTFAMILY_MODERN", SWIG_From_int((int)(wxFONTFAMILY_MODERN)));
22128 }
22129 {
22130 PyDict_SetItemString(d,"FONTFAMILY_TELETYPE", SWIG_From_int((int)(wxFONTFAMILY_TELETYPE)));
22131 }
22132 {
22133 PyDict_SetItemString(d,"FONTFAMILY_MAX", SWIG_From_int((int)(wxFONTFAMILY_MAX)));
22134 }
22135 {
22136 PyDict_SetItemString(d,"FONTFAMILY_UNKNOWN", SWIG_From_int((int)(wxFONTFAMILY_UNKNOWN)));
22137 }
22138 {
22139 PyDict_SetItemString(d,"FONTSTYLE_NORMAL", SWIG_From_int((int)(wxFONTSTYLE_NORMAL)));
22140 }
22141 {
22142 PyDict_SetItemString(d,"FONTSTYLE_ITALIC", SWIG_From_int((int)(wxFONTSTYLE_ITALIC)));
22143 }
22144 {
22145 PyDict_SetItemString(d,"FONTSTYLE_SLANT", SWIG_From_int((int)(wxFONTSTYLE_SLANT)));
22146 }
22147 {
22148 PyDict_SetItemString(d,"FONTSTYLE_MAX", SWIG_From_int((int)(wxFONTSTYLE_MAX)));
22149 }
22150 {
22151 PyDict_SetItemString(d,"FONTWEIGHT_NORMAL", SWIG_From_int((int)(wxFONTWEIGHT_NORMAL)));
22152 }
22153 {
22154 PyDict_SetItemString(d,"FONTWEIGHT_LIGHT", SWIG_From_int((int)(wxFONTWEIGHT_LIGHT)));
22155 }
22156 {
22157 PyDict_SetItemString(d,"FONTWEIGHT_BOLD", SWIG_From_int((int)(wxFONTWEIGHT_BOLD)));
22158 }
22159 {
22160 PyDict_SetItemString(d,"FONTWEIGHT_MAX", SWIG_From_int((int)(wxFONTWEIGHT_MAX)));
22161 }
22162 {
22163 PyDict_SetItemString(d,"FONTFLAG_DEFAULT", SWIG_From_int((int)(wxFONTFLAG_DEFAULT)));
22164 }
22165 {
22166 PyDict_SetItemString(d,"FONTFLAG_ITALIC", SWIG_From_int((int)(wxFONTFLAG_ITALIC)));
22167 }
22168 {
22169 PyDict_SetItemString(d,"FONTFLAG_SLANT", SWIG_From_int((int)(wxFONTFLAG_SLANT)));
22170 }
22171 {
22172 PyDict_SetItemString(d,"FONTFLAG_LIGHT", SWIG_From_int((int)(wxFONTFLAG_LIGHT)));
22173 }
22174 {
22175 PyDict_SetItemString(d,"FONTFLAG_BOLD", SWIG_From_int((int)(wxFONTFLAG_BOLD)));
22176 }
22177 {
22178 PyDict_SetItemString(d,"FONTFLAG_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_ANTIALIASED)));
22179 }
22180 {
22181 PyDict_SetItemString(d,"FONTFLAG_NOT_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_NOT_ANTIALIASED)));
22182 }
22183 {
22184 PyDict_SetItemString(d,"FONTFLAG_UNDERLINED", SWIG_From_int((int)(wxFONTFLAG_UNDERLINED)));
22185 }
22186 {
22187 PyDict_SetItemString(d,"FONTFLAG_STRIKETHROUGH", SWIG_From_int((int)(wxFONTFLAG_STRIKETHROUGH)));
22188 }
22189 {
22190 PyDict_SetItemString(d,"FONTFLAG_MASK", SWIG_From_int((int)(wxFONTFLAG_MASK)));
22191 }
22192 {
22193 PyDict_SetItemString(d,"FONTENCODING_SYSTEM", SWIG_From_int((int)(wxFONTENCODING_SYSTEM)));
22194 }
22195 {
22196 PyDict_SetItemString(d,"FONTENCODING_DEFAULT", SWIG_From_int((int)(wxFONTENCODING_DEFAULT)));
22197 }
22198 {
22199 PyDict_SetItemString(d,"FONTENCODING_ISO8859_1", SWIG_From_int((int)(wxFONTENCODING_ISO8859_1)));
22200 }
22201 {
22202 PyDict_SetItemString(d,"FONTENCODING_ISO8859_2", SWIG_From_int((int)(wxFONTENCODING_ISO8859_2)));
22203 }
22204 {
22205 PyDict_SetItemString(d,"FONTENCODING_ISO8859_3", SWIG_From_int((int)(wxFONTENCODING_ISO8859_3)));
22206 }
22207 {
22208 PyDict_SetItemString(d,"FONTENCODING_ISO8859_4", SWIG_From_int((int)(wxFONTENCODING_ISO8859_4)));
22209 }
22210 {
22211 PyDict_SetItemString(d,"FONTENCODING_ISO8859_5", SWIG_From_int((int)(wxFONTENCODING_ISO8859_5)));
22212 }
22213 {
22214 PyDict_SetItemString(d,"FONTENCODING_ISO8859_6", SWIG_From_int((int)(wxFONTENCODING_ISO8859_6)));
22215 }
22216 {
22217 PyDict_SetItemString(d,"FONTENCODING_ISO8859_7", SWIG_From_int((int)(wxFONTENCODING_ISO8859_7)));
22218 }
22219 {
22220 PyDict_SetItemString(d,"FONTENCODING_ISO8859_8", SWIG_From_int((int)(wxFONTENCODING_ISO8859_8)));
22221 }
22222 {
22223 PyDict_SetItemString(d,"FONTENCODING_ISO8859_9", SWIG_From_int((int)(wxFONTENCODING_ISO8859_9)));
22224 }
22225 {
22226 PyDict_SetItemString(d,"FONTENCODING_ISO8859_10", SWIG_From_int((int)(wxFONTENCODING_ISO8859_10)));
22227 }
22228 {
22229 PyDict_SetItemString(d,"FONTENCODING_ISO8859_11", SWIG_From_int((int)(wxFONTENCODING_ISO8859_11)));
22230 }
22231 {
22232 PyDict_SetItemString(d,"FONTENCODING_ISO8859_12", SWIG_From_int((int)(wxFONTENCODING_ISO8859_12)));
22233 }
22234 {
22235 PyDict_SetItemString(d,"FONTENCODING_ISO8859_13", SWIG_From_int((int)(wxFONTENCODING_ISO8859_13)));
22236 }
22237 {
22238 PyDict_SetItemString(d,"FONTENCODING_ISO8859_14", SWIG_From_int((int)(wxFONTENCODING_ISO8859_14)));
22239 }
22240 {
22241 PyDict_SetItemString(d,"FONTENCODING_ISO8859_15", SWIG_From_int((int)(wxFONTENCODING_ISO8859_15)));
22242 }
22243 {
22244 PyDict_SetItemString(d,"FONTENCODING_ISO8859_MAX", SWIG_From_int((int)(wxFONTENCODING_ISO8859_MAX)));
22245 }
22246 {
22247 PyDict_SetItemString(d,"FONTENCODING_KOI8", SWIG_From_int((int)(wxFONTENCODING_KOI8)));
22248 }
22249 {
22250 PyDict_SetItemString(d,"FONTENCODING_KOI8_U", SWIG_From_int((int)(wxFONTENCODING_KOI8_U)));
22251 }
22252 {
22253 PyDict_SetItemString(d,"FONTENCODING_ALTERNATIVE", SWIG_From_int((int)(wxFONTENCODING_ALTERNATIVE)));
22254 }
22255 {
22256 PyDict_SetItemString(d,"FONTENCODING_BULGARIAN", SWIG_From_int((int)(wxFONTENCODING_BULGARIAN)));
22257 }
22258 {
22259 PyDict_SetItemString(d,"FONTENCODING_CP437", SWIG_From_int((int)(wxFONTENCODING_CP437)));
22260 }
22261 {
22262 PyDict_SetItemString(d,"FONTENCODING_CP850", SWIG_From_int((int)(wxFONTENCODING_CP850)));
22263 }
22264 {
22265 PyDict_SetItemString(d,"FONTENCODING_CP852", SWIG_From_int((int)(wxFONTENCODING_CP852)));
22266 }
22267 {
22268 PyDict_SetItemString(d,"FONTENCODING_CP855", SWIG_From_int((int)(wxFONTENCODING_CP855)));
22269 }
22270 {
22271 PyDict_SetItemString(d,"FONTENCODING_CP866", SWIG_From_int((int)(wxFONTENCODING_CP866)));
22272 }
22273 {
22274 PyDict_SetItemString(d,"FONTENCODING_CP874", SWIG_From_int((int)(wxFONTENCODING_CP874)));
22275 }
22276 {
22277 PyDict_SetItemString(d,"FONTENCODING_CP932", SWIG_From_int((int)(wxFONTENCODING_CP932)));
22278 }
22279 {
22280 PyDict_SetItemString(d,"FONTENCODING_CP936", SWIG_From_int((int)(wxFONTENCODING_CP936)));
22281 }
22282 {
22283 PyDict_SetItemString(d,"FONTENCODING_CP949", SWIG_From_int((int)(wxFONTENCODING_CP949)));
22284 }
22285 {
22286 PyDict_SetItemString(d,"FONTENCODING_CP950", SWIG_From_int((int)(wxFONTENCODING_CP950)));
22287 }
22288 {
22289 PyDict_SetItemString(d,"FONTENCODING_CP1250", SWIG_From_int((int)(wxFONTENCODING_CP1250)));
22290 }
22291 {
22292 PyDict_SetItemString(d,"FONTENCODING_CP1251", SWIG_From_int((int)(wxFONTENCODING_CP1251)));
22293 }
22294 {
22295 PyDict_SetItemString(d,"FONTENCODING_CP1252", SWIG_From_int((int)(wxFONTENCODING_CP1252)));
22296 }
22297 {
22298 PyDict_SetItemString(d,"FONTENCODING_CP1253", SWIG_From_int((int)(wxFONTENCODING_CP1253)));
22299 }
22300 {
22301 PyDict_SetItemString(d,"FONTENCODING_CP1254", SWIG_From_int((int)(wxFONTENCODING_CP1254)));
22302 }
22303 {
22304 PyDict_SetItemString(d,"FONTENCODING_CP1255", SWIG_From_int((int)(wxFONTENCODING_CP1255)));
22305 }
22306 {
22307 PyDict_SetItemString(d,"FONTENCODING_CP1256", SWIG_From_int((int)(wxFONTENCODING_CP1256)));
22308 }
22309 {
22310 PyDict_SetItemString(d,"FONTENCODING_CP1257", SWIG_From_int((int)(wxFONTENCODING_CP1257)));
22311 }
22312 {
22313 PyDict_SetItemString(d,"FONTENCODING_CP12_MAX", SWIG_From_int((int)(wxFONTENCODING_CP12_MAX)));
22314 }
22315 {
22316 PyDict_SetItemString(d,"FONTENCODING_UTF7", SWIG_From_int((int)(wxFONTENCODING_UTF7)));
22317 }
22318 {
22319 PyDict_SetItemString(d,"FONTENCODING_UTF8", SWIG_From_int((int)(wxFONTENCODING_UTF8)));
22320 }
22321 {
22322 PyDict_SetItemString(d,"FONTENCODING_EUC_JP", SWIG_From_int((int)(wxFONTENCODING_EUC_JP)));
22323 }
22324 {
22325 PyDict_SetItemString(d,"FONTENCODING_UTF16BE", SWIG_From_int((int)(wxFONTENCODING_UTF16BE)));
22326 }
22327 {
22328 PyDict_SetItemString(d,"FONTENCODING_UTF16LE", SWIG_From_int((int)(wxFONTENCODING_UTF16LE)));
22329 }
22330 {
22331 PyDict_SetItemString(d,"FONTENCODING_UTF32BE", SWIG_From_int((int)(wxFONTENCODING_UTF32BE)));
22332 }
22333 {
22334 PyDict_SetItemString(d,"FONTENCODING_UTF32LE", SWIG_From_int((int)(wxFONTENCODING_UTF32LE)));
22335 }
22336 {
22337 PyDict_SetItemString(d,"FONTENCODING_MACROMAN", SWIG_From_int((int)(wxFONTENCODING_MACROMAN)));
22338 }
22339 {
22340 PyDict_SetItemString(d,"FONTENCODING_MACJAPANESE", SWIG_From_int((int)(wxFONTENCODING_MACJAPANESE)));
22341 }
22342 {
22343 PyDict_SetItemString(d,"FONTENCODING_MACCHINESETRAD", SWIG_From_int((int)(wxFONTENCODING_MACCHINESETRAD)));
22344 }
22345 {
22346 PyDict_SetItemString(d,"FONTENCODING_MACKOREAN", SWIG_From_int((int)(wxFONTENCODING_MACKOREAN)));
22347 }
22348 {
22349 PyDict_SetItemString(d,"FONTENCODING_MACARABIC", SWIG_From_int((int)(wxFONTENCODING_MACARABIC)));
22350 }
22351 {
22352 PyDict_SetItemString(d,"FONTENCODING_MACHEBREW", SWIG_From_int((int)(wxFONTENCODING_MACHEBREW)));
22353 }
22354 {
22355 PyDict_SetItemString(d,"FONTENCODING_MACGREEK", SWIG_From_int((int)(wxFONTENCODING_MACGREEK)));
22356 }
22357 {
22358 PyDict_SetItemString(d,"FONTENCODING_MACCYRILLIC", SWIG_From_int((int)(wxFONTENCODING_MACCYRILLIC)));
22359 }
22360 {
22361 PyDict_SetItemString(d,"FONTENCODING_MACDEVANAGARI", SWIG_From_int((int)(wxFONTENCODING_MACDEVANAGARI)));
22362 }
22363 {
22364 PyDict_SetItemString(d,"FONTENCODING_MACGURMUKHI", SWIG_From_int((int)(wxFONTENCODING_MACGURMUKHI)));
22365 }
22366 {
22367 PyDict_SetItemString(d,"FONTENCODING_MACGUJARATI", SWIG_From_int((int)(wxFONTENCODING_MACGUJARATI)));
22368 }
22369 {
22370 PyDict_SetItemString(d,"FONTENCODING_MACORIYA", SWIG_From_int((int)(wxFONTENCODING_MACORIYA)));
22371 }
22372 {
22373 PyDict_SetItemString(d,"FONTENCODING_MACBENGALI", SWIG_From_int((int)(wxFONTENCODING_MACBENGALI)));
22374 }
22375 {
22376 PyDict_SetItemString(d,"FONTENCODING_MACTAMIL", SWIG_From_int((int)(wxFONTENCODING_MACTAMIL)));
22377 }
22378 {
22379 PyDict_SetItemString(d,"FONTENCODING_MACTELUGU", SWIG_From_int((int)(wxFONTENCODING_MACTELUGU)));
22380 }
22381 {
22382 PyDict_SetItemString(d,"FONTENCODING_MACKANNADA", SWIG_From_int((int)(wxFONTENCODING_MACKANNADA)));
22383 }
22384 {
22385 PyDict_SetItemString(d,"FONTENCODING_MACMALAJALAM", SWIG_From_int((int)(wxFONTENCODING_MACMALAJALAM)));
22386 }
22387 {
22388 PyDict_SetItemString(d,"FONTENCODING_MACSINHALESE", SWIG_From_int((int)(wxFONTENCODING_MACSINHALESE)));
22389 }
22390 {
22391 PyDict_SetItemString(d,"FONTENCODING_MACBURMESE", SWIG_From_int((int)(wxFONTENCODING_MACBURMESE)));
22392 }
22393 {
22394 PyDict_SetItemString(d,"FONTENCODING_MACKHMER", SWIG_From_int((int)(wxFONTENCODING_MACKHMER)));
22395 }
22396 {
22397 PyDict_SetItemString(d,"FONTENCODING_MACTHAI", SWIG_From_int((int)(wxFONTENCODING_MACTHAI)));
22398 }
22399 {
22400 PyDict_SetItemString(d,"FONTENCODING_MACLAOTIAN", SWIG_From_int((int)(wxFONTENCODING_MACLAOTIAN)));
22401 }
22402 {
22403 PyDict_SetItemString(d,"FONTENCODING_MACGEORGIAN", SWIG_From_int((int)(wxFONTENCODING_MACGEORGIAN)));
22404 }
22405 {
22406 PyDict_SetItemString(d,"FONTENCODING_MACARMENIAN", SWIG_From_int((int)(wxFONTENCODING_MACARMENIAN)));
22407 }
22408 {
22409 PyDict_SetItemString(d,"FONTENCODING_MACCHINESESIMP", SWIG_From_int((int)(wxFONTENCODING_MACCHINESESIMP)));
22410 }
22411 {
22412 PyDict_SetItemString(d,"FONTENCODING_MACTIBETAN", SWIG_From_int((int)(wxFONTENCODING_MACTIBETAN)));
22413 }
22414 {
22415 PyDict_SetItemString(d,"FONTENCODING_MACMONGOLIAN", SWIG_From_int((int)(wxFONTENCODING_MACMONGOLIAN)));
22416 }
22417 {
22418 PyDict_SetItemString(d,"FONTENCODING_MACETHIOPIC", SWIG_From_int((int)(wxFONTENCODING_MACETHIOPIC)));
22419 }
22420 {
22421 PyDict_SetItemString(d,"FONTENCODING_MACCENTRALEUR", SWIG_From_int((int)(wxFONTENCODING_MACCENTRALEUR)));
22422 }
22423 {
22424 PyDict_SetItemString(d,"FONTENCODING_MACVIATNAMESE", SWIG_From_int((int)(wxFONTENCODING_MACVIATNAMESE)));
22425 }
22426 {
22427 PyDict_SetItemString(d,"FONTENCODING_MACARABICEXT", SWIG_From_int((int)(wxFONTENCODING_MACARABICEXT)));
22428 }
22429 {
22430 PyDict_SetItemString(d,"FONTENCODING_MACSYMBOL", SWIG_From_int((int)(wxFONTENCODING_MACSYMBOL)));
22431 }
22432 {
22433 PyDict_SetItemString(d,"FONTENCODING_MACDINGBATS", SWIG_From_int((int)(wxFONTENCODING_MACDINGBATS)));
22434 }
22435 {
22436 PyDict_SetItemString(d,"FONTENCODING_MACTURKISH", SWIG_From_int((int)(wxFONTENCODING_MACTURKISH)));
22437 }
22438 {
22439 PyDict_SetItemString(d,"FONTENCODING_MACCROATIAN", SWIG_From_int((int)(wxFONTENCODING_MACCROATIAN)));
22440 }
22441 {
22442 PyDict_SetItemString(d,"FONTENCODING_MACICELANDIC", SWIG_From_int((int)(wxFONTENCODING_MACICELANDIC)));
22443 }
22444 {
22445 PyDict_SetItemString(d,"FONTENCODING_MACROMANIAN", SWIG_From_int((int)(wxFONTENCODING_MACROMANIAN)));
22446 }
22447 {
22448 PyDict_SetItemString(d,"FONTENCODING_MACCELTIC", SWIG_From_int((int)(wxFONTENCODING_MACCELTIC)));
22449 }
22450 {
22451 PyDict_SetItemString(d,"FONTENCODING_MACGAELIC", SWIG_From_int((int)(wxFONTENCODING_MACGAELIC)));
22452 }
22453 {
22454 PyDict_SetItemString(d,"FONTENCODING_MACKEYBOARD", SWIG_From_int((int)(wxFONTENCODING_MACKEYBOARD)));
22455 }
22456 {
22457 PyDict_SetItemString(d,"FONTENCODING_MACMIN", SWIG_From_int((int)(wxFONTENCODING_MACMIN)));
22458 }
22459 {
22460 PyDict_SetItemString(d,"FONTENCODING_MACMAX", SWIG_From_int((int)(wxFONTENCODING_MACMAX)));
22461 }
22462 {
22463 PyDict_SetItemString(d,"FONTENCODING_MAX", SWIG_From_int((int)(wxFONTENCODING_MAX)));
22464 }
22465 {
22466 PyDict_SetItemString(d,"FONTENCODING_UTF16", SWIG_From_int((int)(wxFONTENCODING_UTF16)));
22467 }
22468 {
22469 PyDict_SetItemString(d,"FONTENCODING_UTF32", SWIG_From_int((int)(wxFONTENCODING_UTF32)));
22470 }
22471 {
22472 PyDict_SetItemString(d,"FONTENCODING_UNICODE", SWIG_From_int((int)(wxFONTENCODING_UNICODE)));
22473 }
22474 {
22475 PyDict_SetItemString(d,"FONTENCODING_GB2312", SWIG_From_int((int)(wxFONTENCODING_GB2312)));
22476 }
22477 {
22478 PyDict_SetItemString(d,"FONTENCODING_BIG5", SWIG_From_int((int)(wxFONTENCODING_BIG5)));
22479 }
22480 {
22481 PyDict_SetItemString(d,"FONTENCODING_SHIFT_JIS", SWIG_From_int((int)(wxFONTENCODING_SHIFT_JIS)));
22482 }
22483
22484 wxPyPtrTypeMap_Add("wxFontEnumerator", "wxPyFontEnumerator");
22485
22486 {
22487 PyDict_SetItemString(d,"LANGUAGE_DEFAULT", SWIG_From_int((int)(wxLANGUAGE_DEFAULT)));
22488 }
22489 {
22490 PyDict_SetItemString(d,"LANGUAGE_UNKNOWN", SWIG_From_int((int)(wxLANGUAGE_UNKNOWN)));
22491 }
22492 {
22493 PyDict_SetItemString(d,"LANGUAGE_ABKHAZIAN", SWIG_From_int((int)(wxLANGUAGE_ABKHAZIAN)));
22494 }
22495 {
22496 PyDict_SetItemString(d,"LANGUAGE_AFAR", SWIG_From_int((int)(wxLANGUAGE_AFAR)));
22497 }
22498 {
22499 PyDict_SetItemString(d,"LANGUAGE_AFRIKAANS", SWIG_From_int((int)(wxLANGUAGE_AFRIKAANS)));
22500 }
22501 {
22502 PyDict_SetItemString(d,"LANGUAGE_ALBANIAN", SWIG_From_int((int)(wxLANGUAGE_ALBANIAN)));
22503 }
22504 {
22505 PyDict_SetItemString(d,"LANGUAGE_AMHARIC", SWIG_From_int((int)(wxLANGUAGE_AMHARIC)));
22506 }
22507 {
22508 PyDict_SetItemString(d,"LANGUAGE_ARABIC", SWIG_From_int((int)(wxLANGUAGE_ARABIC)));
22509 }
22510 {
22511 PyDict_SetItemString(d,"LANGUAGE_ARABIC_ALGERIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_ALGERIA)));
22512 }
22513 {
22514 PyDict_SetItemString(d,"LANGUAGE_ARABIC_BAHRAIN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_BAHRAIN)));
22515 }
22516 {
22517 PyDict_SetItemString(d,"LANGUAGE_ARABIC_EGYPT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_EGYPT)));
22518 }
22519 {
22520 PyDict_SetItemString(d,"LANGUAGE_ARABIC_IRAQ", SWIG_From_int((int)(wxLANGUAGE_ARABIC_IRAQ)));
22521 }
22522 {
22523 PyDict_SetItemString(d,"LANGUAGE_ARABIC_JORDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_JORDAN)));
22524 }
22525 {
22526 PyDict_SetItemString(d,"LANGUAGE_ARABIC_KUWAIT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_KUWAIT)));
22527 }
22528 {
22529 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LEBANON", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LEBANON)));
22530 }
22531 {
22532 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LIBYA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LIBYA)));
22533 }
22534 {
22535 PyDict_SetItemString(d,"LANGUAGE_ARABIC_MOROCCO", SWIG_From_int((int)(wxLANGUAGE_ARABIC_MOROCCO)));
22536 }
22537 {
22538 PyDict_SetItemString(d,"LANGUAGE_ARABIC_OMAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_OMAN)));
22539 }
22540 {
22541 PyDict_SetItemString(d,"LANGUAGE_ARABIC_QATAR", SWIG_From_int((int)(wxLANGUAGE_ARABIC_QATAR)));
22542 }
22543 {
22544 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SAUDI_ARABIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SAUDI_ARABIA)));
22545 }
22546 {
22547 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SUDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SUDAN)));
22548 }
22549 {
22550 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SYRIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SYRIA)));
22551 }
22552 {
22553 PyDict_SetItemString(d,"LANGUAGE_ARABIC_TUNISIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_TUNISIA)));
22554 }
22555 {
22556 PyDict_SetItemString(d,"LANGUAGE_ARABIC_UAE", SWIG_From_int((int)(wxLANGUAGE_ARABIC_UAE)));
22557 }
22558 {
22559 PyDict_SetItemString(d,"LANGUAGE_ARABIC_YEMEN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_YEMEN)));
22560 }
22561 {
22562 PyDict_SetItemString(d,"LANGUAGE_ARMENIAN", SWIG_From_int((int)(wxLANGUAGE_ARMENIAN)));
22563 }
22564 {
22565 PyDict_SetItemString(d,"LANGUAGE_ASSAMESE", SWIG_From_int((int)(wxLANGUAGE_ASSAMESE)));
22566 }
22567 {
22568 PyDict_SetItemString(d,"LANGUAGE_AYMARA", SWIG_From_int((int)(wxLANGUAGE_AYMARA)));
22569 }
22570 {
22571 PyDict_SetItemString(d,"LANGUAGE_AZERI", SWIG_From_int((int)(wxLANGUAGE_AZERI)));
22572 }
22573 {
22574 PyDict_SetItemString(d,"LANGUAGE_AZERI_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_AZERI_CYRILLIC)));
22575 }
22576 {
22577 PyDict_SetItemString(d,"LANGUAGE_AZERI_LATIN", SWIG_From_int((int)(wxLANGUAGE_AZERI_LATIN)));
22578 }
22579 {
22580 PyDict_SetItemString(d,"LANGUAGE_BASHKIR", SWIG_From_int((int)(wxLANGUAGE_BASHKIR)));
22581 }
22582 {
22583 PyDict_SetItemString(d,"LANGUAGE_BASQUE", SWIG_From_int((int)(wxLANGUAGE_BASQUE)));
22584 }
22585 {
22586 PyDict_SetItemString(d,"LANGUAGE_BELARUSIAN", SWIG_From_int((int)(wxLANGUAGE_BELARUSIAN)));
22587 }
22588 {
22589 PyDict_SetItemString(d,"LANGUAGE_BENGALI", SWIG_From_int((int)(wxLANGUAGE_BENGALI)));
22590 }
22591 {
22592 PyDict_SetItemString(d,"LANGUAGE_BHUTANI", SWIG_From_int((int)(wxLANGUAGE_BHUTANI)));
22593 }
22594 {
22595 PyDict_SetItemString(d,"LANGUAGE_BIHARI", SWIG_From_int((int)(wxLANGUAGE_BIHARI)));
22596 }
22597 {
22598 PyDict_SetItemString(d,"LANGUAGE_BISLAMA", SWIG_From_int((int)(wxLANGUAGE_BISLAMA)));
22599 }
22600 {
22601 PyDict_SetItemString(d,"LANGUAGE_BRETON", SWIG_From_int((int)(wxLANGUAGE_BRETON)));
22602 }
22603 {
22604 PyDict_SetItemString(d,"LANGUAGE_BULGARIAN", SWIG_From_int((int)(wxLANGUAGE_BULGARIAN)));
22605 }
22606 {
22607 PyDict_SetItemString(d,"LANGUAGE_BURMESE", SWIG_From_int((int)(wxLANGUAGE_BURMESE)));
22608 }
22609 {
22610 PyDict_SetItemString(d,"LANGUAGE_CAMBODIAN", SWIG_From_int((int)(wxLANGUAGE_CAMBODIAN)));
22611 }
22612 {
22613 PyDict_SetItemString(d,"LANGUAGE_CATALAN", SWIG_From_int((int)(wxLANGUAGE_CATALAN)));
22614 }
22615 {
22616 PyDict_SetItemString(d,"LANGUAGE_CHINESE", SWIG_From_int((int)(wxLANGUAGE_CHINESE)));
22617 }
22618 {
22619 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SIMPLIFIED", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SIMPLIFIED)));
22620 }
22621 {
22622 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TRADITIONAL", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TRADITIONAL)));
22623 }
22624 {
22625 PyDict_SetItemString(d,"LANGUAGE_CHINESE_HONGKONG", SWIG_From_int((int)(wxLANGUAGE_CHINESE_HONGKONG)));
22626 }
22627 {
22628 PyDict_SetItemString(d,"LANGUAGE_CHINESE_MACAU", SWIG_From_int((int)(wxLANGUAGE_CHINESE_MACAU)));
22629 }
22630 {
22631 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SINGAPORE", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SINGAPORE)));
22632 }
22633 {
22634 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TAIWAN", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TAIWAN)));
22635 }
22636 {
22637 PyDict_SetItemString(d,"LANGUAGE_CORSICAN", SWIG_From_int((int)(wxLANGUAGE_CORSICAN)));
22638 }
22639 {
22640 PyDict_SetItemString(d,"LANGUAGE_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_CROATIAN)));
22641 }
22642 {
22643 PyDict_SetItemString(d,"LANGUAGE_CZECH", SWIG_From_int((int)(wxLANGUAGE_CZECH)));
22644 }
22645 {
22646 PyDict_SetItemString(d,"LANGUAGE_DANISH", SWIG_From_int((int)(wxLANGUAGE_DANISH)));
22647 }
22648 {
22649 PyDict_SetItemString(d,"LANGUAGE_DUTCH", SWIG_From_int((int)(wxLANGUAGE_DUTCH)));
22650 }
22651 {
22652 PyDict_SetItemString(d,"LANGUAGE_DUTCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_DUTCH_BELGIAN)));
22653 }
22654 {
22655 PyDict_SetItemString(d,"LANGUAGE_ENGLISH", SWIG_From_int((int)(wxLANGUAGE_ENGLISH)));
22656 }
22657 {
22658 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_UK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_UK)));
22659 }
22660 {
22661 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_US", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_US)));
22662 }
22663 {
22664 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_AUSTRALIA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_AUSTRALIA)));
22665 }
22666 {
22667 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BELIZE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BELIZE)));
22668 }
22669 {
22670 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BOTSWANA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BOTSWANA)));
22671 }
22672 {
22673 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CANADA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CANADA)));
22674 }
22675 {
22676 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CARIBBEAN", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CARIBBEAN)));
22677 }
22678 {
22679 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_DENMARK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_DENMARK)));
22680 }
22681 {
22682 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_EIRE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_EIRE)));
22683 }
22684 {
22685 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_JAMAICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_JAMAICA)));
22686 }
22687 {
22688 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_NEW_ZEALAND", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_NEW_ZEALAND)));
22689 }
22690 {
22691 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_PHILIPPINES", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_PHILIPPINES)));
22692 }
22693 {
22694 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_SOUTH_AFRICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_SOUTH_AFRICA)));
22695 }
22696 {
22697 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_TRINIDAD", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_TRINIDAD)));
22698 }
22699 {
22700 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_ZIMBABWE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_ZIMBABWE)));
22701 }
22702 {
22703 PyDict_SetItemString(d,"LANGUAGE_ESPERANTO", SWIG_From_int((int)(wxLANGUAGE_ESPERANTO)));
22704 }
22705 {
22706 PyDict_SetItemString(d,"LANGUAGE_ESTONIAN", SWIG_From_int((int)(wxLANGUAGE_ESTONIAN)));
22707 }
22708 {
22709 PyDict_SetItemString(d,"LANGUAGE_FAEROESE", SWIG_From_int((int)(wxLANGUAGE_FAEROESE)));
22710 }
22711 {
22712 PyDict_SetItemString(d,"LANGUAGE_FARSI", SWIG_From_int((int)(wxLANGUAGE_FARSI)));
22713 }
22714 {
22715 PyDict_SetItemString(d,"LANGUAGE_FIJI", SWIG_From_int((int)(wxLANGUAGE_FIJI)));
22716 }
22717 {
22718 PyDict_SetItemString(d,"LANGUAGE_FINNISH", SWIG_From_int((int)(wxLANGUAGE_FINNISH)));
22719 }
22720 {
22721 PyDict_SetItemString(d,"LANGUAGE_FRENCH", SWIG_From_int((int)(wxLANGUAGE_FRENCH)));
22722 }
22723 {
22724 PyDict_SetItemString(d,"LANGUAGE_FRENCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_BELGIAN)));
22725 }
22726 {
22727 PyDict_SetItemString(d,"LANGUAGE_FRENCH_CANADIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_CANADIAN)));
22728 }
22729 {
22730 PyDict_SetItemString(d,"LANGUAGE_FRENCH_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_FRENCH_LUXEMBOURG)));
22731 }
22732 {
22733 PyDict_SetItemString(d,"LANGUAGE_FRENCH_MONACO", SWIG_From_int((int)(wxLANGUAGE_FRENCH_MONACO)));
22734 }
22735 {
22736 PyDict_SetItemString(d,"LANGUAGE_FRENCH_SWISS", SWIG_From_int((int)(wxLANGUAGE_FRENCH_SWISS)));
22737 }
22738 {
22739 PyDict_SetItemString(d,"LANGUAGE_FRISIAN", SWIG_From_int((int)(wxLANGUAGE_FRISIAN)));
22740 }
22741 {
22742 PyDict_SetItemString(d,"LANGUAGE_GALICIAN", SWIG_From_int((int)(wxLANGUAGE_GALICIAN)));
22743 }
22744 {
22745 PyDict_SetItemString(d,"LANGUAGE_GEORGIAN", SWIG_From_int((int)(wxLANGUAGE_GEORGIAN)));
22746 }
22747 {
22748 PyDict_SetItemString(d,"LANGUAGE_GERMAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN)));
22749 }
22750 {
22751 PyDict_SetItemString(d,"LANGUAGE_GERMAN_AUSTRIAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_AUSTRIAN)));
22752 }
22753 {
22754 PyDict_SetItemString(d,"LANGUAGE_GERMAN_BELGIUM", SWIG_From_int((int)(wxLANGUAGE_GERMAN_BELGIUM)));
22755 }
22756 {
22757 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LIECHTENSTEIN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LIECHTENSTEIN)));
22758 }
22759 {
22760 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LUXEMBOURG)));
22761 }
22762 {
22763 PyDict_SetItemString(d,"LANGUAGE_GERMAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_GERMAN_SWISS)));
22764 }
22765 {
22766 PyDict_SetItemString(d,"LANGUAGE_GREEK", SWIG_From_int((int)(wxLANGUAGE_GREEK)));
22767 }
22768 {
22769 PyDict_SetItemString(d,"LANGUAGE_GREENLANDIC", SWIG_From_int((int)(wxLANGUAGE_GREENLANDIC)));
22770 }
22771 {
22772 PyDict_SetItemString(d,"LANGUAGE_GUARANI", SWIG_From_int((int)(wxLANGUAGE_GUARANI)));
22773 }
22774 {
22775 PyDict_SetItemString(d,"LANGUAGE_GUJARATI", SWIG_From_int((int)(wxLANGUAGE_GUJARATI)));
22776 }
22777 {
22778 PyDict_SetItemString(d,"LANGUAGE_HAUSA", SWIG_From_int((int)(wxLANGUAGE_HAUSA)));
22779 }
22780 {
22781 PyDict_SetItemString(d,"LANGUAGE_HEBREW", SWIG_From_int((int)(wxLANGUAGE_HEBREW)));
22782 }
22783 {
22784 PyDict_SetItemString(d,"LANGUAGE_HINDI", SWIG_From_int((int)(wxLANGUAGE_HINDI)));
22785 }
22786 {
22787 PyDict_SetItemString(d,"LANGUAGE_HUNGARIAN", SWIG_From_int((int)(wxLANGUAGE_HUNGARIAN)));
22788 }
22789 {
22790 PyDict_SetItemString(d,"LANGUAGE_ICELANDIC", SWIG_From_int((int)(wxLANGUAGE_ICELANDIC)));
22791 }
22792 {
22793 PyDict_SetItemString(d,"LANGUAGE_INDONESIAN", SWIG_From_int((int)(wxLANGUAGE_INDONESIAN)));
22794 }
22795 {
22796 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUA", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUA)));
22797 }
22798 {
22799 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUE", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUE)));
22800 }
22801 {
22802 PyDict_SetItemString(d,"LANGUAGE_INUKTITUT", SWIG_From_int((int)(wxLANGUAGE_INUKTITUT)));
22803 }
22804 {
22805 PyDict_SetItemString(d,"LANGUAGE_INUPIAK", SWIG_From_int((int)(wxLANGUAGE_INUPIAK)));
22806 }
22807 {
22808 PyDict_SetItemString(d,"LANGUAGE_IRISH", SWIG_From_int((int)(wxLANGUAGE_IRISH)));
22809 }
22810 {
22811 PyDict_SetItemString(d,"LANGUAGE_ITALIAN", SWIG_From_int((int)(wxLANGUAGE_ITALIAN)));
22812 }
22813 {
22814 PyDict_SetItemString(d,"LANGUAGE_ITALIAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_ITALIAN_SWISS)));
22815 }
22816 {
22817 PyDict_SetItemString(d,"LANGUAGE_JAPANESE", SWIG_From_int((int)(wxLANGUAGE_JAPANESE)));
22818 }
22819 {
22820 PyDict_SetItemString(d,"LANGUAGE_JAVANESE", SWIG_From_int((int)(wxLANGUAGE_JAVANESE)));
22821 }
22822 {
22823 PyDict_SetItemString(d,"LANGUAGE_KANNADA", SWIG_From_int((int)(wxLANGUAGE_KANNADA)));
22824 }
22825 {
22826 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI)));
22827 }
22828 {
22829 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI_INDIA", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI_INDIA)));
22830 }
22831 {
22832 PyDict_SetItemString(d,"LANGUAGE_KAZAKH", SWIG_From_int((int)(wxLANGUAGE_KAZAKH)));
22833 }
22834 {
22835 PyDict_SetItemString(d,"LANGUAGE_KERNEWEK", SWIG_From_int((int)(wxLANGUAGE_KERNEWEK)));
22836 }
22837 {
22838 PyDict_SetItemString(d,"LANGUAGE_KINYARWANDA", SWIG_From_int((int)(wxLANGUAGE_KINYARWANDA)));
22839 }
22840 {
22841 PyDict_SetItemString(d,"LANGUAGE_KIRGHIZ", SWIG_From_int((int)(wxLANGUAGE_KIRGHIZ)));
22842 }
22843 {
22844 PyDict_SetItemString(d,"LANGUAGE_KIRUNDI", SWIG_From_int((int)(wxLANGUAGE_KIRUNDI)));
22845 }
22846 {
22847 PyDict_SetItemString(d,"LANGUAGE_KONKANI", SWIG_From_int((int)(wxLANGUAGE_KONKANI)));
22848 }
22849 {
22850 PyDict_SetItemString(d,"LANGUAGE_KOREAN", SWIG_From_int((int)(wxLANGUAGE_KOREAN)));
22851 }
22852 {
22853 PyDict_SetItemString(d,"LANGUAGE_KURDISH", SWIG_From_int((int)(wxLANGUAGE_KURDISH)));
22854 }
22855 {
22856 PyDict_SetItemString(d,"LANGUAGE_LAOTHIAN", SWIG_From_int((int)(wxLANGUAGE_LAOTHIAN)));
22857 }
22858 {
22859 PyDict_SetItemString(d,"LANGUAGE_LATIN", SWIG_From_int((int)(wxLANGUAGE_LATIN)));
22860 }
22861 {
22862 PyDict_SetItemString(d,"LANGUAGE_LATVIAN", SWIG_From_int((int)(wxLANGUAGE_LATVIAN)));
22863 }
22864 {
22865 PyDict_SetItemString(d,"LANGUAGE_LINGALA", SWIG_From_int((int)(wxLANGUAGE_LINGALA)));
22866 }
22867 {
22868 PyDict_SetItemString(d,"LANGUAGE_LITHUANIAN", SWIG_From_int((int)(wxLANGUAGE_LITHUANIAN)));
22869 }
22870 {
22871 PyDict_SetItemString(d,"LANGUAGE_MACEDONIAN", SWIG_From_int((int)(wxLANGUAGE_MACEDONIAN)));
22872 }
22873 {
22874 PyDict_SetItemString(d,"LANGUAGE_MALAGASY", SWIG_From_int((int)(wxLANGUAGE_MALAGASY)));
22875 }
22876 {
22877 PyDict_SetItemString(d,"LANGUAGE_MALAY", SWIG_From_int((int)(wxLANGUAGE_MALAY)));
22878 }
22879 {
22880 PyDict_SetItemString(d,"LANGUAGE_MALAYALAM", SWIG_From_int((int)(wxLANGUAGE_MALAYALAM)));
22881 }
22882 {
22883 PyDict_SetItemString(d,"LANGUAGE_MALAY_BRUNEI_DARUSSALAM", SWIG_From_int((int)(wxLANGUAGE_MALAY_BRUNEI_DARUSSALAM)));
22884 }
22885 {
22886 PyDict_SetItemString(d,"LANGUAGE_MALAY_MALAYSIA", SWIG_From_int((int)(wxLANGUAGE_MALAY_MALAYSIA)));
22887 }
22888 {
22889 PyDict_SetItemString(d,"LANGUAGE_MALTESE", SWIG_From_int((int)(wxLANGUAGE_MALTESE)));
22890 }
22891 {
22892 PyDict_SetItemString(d,"LANGUAGE_MANIPURI", SWIG_From_int((int)(wxLANGUAGE_MANIPURI)));
22893 }
22894 {
22895 PyDict_SetItemString(d,"LANGUAGE_MAORI", SWIG_From_int((int)(wxLANGUAGE_MAORI)));
22896 }
22897 {
22898 PyDict_SetItemString(d,"LANGUAGE_MARATHI", SWIG_From_int((int)(wxLANGUAGE_MARATHI)));
22899 }
22900 {
22901 PyDict_SetItemString(d,"LANGUAGE_MOLDAVIAN", SWIG_From_int((int)(wxLANGUAGE_MOLDAVIAN)));
22902 }
22903 {
22904 PyDict_SetItemString(d,"LANGUAGE_MONGOLIAN", SWIG_From_int((int)(wxLANGUAGE_MONGOLIAN)));
22905 }
22906 {
22907 PyDict_SetItemString(d,"LANGUAGE_NAURU", SWIG_From_int((int)(wxLANGUAGE_NAURU)));
22908 }
22909 {
22910 PyDict_SetItemString(d,"LANGUAGE_NEPALI", SWIG_From_int((int)(wxLANGUAGE_NEPALI)));
22911 }
22912 {
22913 PyDict_SetItemString(d,"LANGUAGE_NEPALI_INDIA", SWIG_From_int((int)(wxLANGUAGE_NEPALI_INDIA)));
22914 }
22915 {
22916 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_BOKMAL", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_BOKMAL)));
22917 }
22918 {
22919 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_NYNORSK", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_NYNORSK)));
22920 }
22921 {
22922 PyDict_SetItemString(d,"LANGUAGE_OCCITAN", SWIG_From_int((int)(wxLANGUAGE_OCCITAN)));
22923 }
22924 {
22925 PyDict_SetItemString(d,"LANGUAGE_ORIYA", SWIG_From_int((int)(wxLANGUAGE_ORIYA)));
22926 }
22927 {
22928 PyDict_SetItemString(d,"LANGUAGE_OROMO", SWIG_From_int((int)(wxLANGUAGE_OROMO)));
22929 }
22930 {
22931 PyDict_SetItemString(d,"LANGUAGE_PASHTO", SWIG_From_int((int)(wxLANGUAGE_PASHTO)));
22932 }
22933 {
22934 PyDict_SetItemString(d,"LANGUAGE_POLISH", SWIG_From_int((int)(wxLANGUAGE_POLISH)));
22935 }
22936 {
22937 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE)));
22938 }
22939 {
22940 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE_BRAZILIAN", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE_BRAZILIAN)));
22941 }
22942 {
22943 PyDict_SetItemString(d,"LANGUAGE_PUNJABI", SWIG_From_int((int)(wxLANGUAGE_PUNJABI)));
22944 }
22945 {
22946 PyDict_SetItemString(d,"LANGUAGE_QUECHUA", SWIG_From_int((int)(wxLANGUAGE_QUECHUA)));
22947 }
22948 {
22949 PyDict_SetItemString(d,"LANGUAGE_RHAETO_ROMANCE", SWIG_From_int((int)(wxLANGUAGE_RHAETO_ROMANCE)));
22950 }
22951 {
22952 PyDict_SetItemString(d,"LANGUAGE_ROMANIAN", SWIG_From_int((int)(wxLANGUAGE_ROMANIAN)));
22953 }
22954 {
22955 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN)));
22956 }
22957 {
22958 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN_UKRAINE", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN_UKRAINE)));
22959 }
22960 {
22961 PyDict_SetItemString(d,"LANGUAGE_SAMOAN", SWIG_From_int((int)(wxLANGUAGE_SAMOAN)));
22962 }
22963 {
22964 PyDict_SetItemString(d,"LANGUAGE_SANGHO", SWIG_From_int((int)(wxLANGUAGE_SANGHO)));
22965 }
22966 {
22967 PyDict_SetItemString(d,"LANGUAGE_SANSKRIT", SWIG_From_int((int)(wxLANGUAGE_SANSKRIT)));
22968 }
22969 {
22970 PyDict_SetItemString(d,"LANGUAGE_SCOTS_GAELIC", SWIG_From_int((int)(wxLANGUAGE_SCOTS_GAELIC)));
22971 }
22972 {
22973 PyDict_SetItemString(d,"LANGUAGE_SERBIAN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN)));
22974 }
22975 {
22976 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_CYRILLIC)));
22977 }
22978 {
22979 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_LATIN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_LATIN)));
22980 }
22981 {
22982 PyDict_SetItemString(d,"LANGUAGE_SERBO_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_SERBO_CROATIAN)));
22983 }
22984 {
22985 PyDict_SetItemString(d,"LANGUAGE_SESOTHO", SWIG_From_int((int)(wxLANGUAGE_SESOTHO)));
22986 }
22987 {
22988 PyDict_SetItemString(d,"LANGUAGE_SETSWANA", SWIG_From_int((int)(wxLANGUAGE_SETSWANA)));
22989 }
22990 {
22991 PyDict_SetItemString(d,"LANGUAGE_SHONA", SWIG_From_int((int)(wxLANGUAGE_SHONA)));
22992 }
22993 {
22994 PyDict_SetItemString(d,"LANGUAGE_SINDHI", SWIG_From_int((int)(wxLANGUAGE_SINDHI)));
22995 }
22996 {
22997 PyDict_SetItemString(d,"LANGUAGE_SINHALESE", SWIG_From_int((int)(wxLANGUAGE_SINHALESE)));
22998 }
22999 {
23000 PyDict_SetItemString(d,"LANGUAGE_SISWATI", SWIG_From_int((int)(wxLANGUAGE_SISWATI)));
23001 }
23002 {
23003 PyDict_SetItemString(d,"LANGUAGE_SLOVAK", SWIG_From_int((int)(wxLANGUAGE_SLOVAK)));
23004 }
23005 {
23006 PyDict_SetItemString(d,"LANGUAGE_SLOVENIAN", SWIG_From_int((int)(wxLANGUAGE_SLOVENIAN)));
23007 }
23008 {
23009 PyDict_SetItemString(d,"LANGUAGE_SOMALI", SWIG_From_int((int)(wxLANGUAGE_SOMALI)));
23010 }
23011 {
23012 PyDict_SetItemString(d,"LANGUAGE_SPANISH", SWIG_From_int((int)(wxLANGUAGE_SPANISH)));
23013 }
23014 {
23015 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ARGENTINA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ARGENTINA)));
23016 }
23017 {
23018 PyDict_SetItemString(d,"LANGUAGE_SPANISH_BOLIVIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_BOLIVIA)));
23019 }
23020 {
23021 PyDict_SetItemString(d,"LANGUAGE_SPANISH_CHILE", SWIG_From_int((int)(wxLANGUAGE_SPANISH_CHILE)));
23022 }
23023 {
23024 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COLOMBIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COLOMBIA)));
23025 }
23026 {
23027 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COSTA_RICA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COSTA_RICA)));
23028 }
23029 {
23030 PyDict_SetItemString(d,"LANGUAGE_SPANISH_DOMINICAN_REPUBLIC", SWIG_From_int((int)(wxLANGUAGE_SPANISH_DOMINICAN_REPUBLIC)));
23031 }
23032 {
23033 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ECUADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ECUADOR)));
23034 }
23035 {
23036 PyDict_SetItemString(d,"LANGUAGE_SPANISH_EL_SALVADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_EL_SALVADOR)));
23037 }
23038 {
23039 PyDict_SetItemString(d,"LANGUAGE_SPANISH_GUATEMALA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_GUATEMALA)));
23040 }
23041 {
23042 PyDict_SetItemString(d,"LANGUAGE_SPANISH_HONDURAS", SWIG_From_int((int)(wxLANGUAGE_SPANISH_HONDURAS)));
23043 }
23044 {
23045 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MEXICAN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MEXICAN)));
23046 }
23047 {
23048 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MODERN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MODERN)));
23049 }
23050 {
23051 PyDict_SetItemString(d,"LANGUAGE_SPANISH_NICARAGUA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_NICARAGUA)));
23052 }
23053 {
23054 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PANAMA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PANAMA)));
23055 }
23056 {
23057 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PARAGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PARAGUAY)));
23058 }
23059 {
23060 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PERU", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PERU)));
23061 }
23062 {
23063 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PUERTO_RICO", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PUERTO_RICO)));
23064 }
23065 {
23066 PyDict_SetItemString(d,"LANGUAGE_SPANISH_URUGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_URUGUAY)));
23067 }
23068 {
23069 PyDict_SetItemString(d,"LANGUAGE_SPANISH_US", SWIG_From_int((int)(wxLANGUAGE_SPANISH_US)));
23070 }
23071 {
23072 PyDict_SetItemString(d,"LANGUAGE_SPANISH_VENEZUELA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_VENEZUELA)));
23073 }
23074 {
23075 PyDict_SetItemString(d,"LANGUAGE_SUNDANESE", SWIG_From_int((int)(wxLANGUAGE_SUNDANESE)));
23076 }
23077 {
23078 PyDict_SetItemString(d,"LANGUAGE_SWAHILI", SWIG_From_int((int)(wxLANGUAGE_SWAHILI)));
23079 }
23080 {
23081 PyDict_SetItemString(d,"LANGUAGE_SWEDISH", SWIG_From_int((int)(wxLANGUAGE_SWEDISH)));
23082 }
23083 {
23084 PyDict_SetItemString(d,"LANGUAGE_SWEDISH_FINLAND", SWIG_From_int((int)(wxLANGUAGE_SWEDISH_FINLAND)));
23085 }
23086 {
23087 PyDict_SetItemString(d,"LANGUAGE_TAGALOG", SWIG_From_int((int)(wxLANGUAGE_TAGALOG)));
23088 }
23089 {
23090 PyDict_SetItemString(d,"LANGUAGE_TAJIK", SWIG_From_int((int)(wxLANGUAGE_TAJIK)));
23091 }
23092 {
23093 PyDict_SetItemString(d,"LANGUAGE_TAMIL", SWIG_From_int((int)(wxLANGUAGE_TAMIL)));
23094 }
23095 {
23096 PyDict_SetItemString(d,"LANGUAGE_TATAR", SWIG_From_int((int)(wxLANGUAGE_TATAR)));
23097 }
23098 {
23099 PyDict_SetItemString(d,"LANGUAGE_TELUGU", SWIG_From_int((int)(wxLANGUAGE_TELUGU)));
23100 }
23101 {
23102 PyDict_SetItemString(d,"LANGUAGE_THAI", SWIG_From_int((int)(wxLANGUAGE_THAI)));
23103 }
23104 {
23105 PyDict_SetItemString(d,"LANGUAGE_TIBETAN", SWIG_From_int((int)(wxLANGUAGE_TIBETAN)));
23106 }
23107 {
23108 PyDict_SetItemString(d,"LANGUAGE_TIGRINYA", SWIG_From_int((int)(wxLANGUAGE_TIGRINYA)));
23109 }
23110 {
23111 PyDict_SetItemString(d,"LANGUAGE_TONGA", SWIG_From_int((int)(wxLANGUAGE_TONGA)));
23112 }
23113 {
23114 PyDict_SetItemString(d,"LANGUAGE_TSONGA", SWIG_From_int((int)(wxLANGUAGE_TSONGA)));
23115 }
23116 {
23117 PyDict_SetItemString(d,"LANGUAGE_TURKISH", SWIG_From_int((int)(wxLANGUAGE_TURKISH)));
23118 }
23119 {
23120 PyDict_SetItemString(d,"LANGUAGE_TURKMEN", SWIG_From_int((int)(wxLANGUAGE_TURKMEN)));
23121 }
23122 {
23123 PyDict_SetItemString(d,"LANGUAGE_TWI", SWIG_From_int((int)(wxLANGUAGE_TWI)));
23124 }
23125 {
23126 PyDict_SetItemString(d,"LANGUAGE_UIGHUR", SWIG_From_int((int)(wxLANGUAGE_UIGHUR)));
23127 }
23128 {
23129 PyDict_SetItemString(d,"LANGUAGE_UKRAINIAN", SWIG_From_int((int)(wxLANGUAGE_UKRAINIAN)));
23130 }
23131 {
23132 PyDict_SetItemString(d,"LANGUAGE_URDU", SWIG_From_int((int)(wxLANGUAGE_URDU)));
23133 }
23134 {
23135 PyDict_SetItemString(d,"LANGUAGE_URDU_INDIA", SWIG_From_int((int)(wxLANGUAGE_URDU_INDIA)));
23136 }
23137 {
23138 PyDict_SetItemString(d,"LANGUAGE_URDU_PAKISTAN", SWIG_From_int((int)(wxLANGUAGE_URDU_PAKISTAN)));
23139 }
23140 {
23141 PyDict_SetItemString(d,"LANGUAGE_UZBEK", SWIG_From_int((int)(wxLANGUAGE_UZBEK)));
23142 }
23143 {
23144 PyDict_SetItemString(d,"LANGUAGE_UZBEK_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_UZBEK_CYRILLIC)));
23145 }
23146 {
23147 PyDict_SetItemString(d,"LANGUAGE_UZBEK_LATIN", SWIG_From_int((int)(wxLANGUAGE_UZBEK_LATIN)));
23148 }
23149 {
23150 PyDict_SetItemString(d,"LANGUAGE_VIETNAMESE", SWIG_From_int((int)(wxLANGUAGE_VIETNAMESE)));
23151 }
23152 {
23153 PyDict_SetItemString(d,"LANGUAGE_VOLAPUK", SWIG_From_int((int)(wxLANGUAGE_VOLAPUK)));
23154 }
23155 {
23156 PyDict_SetItemString(d,"LANGUAGE_WELSH", SWIG_From_int((int)(wxLANGUAGE_WELSH)));
23157 }
23158 {
23159 PyDict_SetItemString(d,"LANGUAGE_WOLOF", SWIG_From_int((int)(wxLANGUAGE_WOLOF)));
23160 }
23161 {
23162 PyDict_SetItemString(d,"LANGUAGE_XHOSA", SWIG_From_int((int)(wxLANGUAGE_XHOSA)));
23163 }
23164 {
23165 PyDict_SetItemString(d,"LANGUAGE_YIDDISH", SWIG_From_int((int)(wxLANGUAGE_YIDDISH)));
23166 }
23167 {
23168 PyDict_SetItemString(d,"LANGUAGE_YORUBA", SWIG_From_int((int)(wxLANGUAGE_YORUBA)));
23169 }
23170 {
23171 PyDict_SetItemString(d,"LANGUAGE_ZHUANG", SWIG_From_int((int)(wxLANGUAGE_ZHUANG)));
23172 }
23173 {
23174 PyDict_SetItemString(d,"LANGUAGE_ZULU", SWIG_From_int((int)(wxLANGUAGE_ZULU)));
23175 }
23176 {
23177 PyDict_SetItemString(d,"LANGUAGE_USER_DEFINED", SWIG_From_int((int)(wxLANGUAGE_USER_DEFINED)));
23178 }
23179 {
23180 PyDict_SetItemString(d,"LOCALE_CAT_NUMBER", SWIG_From_int((int)(wxLOCALE_CAT_NUMBER)));
23181 }
23182 {
23183 PyDict_SetItemString(d,"LOCALE_CAT_DATE", SWIG_From_int((int)(wxLOCALE_CAT_DATE)));
23184 }
23185 {
23186 PyDict_SetItemString(d,"LOCALE_CAT_MONEY", SWIG_From_int((int)(wxLOCALE_CAT_MONEY)));
23187 }
23188 {
23189 PyDict_SetItemString(d,"LOCALE_CAT_MAX", SWIG_From_int((int)(wxLOCALE_CAT_MAX)));
23190 }
23191 {
23192 PyDict_SetItemString(d,"LOCALE_THOUSANDS_SEP", SWIG_From_int((int)(wxLOCALE_THOUSANDS_SEP)));
23193 }
23194 {
23195 PyDict_SetItemString(d,"LOCALE_DECIMAL_POINT", SWIG_From_int((int)(wxLOCALE_DECIMAL_POINT)));
23196 }
23197 {
23198 PyDict_SetItemString(d,"LOCALE_LOAD_DEFAULT", SWIG_From_int((int)(wxLOCALE_LOAD_DEFAULT)));
23199 }
23200 {
23201 PyDict_SetItemString(d,"LOCALE_CONV_ENCODING", SWIG_From_int((int)(wxLOCALE_CONV_ENCODING)));
23202 }
23203 {
23204 PyDict_SetItemString(d,"CONVERT_STRICT", SWIG_From_int((int)(wxCONVERT_STRICT)));
23205 }
23206 {
23207 PyDict_SetItemString(d,"CONVERT_SUBSTITUTE", SWIG_From_int((int)(wxCONVERT_SUBSTITUTE)));
23208 }
23209 {
23210 PyDict_SetItemString(d,"PLATFORM_CURRENT", SWIG_From_int((int)(wxPLATFORM_CURRENT)));
23211 }
23212 {
23213 PyDict_SetItemString(d,"PLATFORM_UNIX", SWIG_From_int((int)(wxPLATFORM_UNIX)));
23214 }
23215 {
23216 PyDict_SetItemString(d,"PLATFORM_WINDOWS", SWIG_From_int((int)(wxPLATFORM_WINDOWS)));
23217 }
23218 {
23219 PyDict_SetItemString(d,"PLATFORM_OS2", SWIG_From_int((int)(wxPLATFORM_OS2)));
23220 }
23221 {
23222 PyDict_SetItemString(d,"PLATFORM_MAC", SWIG_From_int((int)(wxPLATFORM_MAC)));
23223 }
23224 {
23225 PyDict_SetItemString(d,"BUFFER_VIRTUAL_AREA", SWIG_From_int((int)(wxBUFFER_VIRTUAL_AREA)));
23226 }
23227 {
23228 PyDict_SetItemString(d,"BUFFER_CLIENT_AREA", SWIG_From_int((int)(wxBUFFER_CLIENT_AREA)));
23229 }
23230 {
23231 PyDict_SetItemString(d,"IMAGELIST_DRAW_NORMAL", SWIG_From_int((int)(wxIMAGELIST_DRAW_NORMAL)));
23232 }
23233 {
23234 PyDict_SetItemString(d,"IMAGELIST_DRAW_TRANSPARENT", SWIG_From_int((int)(wxIMAGELIST_DRAW_TRANSPARENT)));
23235 }
23236 {
23237 PyDict_SetItemString(d,"IMAGELIST_DRAW_SELECTED", SWIG_From_int((int)(wxIMAGELIST_DRAW_SELECTED)));
23238 }
23239 {
23240 PyDict_SetItemString(d,"IMAGELIST_DRAW_FOCUSED", SWIG_From_int((int)(wxIMAGELIST_DRAW_FOCUSED)));
23241 }
23242 {
23243 PyDict_SetItemString(d,"IMAGE_LIST_NORMAL", SWIG_From_int((int)(wxIMAGE_LIST_NORMAL)));
23244 }
23245 {
23246 PyDict_SetItemString(d,"IMAGE_LIST_SMALL", SWIG_From_int((int)(wxIMAGE_LIST_SMALL)));
23247 }
23248 {
23249 PyDict_SetItemString(d,"IMAGE_LIST_STATE", SWIG_From_int((int)(wxIMAGE_LIST_STATE)));
23250 }
23251 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
23252 SWIG_addvarlink(SWIG_globals,(char*)"NORMAL_FONT",_wrap_NORMAL_FONT_get, _wrap_NORMAL_FONT_set);
23253 SWIG_addvarlink(SWIG_globals,(char*)"SMALL_FONT",_wrap_SMALL_FONT_get, _wrap_SMALL_FONT_set);
23254 SWIG_addvarlink(SWIG_globals,(char*)"ITALIC_FONT",_wrap_ITALIC_FONT_get, _wrap_ITALIC_FONT_set);
23255 SWIG_addvarlink(SWIG_globals,(char*)"SWISS_FONT",_wrap_SWISS_FONT_get, _wrap_SWISS_FONT_set);
23256 SWIG_addvarlink(SWIG_globals,(char*)"RED_PEN",_wrap_RED_PEN_get, _wrap_RED_PEN_set);
23257 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_PEN",_wrap_CYAN_PEN_get, _wrap_CYAN_PEN_set);
23258 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_PEN",_wrap_GREEN_PEN_get, _wrap_GREEN_PEN_set);
23259 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_PEN",_wrap_BLACK_PEN_get, _wrap_BLACK_PEN_set);
23260 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_PEN",_wrap_WHITE_PEN_get, _wrap_WHITE_PEN_set);
23261 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_PEN",_wrap_TRANSPARENT_PEN_get, _wrap_TRANSPARENT_PEN_set);
23262 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_DASHED_PEN",_wrap_BLACK_DASHED_PEN_get, _wrap_BLACK_DASHED_PEN_set);
23263 SWIG_addvarlink(SWIG_globals,(char*)"GREY_PEN",_wrap_GREY_PEN_get, _wrap_GREY_PEN_set);
23264 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_PEN",_wrap_MEDIUM_GREY_PEN_get, _wrap_MEDIUM_GREY_PEN_set);
23265 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_PEN",_wrap_LIGHT_GREY_PEN_get, _wrap_LIGHT_GREY_PEN_set);
23266 SWIG_addvarlink(SWIG_globals,(char*)"BLUE_BRUSH",_wrap_BLUE_BRUSH_get, _wrap_BLUE_BRUSH_set);
23267 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_BRUSH",_wrap_GREEN_BRUSH_get, _wrap_GREEN_BRUSH_set);
23268 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_BRUSH",_wrap_WHITE_BRUSH_get, _wrap_WHITE_BRUSH_set);
23269 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_BRUSH",_wrap_BLACK_BRUSH_get, _wrap_BLACK_BRUSH_set);
23270 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_BRUSH",_wrap_TRANSPARENT_BRUSH_get, _wrap_TRANSPARENT_BRUSH_set);
23271 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_BRUSH",_wrap_CYAN_BRUSH_get, _wrap_CYAN_BRUSH_set);
23272 SWIG_addvarlink(SWIG_globals,(char*)"RED_BRUSH",_wrap_RED_BRUSH_get, _wrap_RED_BRUSH_set);
23273 SWIG_addvarlink(SWIG_globals,(char*)"GREY_BRUSH",_wrap_GREY_BRUSH_get, _wrap_GREY_BRUSH_set);
23274 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_BRUSH",_wrap_MEDIUM_GREY_BRUSH_get, _wrap_MEDIUM_GREY_BRUSH_set);
23275 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_BRUSH",_wrap_LIGHT_GREY_BRUSH_get, _wrap_LIGHT_GREY_BRUSH_set);
23276 SWIG_addvarlink(SWIG_globals,(char*)"BLACK",_wrap_BLACK_get, _wrap_BLACK_set);
23277 SWIG_addvarlink(SWIG_globals,(char*)"WHITE",_wrap_WHITE_get, _wrap_WHITE_set);
23278 SWIG_addvarlink(SWIG_globals,(char*)"RED",_wrap_RED_get, _wrap_RED_set);
23279 SWIG_addvarlink(SWIG_globals,(char*)"BLUE",_wrap_BLUE_get, _wrap_BLUE_set);
23280 SWIG_addvarlink(SWIG_globals,(char*)"GREEN",_wrap_GREEN_get, _wrap_GREEN_set);
23281 SWIG_addvarlink(SWIG_globals,(char*)"CYAN",_wrap_CYAN_get, _wrap_CYAN_set);
23282 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY",_wrap_LIGHT_GREY_get, _wrap_LIGHT_GREY_set);
23283 SWIG_addvarlink(SWIG_globals,(char*)"STANDARD_CURSOR",_wrap_STANDARD_CURSOR_get, _wrap_STANDARD_CURSOR_set);
23284 SWIG_addvarlink(SWIG_globals,(char*)"HOURGLASS_CURSOR",_wrap_HOURGLASS_CURSOR_get, _wrap_HOURGLASS_CURSOR_set);
23285 SWIG_addvarlink(SWIG_globals,(char*)"CROSS_CURSOR",_wrap_CROSS_CURSOR_get, _wrap_CROSS_CURSOR_set);
23286 SWIG_addvarlink(SWIG_globals,(char*)"NullBitmap",_wrap_NullBitmap_get, _wrap_NullBitmap_set);
23287 SWIG_addvarlink(SWIG_globals,(char*)"NullIcon",_wrap_NullIcon_get, _wrap_NullIcon_set);
23288 SWIG_addvarlink(SWIG_globals,(char*)"NullCursor",_wrap_NullCursor_get, _wrap_NullCursor_set);
23289 SWIG_addvarlink(SWIG_globals,(char*)"NullPen",_wrap_NullPen_get, _wrap_NullPen_set);
23290 SWIG_addvarlink(SWIG_globals,(char*)"NullBrush",_wrap_NullBrush_get, _wrap_NullBrush_set);
23291 SWIG_addvarlink(SWIG_globals,(char*)"NullPalette",_wrap_NullPalette_get, _wrap_NullPalette_set);
23292 SWIG_addvarlink(SWIG_globals,(char*)"NullFont",_wrap_NullFont_get, _wrap_NullFont_set);
23293 SWIG_addvarlink(SWIG_globals,(char*)"NullColour",_wrap_NullColour_get, _wrap_NullColour_set);
23294 SWIG_addvarlink(SWIG_globals,(char*)"TheFontList",_wrap_TheFontList_get, _wrap_TheFontList_set);
23295 SWIG_addvarlink(SWIG_globals,(char*)"ThePenList",_wrap_ThePenList_get, _wrap_ThePenList_set);
23296 SWIG_addvarlink(SWIG_globals,(char*)"TheBrushList",_wrap_TheBrushList_get, _wrap_TheBrushList_set);
23297 SWIG_addvarlink(SWIG_globals,(char*)"TheColourDatabase",_wrap_TheColourDatabase_get, _wrap_TheColourDatabase_set);
23298
23299 // Work around a chicken/egg problem in drawlist.cpp
23300 wxPyDrawList_SetAPIPtr();
23301
23302 }
23303
wxWidgets (Impactor)