]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_gdi_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Get rid of wxFontMapper in wxBase library.
[wxWidgets.git] / wxPython / src / gtk / _gdi_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 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 wxPyBlock_t 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 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1736 int size = PyList_Size(pyDashes);
1737 wxDash* dashes = (wxDash*)byte_LIST_helper(pyDashes);
1738
1739 // black magic warning! The array of wxDashes needs to exist as
1740 // long as the pen does because wxPen does not copy the array. So
1741 // stick a copy in a Python string object and attach it to _self,
1742 // and then call SetDashes with a pointer to that array. Then
1743 // when the Python pen object is destroyed the array will be
1744 // cleaned up too.
1745 PyObject* strDashes = PyString_FromStringAndSize((char*)dashes, size*sizeof(wxDash));
1746 PyObject_SetAttrString(_self, "_dashes", strDashes);
1747
1748 self->SetDashes(size, (wxDash*)PyString_AS_STRING(strDashes));
1749 delete [] dashes;
1750 Py_DECREF(strDashes);
1751 wxPyEndBlockThreads(blocked);
1752 }
1753 static bool wxPen___eq__(wxPen *self,wxPen const *other){ return other ? (*self == *other) : false; }
1754 static bool wxPen___ne__(wxPen *self,wxPen const *other){ return other ? (*self != *other) : true; }
1755
1756 #include <wx/image.h>
1757
1758 static char** ConvertListOfStrings(PyObject* listOfStrings) {
1759 char** cArray = NULL;
1760 int count;
1761
1762 if (!PyList_Check(listOfStrings)) {
1763 PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
1764 return NULL;
1765 }
1766 count = PyList_Size(listOfStrings);
1767 cArray = new char*[count];
1768
1769 for(int x=0; x<count; x++) {
1770 // TODO: Need some validation and error checking here
1771 cArray[x] = PyString_AsString(PyList_GET_ITEM(listOfStrings, x));
1772 }
1773 return cArray;
1774 }
1775
1776
1777 static wxBitmap *new_wxBitmap(PyObject *listOfStrings){
1778 char** cArray = NULL;
1779 wxBitmap* bmp;
1780
1781 cArray = ConvertListOfStrings(listOfStrings);
1782 if (! cArray)
1783 return NULL;
1784 bmp = new wxBitmap(cArray);
1785 delete [] cArray;
1786 return bmp;
1787 }
1788 static wxBitmap *new_wxBitmap(PyObject *bits,int width,int height,int depth=1){
1789 char* buf;
1790 int length;
1791 PyString_AsStringAndSize(bits, &buf, &length);
1792 return new wxBitmap(buf, width, height, depth);
1793 }
1794 static wxSize wxBitmap_GetSize(wxBitmap *self){
1795 wxSize size(self->GetWidth(), self->GetHeight());
1796 return size;
1797 }
1798 static void wxBitmap_SetMaskColour(wxBitmap *self,wxColour const &colour){
1799 wxMask *mask = new wxMask(*self, colour);
1800 self->SetMask(mask);
1801 }
1802 static void wxBitmap_SetSize(wxBitmap *self,wxSize const &size){
1803 self->SetWidth(size.x);
1804 self->SetHeight(size.y);
1805 }
1806 static bool wxBitmap___eq__(wxBitmap *self,wxBitmap const *other){ return other ? (*self == *other) : false; }
1807 static bool wxBitmap___ne__(wxBitmap *self,wxBitmap const *other){ return other ? (*self != *other) : true; }
1808 static wxMask *new_wxMask(wxBitmap const &bitmap,wxColour const &colour=wxNullColour){
1809 if ( !colour.Ok() )
1810 return new wxMask(bitmap, *wxBLACK);
1811 else
1812 return new wxMask(bitmap, colour);
1813 }
1814
1815 #include <wx/iconbndl.h>
1816
1817 static wxIcon *new_wxIcon(wxBitmap const &bmp){
1818 wxIcon* icon = new wxIcon();
1819 icon->CopyFromBitmap(bmp);
1820 return icon;
1821 }
1822 static wxIcon *new_wxIcon(PyObject *listOfStrings){
1823 char** cArray = NULL;
1824 wxIcon* icon;
1825
1826 cArray = ConvertListOfStrings(listOfStrings);
1827 if (! cArray)
1828 return NULL;
1829 icon = new wxIcon(cArray);
1830 delete [] cArray;
1831 return icon;
1832 }
1833 static wxIconLocation *new_wxIconLocation(wxString const *filename=&wxPyEmptyString,int num=0){
1834
1835
1836
1837 return new wxIconLocation(*filename);
1838
1839 }
1840 static void wxIconLocation_SetIndex(wxIconLocation *self,int num){
1841
1842
1843
1844 // do nothing
1845
1846 }
1847 static int wxIconLocation_GetIndex(wxIconLocation *self){
1848
1849
1850
1851 return -1;
1852
1853 }
1854
1855 SWIGINTERNSHORT long
1856 SWIG_As_long(PyObject* obj)
1857 {
1858 long v;
1859 if (!SWIG_AsVal_long(obj, &v)) {
1860 /*
1861 this is needed to make valgrind/purify happier.
1862 */
1863 memset((void*)&v, 0, sizeof(long));
1864 }
1865 return v;
1866 }
1867
1868
1869 SWIGINTERNSHORT int
1870 SWIG_Check_long(PyObject* obj)
1871 {
1872 return SWIG_AsVal_long(obj, (long*)0);
1873 }
1874
1875 static wxCursor *new_wxCursor(wxString const &cursorName,long type,int hotSpotX=0,int hotSpotY=0){
1876 #ifdef __WXGTK__
1877 wxImage img(cursorName, type);
1878 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X, hotSpotX);
1879 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y, hotSpotY);
1880 return new wxCursor(img);
1881 #else
1882 return new wxCursor(cursorName, type, hotSpotX, hotSpotY);
1883 #endif
1884 }
1885
1886
1887 static void wxRegionIterator_Next(wxRegionIterator *self){
1888 (*self) ++;
1889 }
1890 static bool wxRegionIterator___nonzero__(wxRegionIterator *self){
1891 return self->operator bool();
1892 }
1893
1894 #include <wx/fontutil.h>
1895 #include <wx/fontmap.h>
1896 #include <wx/fontenum.h>
1897
1898 static wxString wxNativeFontInfo___str__(wxNativeFontInfo *self){
1899 return self->ToString();
1900 }
1901
1902 wxNativeEncodingInfo* wxGetNativeFontEncoding(wxFontEncoding encoding) {
1903 static wxNativeEncodingInfo info;
1904 if ( wxGetNativeFontEncoding(encoding, &info) )
1905 return &info;
1906 else
1907 return NULL;
1908 }
1909
1910 static PyObject *wxFontMapper_GetAltForEncoding(wxFontMapper *self,wxFontEncoding encoding,wxString const &facename=wxPyEmptyString,bool interactive=true){
1911 wxFontEncoding alt_enc;
1912 if (self->GetAltForEncoding(encoding, &alt_enc, facename, interactive))
1913 return PyInt_FromLong(alt_enc);
1914 else {
1915 Py_INCREF(Py_None);
1916 return Py_None;
1917 }
1918 }
1919 static wxFont *new_wxFont(wxString const &info){
1920 wxNativeFontInfo nfi;
1921 nfi.FromString(info);
1922 return new wxFont(nfi);
1923 }
1924 static wxFont *new_wxFont(int pointSize,wxFontFamily family,int flags=wxFONTFLAG_DEFAULT,wxString const &face=wxPyEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1925 return wxFont::New(pointSize, family, flags, face, encoding);
1926 }
1927 static wxFont *new_wxFont(wxSize const &pixelSize,int family,int style,int weight,bool underlined=false,wxString const &face=wxEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1928 return wxFontBase::New(pixelSize, family,
1929 style, weight, underlined,
1930 face, encoding);
1931 }
1932 static bool wxFont___eq__(wxFont *self,wxFont const *other){ return other ? (*self == *other) : false; }
1933 static bool wxFont___ne__(wxFont *self,wxFont const *other){ return other ? (*self != *other) : true; }
1934
1935 class wxPyFontEnumerator : public wxFontEnumerator {
1936 public:
1937 wxPyFontEnumerator() {}
1938 ~wxPyFontEnumerator() {}
1939
1940 DEC_PYCALLBACK_BOOL_STRING(OnFacename);
1941 DEC_PYCALLBACK_BOOL_STRINGSTRING(OnFontEncoding);
1942
1943 PYPRIVATE;
1944 };
1945
1946 IMP_PYCALLBACK_BOOL_STRING(wxPyFontEnumerator, wxFontEnumerator, OnFacename);
1947 IMP_PYCALLBACK_BOOL_STRINGSTRING(wxPyFontEnumerator, wxFontEnumerator, OnFontEncoding);
1948
1949
1950 static PyObject *wxPyFontEnumerator_GetEncodings(wxPyFontEnumerator *self){
1951 wxArrayString* arr = self->GetEncodings();
1952 if (arr)
1953 return wxArrayString2PyList_helper(*arr);
1954 else
1955 return PyList_New(0);
1956 }
1957 static PyObject *wxPyFontEnumerator_GetFacenames(wxPyFontEnumerator *self){
1958 wxArrayString* arr = self->GetFacenames();
1959 if (arr)
1960 return wxArrayString2PyList_helper(*arr);
1961 else
1962 return PyList_New(0);
1963 }
1964
1965 #include <locale.h>
1966
1967 static wxLocale *new_wxLocale(int language=-1,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
1968 wxLocale* loc;
1969 if (language == -1)
1970 loc = new wxLocale();
1971 else
1972 loc = new wxLocale(language, flags);
1973 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1974 // for the floating point conversions and such to work right.
1975 #if PY_VERSION_HEX < 0x02040000
1976 setlocale(LC_NUMERIC, "C");
1977 #endif
1978 return loc;
1979 }
1980 static bool wxLocale_Init1(wxLocale *self,wxString const &szName,wxString const &szShort=wxPyEmptyString,wxString const &szLocale=wxPyEmptyString,bool bLoadDefault=true,bool bConvertEncoding=false){
1981 bool rc = self->Init(szName, szShort, szLocale, bLoadDefault, bConvertEncoding);
1982 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1983 // for the floating point conversions and such to work right.
1984 #if PY_VERSION_HEX < 0x02040000
1985 setlocale(LC_NUMERIC, "C");
1986 #endif
1987 return rc;
1988 }
1989 static bool wxLocale_Init2(wxLocale *self,int language=wxLANGUAGE_DEFAULT,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
1990 bool rc = self->Init(language, flags);
1991 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1992 // for the floating point conversions and such to work right.
1993 #if PY_VERSION_HEX < 0x02040000
1994 setlocale(LC_NUMERIC, "C");
1995 #endif
1996 return rc;
1997 }
1998
1999 #include "wx/wxPython/pydrawxxx.h"
2000
2001 static wxColour wxDC_GetPixel(wxDC *self,int x,int y){
2002 wxColour col;
2003 self->GetPixel(x, y, &col);
2004 return col;
2005 }
2006 static wxColour wxDC_GetPixelPoint(wxDC *self,wxPoint const &pt){
2007 wxColour col;
2008 self->GetPixel(pt, &col);
2009 return col;
2010 }
2011
2012 SWIGINTERN int
2013 SWIG_AsVal_double(PyObject *obj, double* val)
2014 {
2015 if (PyNumber_Check(obj)) {
2016 if (val) *val = PyFloat_AsDouble(obj);
2017 return 1;
2018 }
2019 else {
2020 SWIG_type_error("number", obj);
2021 }
2022 return 0;
2023 }
2024
2025
2026 SWIGINTERNSHORT double
2027 SWIG_As_double(PyObject* obj)
2028 {
2029 double v;
2030 if (!SWIG_AsVal_double(obj, &v)) {
2031 /*
2032 this is needed to make valgrind/purify happier.
2033 */
2034 memset((void*)&v, 0, sizeof(double));
2035 }
2036 return v;
2037 }
2038
2039
2040 SWIGINTERNSHORT int
2041 SWIG_Check_double(PyObject* obj)
2042 {
2043 return SWIG_AsVal_double(obj, (double*)0);
2044 }
2045
2046 static wxRect wxDC_DrawImageLabel(wxDC *self,wxString const &text,wxBitmap const &image,wxRect const &rect,int alignment=wxALIGN_LEFT|wxALIGN_TOP,int indexAccel=-1){
2047 wxRect rv;
2048 self->DrawLabel(text, image, rect, alignment, indexAccel, &rv);
2049 return rv;
2050 }
2051
2052 static wxRect wxDC_GetClippingRect(wxDC *self){
2053 wxRect rect;
2054 self->GetClippingBox(rect);
2055 return rect;
2056 }
2057 static wxArrayInt wxDC_GetPartialTextExtents(wxDC *self,wxString const &text){
2058 wxArrayInt widths;
2059 self->GetPartialTextExtents(text, widths);
2060 return widths;
2061 }
2062
2063 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2064 #define SWIG_From_double PyFloat_FromDouble
2065 /*@@*/
2066
2067
2068 static void wxDC_SetLogicalOriginPoint(wxDC *self,wxPoint const &point){
2069 self->SetLogicalOrigin(point.x, point.y);
2070 }
2071 static void wxDC_SetDeviceOriginPoint(wxDC *self,wxPoint const &point){
2072 self->SetDeviceOrigin(point.x, point.y);
2073 }
2074 static void wxDC_CalcBoundingBoxPoint(wxDC *self,wxPoint const &point){
2075 self->CalcBoundingBox(point.x, point.y);
2076 }
2077 static PyObject *wxDC__DrawPointList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2078 return wxPyDrawXXXList(*self, wxPyDrawXXXPoint, pyCoords, pyPens, pyBrushes);
2079 }
2080 static PyObject *wxDC__DrawLineList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2081 return wxPyDrawXXXList(*self, wxPyDrawXXXLine, pyCoords, pyPens, pyBrushes);
2082 }
2083 static PyObject *wxDC__DrawRectangleList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2084 return wxPyDrawXXXList(*self, wxPyDrawXXXRectangle, pyCoords, pyPens, pyBrushes);
2085 }
2086 static PyObject *wxDC__DrawEllipseList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2087 return wxPyDrawXXXList(*self, wxPyDrawXXXEllipse, pyCoords, pyPens, pyBrushes);
2088 }
2089 static PyObject *wxDC__DrawPolygonList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2090 return wxPyDrawXXXList(*self, wxPyDrawXXXPolygon, pyCoords, pyPens, pyBrushes);
2091 }
2092 static PyObject *wxDC__DrawTextList(wxDC *self,PyObject *textList,PyObject *pyPoints,PyObject *foregroundList,PyObject *backgroundList){
2093 return wxPyDrawTextList(*self, textList, pyPoints, foregroundList, backgroundList);
2094 }
2095
2096 static void wxDC_GetBoundingBox(wxDC* dc, int* x1, int* y1, int* x2, int* y2) {
2097 *x1 = dc->MinX();
2098 *y1 = dc->MinY();
2099 *x2 = dc->MaxX();
2100 *y2 = dc->MaxY();
2101 }
2102
2103
2104 #include <wx/dcbuffer.h>
2105
2106
2107 #include <wx/dcps.h>
2108
2109
2110 class wxMetaFile : public wxObject {
2111 public:
2112 wxMetaFile(const wxString&)
2113 { wxPyRaiseNotImplemented(); }
2114 };
2115
2116 class wxMetaFileDC : public wxClientDC {
2117 public:
2118 wxMetaFileDC(const wxString&, int, int, const wxString&)
2119 { wxPyRaiseNotImplemented(); }
2120 };
2121
2122
2123
2124 class wxPrinterDC : public wxClientDC {
2125 public:
2126 wxPrinterDC(const wxPrintData&)
2127 { wxPyRaiseNotImplemented(); }
2128
2129 };
2130
2131
2132
2133 static void wxColourDatabase_Append(wxColourDatabase *self,wxString const &name,int red,int green,int blue){
2134 self->AddColour(name, wxColour(red, green, blue));
2135 }
2136
2137 #include <wx/effects.h>
2138
2139 #ifdef __cplusplus
2140 extern "C" {
2141 #endif
2142 static PyObject *_wrap_new_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2143 PyObject *resultobj;
2144 wxGDIObject *result;
2145 char *kwnames[] = {
2146 NULL
2147 };
2148
2149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GDIObject",kwnames)) goto fail;
2150 {
2151 if (!wxPyCheckForApp()) SWIG_fail;
2152 PyThreadState* __tstate = wxPyBeginAllowThreads();
2153 result = (wxGDIObject *)new wxGDIObject();
2154
2155 wxPyEndAllowThreads(__tstate);
2156 if (PyErr_Occurred()) SWIG_fail;
2157 }
2158 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGDIObject, 1);
2159 return resultobj;
2160 fail:
2161 return NULL;
2162 }
2163
2164
2165 static PyObject *_wrap_delete_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2166 PyObject *resultobj;
2167 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2168 PyObject * obj0 = 0 ;
2169 char *kwnames[] = {
2170 (char *) "self", NULL
2171 };
2172
2173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GDIObject",kwnames,&obj0)) goto fail;
2174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2175 if (SWIG_arg_fail(1)) SWIG_fail;
2176 {
2177 PyThreadState* __tstate = wxPyBeginAllowThreads();
2178 delete arg1;
2179
2180 wxPyEndAllowThreads(__tstate);
2181 if (PyErr_Occurred()) SWIG_fail;
2182 }
2183 Py_INCREF(Py_None); resultobj = Py_None;
2184 return resultobj;
2185 fail:
2186 return NULL;
2187 }
2188
2189
2190 static PyObject *_wrap_GDIObject_GetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2191 PyObject *resultobj;
2192 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2193 bool result;
2194 PyObject * obj0 = 0 ;
2195 char *kwnames[] = {
2196 (char *) "self", NULL
2197 };
2198
2199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_GetVisible",kwnames,&obj0)) goto fail;
2200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2201 if (SWIG_arg_fail(1)) SWIG_fail;
2202 {
2203 PyThreadState* __tstate = wxPyBeginAllowThreads();
2204 result = (bool)(arg1)->GetVisible();
2205
2206 wxPyEndAllowThreads(__tstate);
2207 if (PyErr_Occurred()) SWIG_fail;
2208 }
2209 {
2210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2211 }
2212 return resultobj;
2213 fail:
2214 return NULL;
2215 }
2216
2217
2218 static PyObject *_wrap_GDIObject_SetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2219 PyObject *resultobj;
2220 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2221 bool arg2 ;
2222 PyObject * obj0 = 0 ;
2223 PyObject * obj1 = 0 ;
2224 char *kwnames[] = {
2225 (char *) "self",(char *) "visible", NULL
2226 };
2227
2228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GDIObject_SetVisible",kwnames,&obj0,&obj1)) 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 arg2 = (bool)(SWIG_As_bool(obj1));
2233 if (SWIG_arg_fail(2)) SWIG_fail;
2234 }
2235 {
2236 PyThreadState* __tstate = wxPyBeginAllowThreads();
2237 (arg1)->SetVisible(arg2);
2238
2239 wxPyEndAllowThreads(__tstate);
2240 if (PyErr_Occurred()) SWIG_fail;
2241 }
2242 Py_INCREF(Py_None); resultobj = Py_None;
2243 return resultobj;
2244 fail:
2245 return NULL;
2246 }
2247
2248
2249 static PyObject *_wrap_GDIObject_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
2250 PyObject *resultobj;
2251 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2252 bool result;
2253 PyObject * obj0 = 0 ;
2254 char *kwnames[] = {
2255 (char *) "self", NULL
2256 };
2257
2258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_IsNull",kwnames,&obj0)) goto fail;
2259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2260 if (SWIG_arg_fail(1)) SWIG_fail;
2261 {
2262 PyThreadState* __tstate = wxPyBeginAllowThreads();
2263 result = (bool)(arg1)->IsNull();
2264
2265 wxPyEndAllowThreads(__tstate);
2266 if (PyErr_Occurred()) SWIG_fail;
2267 }
2268 {
2269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2270 }
2271 return resultobj;
2272 fail:
2273 return NULL;
2274 }
2275
2276
2277 static PyObject * GDIObject_swigregister(PyObject *, PyObject *args) {
2278 PyObject *obj;
2279 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2280 SWIG_TypeClientData(SWIGTYPE_p_wxGDIObject, obj);
2281 Py_INCREF(obj);
2282 return Py_BuildValue((char *)"");
2283 }
2284 static PyObject *_wrap_new_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2285 PyObject *resultobj;
2286 byte arg1 = (byte) 0 ;
2287 byte arg2 = (byte) 0 ;
2288 byte arg3 = (byte) 0 ;
2289 wxColour *result;
2290 PyObject * obj0 = 0 ;
2291 PyObject * obj1 = 0 ;
2292 PyObject * obj2 = 0 ;
2293 char *kwnames[] = {
2294 (char *) "red",(char *) "green",(char *) "blue", NULL
2295 };
2296
2297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Colour",kwnames,&obj0,&obj1,&obj2)) goto fail;
2298 if (obj0) {
2299 {
2300 arg1 = (byte)(SWIG_As_unsigned_SS_char(obj0));
2301 if (SWIG_arg_fail(1)) SWIG_fail;
2302 }
2303 }
2304 if (obj1) {
2305 {
2306 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2307 if (SWIG_arg_fail(2)) SWIG_fail;
2308 }
2309 }
2310 if (obj2) {
2311 {
2312 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2313 if (SWIG_arg_fail(3)) SWIG_fail;
2314 }
2315 }
2316 {
2317 PyThreadState* __tstate = wxPyBeginAllowThreads();
2318 result = (wxColour *)new wxColour(arg1,arg2,arg3);
2319
2320 wxPyEndAllowThreads(__tstate);
2321 if (PyErr_Occurred()) SWIG_fail;
2322 }
2323 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2324 return resultobj;
2325 fail:
2326 return NULL;
2327 }
2328
2329
2330 static PyObject *_wrap_new_NamedColour(PyObject *, PyObject *args, PyObject *kwargs) {
2331 PyObject *resultobj;
2332 wxString *arg1 = 0 ;
2333 wxColour *result;
2334 bool temp1 = false ;
2335 PyObject * obj0 = 0 ;
2336 char *kwnames[] = {
2337 (char *) "colorName", NULL
2338 };
2339
2340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_NamedColour",kwnames,&obj0)) goto fail;
2341 {
2342 arg1 = wxString_in_helper(obj0);
2343 if (arg1 == NULL) SWIG_fail;
2344 temp1 = true;
2345 }
2346 {
2347 if (!wxPyCheckForApp()) SWIG_fail;
2348 PyThreadState* __tstate = wxPyBeginAllowThreads();
2349 result = (wxColour *)new wxColour((wxString const &)*arg1);
2350
2351 wxPyEndAllowThreads(__tstate);
2352 if (PyErr_Occurred()) SWIG_fail;
2353 }
2354 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2355 {
2356 if (temp1)
2357 delete arg1;
2358 }
2359 return resultobj;
2360 fail:
2361 {
2362 if (temp1)
2363 delete arg1;
2364 }
2365 return NULL;
2366 }
2367
2368
2369 static PyObject *_wrap_new_ColourRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2370 PyObject *resultobj;
2371 unsigned long arg1 ;
2372 wxColour *result;
2373 PyObject * obj0 = 0 ;
2374 char *kwnames[] = {
2375 (char *) "colRGB", NULL
2376 };
2377
2378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ColourRGB",kwnames,&obj0)) goto fail;
2379 {
2380 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
2381 if (SWIG_arg_fail(1)) SWIG_fail;
2382 }
2383 {
2384 PyThreadState* __tstate = wxPyBeginAllowThreads();
2385 result = (wxColour *)new wxColour(arg1);
2386
2387 wxPyEndAllowThreads(__tstate);
2388 if (PyErr_Occurred()) SWIG_fail;
2389 }
2390 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2391 return resultobj;
2392 fail:
2393 return NULL;
2394 }
2395
2396
2397 static PyObject *_wrap_delete_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2398 PyObject *resultobj;
2399 wxColour *arg1 = (wxColour *) 0 ;
2400 PyObject * obj0 = 0 ;
2401 char *kwnames[] = {
2402 (char *) "self", NULL
2403 };
2404
2405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Colour",kwnames,&obj0)) goto fail;
2406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2407 if (SWIG_arg_fail(1)) SWIG_fail;
2408 {
2409 PyThreadState* __tstate = wxPyBeginAllowThreads();
2410 delete arg1;
2411
2412 wxPyEndAllowThreads(__tstate);
2413 if (PyErr_Occurred()) SWIG_fail;
2414 }
2415 Py_INCREF(Py_None); resultobj = Py_None;
2416 return resultobj;
2417 fail:
2418 return NULL;
2419 }
2420
2421
2422 static PyObject *_wrap_Colour_Red(PyObject *, PyObject *args, PyObject *kwargs) {
2423 PyObject *resultobj;
2424 wxColour *arg1 = (wxColour *) 0 ;
2425 byte result;
2426 PyObject * obj0 = 0 ;
2427 char *kwnames[] = {
2428 (char *) "self", NULL
2429 };
2430
2431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Red",kwnames,&obj0)) goto fail;
2432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2433 if (SWIG_arg_fail(1)) SWIG_fail;
2434 {
2435 PyThreadState* __tstate = wxPyBeginAllowThreads();
2436 result = (byte)(arg1)->Red();
2437
2438 wxPyEndAllowThreads(__tstate);
2439 if (PyErr_Occurred()) SWIG_fail;
2440 }
2441 {
2442 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2443 }
2444 return resultobj;
2445 fail:
2446 return NULL;
2447 }
2448
2449
2450 static PyObject *_wrap_Colour_Green(PyObject *, PyObject *args, PyObject *kwargs) {
2451 PyObject *resultobj;
2452 wxColour *arg1 = (wxColour *) 0 ;
2453 byte result;
2454 PyObject * obj0 = 0 ;
2455 char *kwnames[] = {
2456 (char *) "self", NULL
2457 };
2458
2459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Green",kwnames,&obj0)) goto fail;
2460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2461 if (SWIG_arg_fail(1)) SWIG_fail;
2462 {
2463 PyThreadState* __tstate = wxPyBeginAllowThreads();
2464 result = (byte)(arg1)->Green();
2465
2466 wxPyEndAllowThreads(__tstate);
2467 if (PyErr_Occurred()) SWIG_fail;
2468 }
2469 {
2470 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2471 }
2472 return resultobj;
2473 fail:
2474 return NULL;
2475 }
2476
2477
2478 static PyObject *_wrap_Colour_Blue(PyObject *, PyObject *args, PyObject *kwargs) {
2479 PyObject *resultobj;
2480 wxColour *arg1 = (wxColour *) 0 ;
2481 byte result;
2482 PyObject * obj0 = 0 ;
2483 char *kwnames[] = {
2484 (char *) "self", NULL
2485 };
2486
2487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Blue",kwnames,&obj0)) goto fail;
2488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2489 if (SWIG_arg_fail(1)) SWIG_fail;
2490 {
2491 PyThreadState* __tstate = wxPyBeginAllowThreads();
2492 result = (byte)(arg1)->Blue();
2493
2494 wxPyEndAllowThreads(__tstate);
2495 if (PyErr_Occurred()) SWIG_fail;
2496 }
2497 {
2498 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2499 }
2500 return resultobj;
2501 fail:
2502 return NULL;
2503 }
2504
2505
2506 static PyObject *_wrap_Colour_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
2507 PyObject *resultobj;
2508 wxColour *arg1 = (wxColour *) 0 ;
2509 bool result;
2510 PyObject * obj0 = 0 ;
2511 char *kwnames[] = {
2512 (char *) "self", NULL
2513 };
2514
2515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Ok",kwnames,&obj0)) goto fail;
2516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2517 if (SWIG_arg_fail(1)) SWIG_fail;
2518 {
2519 PyThreadState* __tstate = wxPyBeginAllowThreads();
2520 result = (bool)(arg1)->Ok();
2521
2522 wxPyEndAllowThreads(__tstate);
2523 if (PyErr_Occurred()) SWIG_fail;
2524 }
2525 {
2526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2527 }
2528 return resultobj;
2529 fail:
2530 return NULL;
2531 }
2532
2533
2534 static PyObject *_wrap_Colour_Set(PyObject *, PyObject *args, PyObject *kwargs) {
2535 PyObject *resultobj;
2536 wxColour *arg1 = (wxColour *) 0 ;
2537 byte arg2 ;
2538 byte arg3 ;
2539 byte arg4 ;
2540 PyObject * obj0 = 0 ;
2541 PyObject * obj1 = 0 ;
2542 PyObject * obj2 = 0 ;
2543 PyObject * obj3 = 0 ;
2544 char *kwnames[] = {
2545 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2546 };
2547
2548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Colour_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2550 if (SWIG_arg_fail(1)) SWIG_fail;
2551 {
2552 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2553 if (SWIG_arg_fail(2)) SWIG_fail;
2554 }
2555 {
2556 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2557 if (SWIG_arg_fail(3)) SWIG_fail;
2558 }
2559 {
2560 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2561 if (SWIG_arg_fail(4)) SWIG_fail;
2562 }
2563 {
2564 PyThreadState* __tstate = wxPyBeginAllowThreads();
2565 (arg1)->Set(arg2,arg3,arg4);
2566
2567 wxPyEndAllowThreads(__tstate);
2568 if (PyErr_Occurred()) SWIG_fail;
2569 }
2570 Py_INCREF(Py_None); resultobj = Py_None;
2571 return resultobj;
2572 fail:
2573 return NULL;
2574 }
2575
2576
2577 static PyObject *_wrap_Colour_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2578 PyObject *resultobj;
2579 wxColour *arg1 = (wxColour *) 0 ;
2580 unsigned long arg2 ;
2581 PyObject * obj0 = 0 ;
2582 PyObject * obj1 = 0 ;
2583 char *kwnames[] = {
2584 (char *) "self",(char *) "colRGB", NULL
2585 };
2586
2587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetRGB",kwnames,&obj0,&obj1)) goto fail;
2588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2589 if (SWIG_arg_fail(1)) SWIG_fail;
2590 {
2591 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
2592 if (SWIG_arg_fail(2)) SWIG_fail;
2593 }
2594 {
2595 PyThreadState* __tstate = wxPyBeginAllowThreads();
2596 (arg1)->Set(arg2);
2597
2598 wxPyEndAllowThreads(__tstate);
2599 if (PyErr_Occurred()) SWIG_fail;
2600 }
2601 Py_INCREF(Py_None); resultobj = Py_None;
2602 return resultobj;
2603 fail:
2604 return NULL;
2605 }
2606
2607
2608 static PyObject *_wrap_Colour_SetFromName(PyObject *, PyObject *args, PyObject *kwargs) {
2609 PyObject *resultobj;
2610 wxColour *arg1 = (wxColour *) 0 ;
2611 wxString *arg2 = 0 ;
2612 bool temp2 = false ;
2613 PyObject * obj0 = 0 ;
2614 PyObject * obj1 = 0 ;
2615 char *kwnames[] = {
2616 (char *) "self",(char *) "colourName", NULL
2617 };
2618
2619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetFromName",kwnames,&obj0,&obj1)) goto fail;
2620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2621 if (SWIG_arg_fail(1)) SWIG_fail;
2622 {
2623 arg2 = wxString_in_helper(obj1);
2624 if (arg2 == NULL) SWIG_fail;
2625 temp2 = true;
2626 }
2627 {
2628 PyThreadState* __tstate = wxPyBeginAllowThreads();
2629 (arg1)->InitFromName((wxString const &)*arg2);
2630
2631 wxPyEndAllowThreads(__tstate);
2632 if (PyErr_Occurred()) SWIG_fail;
2633 }
2634 Py_INCREF(Py_None); resultobj = Py_None;
2635 {
2636 if (temp2)
2637 delete arg2;
2638 }
2639 return resultobj;
2640 fail:
2641 {
2642 if (temp2)
2643 delete arg2;
2644 }
2645 return NULL;
2646 }
2647
2648
2649 static PyObject *_wrap_Colour_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2650 PyObject *resultobj;
2651 wxColour *arg1 = (wxColour *) 0 ;
2652 long result;
2653 PyObject * obj0 = 0 ;
2654 char *kwnames[] = {
2655 (char *) "self", NULL
2656 };
2657
2658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetPixel",kwnames,&obj0)) goto fail;
2659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2660 if (SWIG_arg_fail(1)) SWIG_fail;
2661 {
2662 PyThreadState* __tstate = wxPyBeginAllowThreads();
2663 result = (long)((wxColour const *)arg1)->GetPixel();
2664
2665 wxPyEndAllowThreads(__tstate);
2666 if (PyErr_Occurred()) SWIG_fail;
2667 }
2668 {
2669 resultobj = SWIG_From_long((long)(result));
2670 }
2671 return resultobj;
2672 fail:
2673 return NULL;
2674 }
2675
2676
2677 static PyObject *_wrap_Colour___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
2678 PyObject *resultobj;
2679 wxColour *arg1 = (wxColour *) 0 ;
2680 wxColour *arg2 = 0 ;
2681 bool result;
2682 wxColour temp2 ;
2683 PyObject * obj0 = 0 ;
2684 PyObject * obj1 = 0 ;
2685 char *kwnames[] = {
2686 (char *) "self",(char *) "colour", NULL
2687 };
2688
2689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___eq__",kwnames,&obj0,&obj1)) goto fail;
2690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2691 if (SWIG_arg_fail(1)) SWIG_fail;
2692 {
2693 arg2 = &temp2;
2694 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2695 }
2696 {
2697 PyThreadState* __tstate = wxPyBeginAllowThreads();
2698 result = (bool)((wxColour const *)arg1)->operator ==((wxColour const &)*arg2);
2699
2700 wxPyEndAllowThreads(__tstate);
2701 if (PyErr_Occurred()) SWIG_fail;
2702 }
2703 {
2704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2705 }
2706 return resultobj;
2707 fail:
2708 return NULL;
2709 }
2710
2711
2712 static PyObject *_wrap_Colour___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
2713 PyObject *resultobj;
2714 wxColour *arg1 = (wxColour *) 0 ;
2715 wxColour *arg2 = 0 ;
2716 bool result;
2717 wxColour temp2 ;
2718 PyObject * obj0 = 0 ;
2719 PyObject * obj1 = 0 ;
2720 char *kwnames[] = {
2721 (char *) "self",(char *) "colour", NULL
2722 };
2723
2724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___ne__",kwnames,&obj0,&obj1)) goto fail;
2725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2726 if (SWIG_arg_fail(1)) SWIG_fail;
2727 {
2728 arg2 = &temp2;
2729 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2730 }
2731 {
2732 PyThreadState* __tstate = wxPyBeginAllowThreads();
2733 result = (bool)((wxColour const *)arg1)->operator !=((wxColour const &)*arg2);
2734
2735 wxPyEndAllowThreads(__tstate);
2736 if (PyErr_Occurred()) SWIG_fail;
2737 }
2738 {
2739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2740 }
2741 return resultobj;
2742 fail:
2743 return NULL;
2744 }
2745
2746
2747 static PyObject *_wrap_Colour_Get(PyObject *, PyObject *args, PyObject *kwargs) {
2748 PyObject *resultobj;
2749 wxColour *arg1 = (wxColour *) 0 ;
2750 PyObject *result;
2751 PyObject * obj0 = 0 ;
2752 char *kwnames[] = {
2753 (char *) "self", NULL
2754 };
2755
2756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Get",kwnames,&obj0)) goto fail;
2757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2758 if (SWIG_arg_fail(1)) SWIG_fail;
2759 {
2760 PyThreadState* __tstate = wxPyBeginAllowThreads();
2761 result = (PyObject *)wxColour_Get(arg1);
2762
2763 wxPyEndAllowThreads(__tstate);
2764 if (PyErr_Occurred()) SWIG_fail;
2765 }
2766 resultobj = result;
2767 return resultobj;
2768 fail:
2769 return NULL;
2770 }
2771
2772
2773 static PyObject *_wrap_Colour_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2774 PyObject *resultobj;
2775 wxColour *arg1 = (wxColour *) 0 ;
2776 unsigned long result;
2777 PyObject * obj0 = 0 ;
2778 char *kwnames[] = {
2779 (char *) "self", NULL
2780 };
2781
2782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetRGB",kwnames,&obj0)) goto fail;
2783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2784 if (SWIG_arg_fail(1)) SWIG_fail;
2785 {
2786 PyThreadState* __tstate = wxPyBeginAllowThreads();
2787 result = (unsigned long)wxColour_GetRGB(arg1);
2788
2789 wxPyEndAllowThreads(__tstate);
2790 if (PyErr_Occurred()) SWIG_fail;
2791 }
2792 {
2793 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
2794 }
2795 return resultobj;
2796 fail:
2797 return NULL;
2798 }
2799
2800
2801 static PyObject * Colour_swigregister(PyObject *, PyObject *args) {
2802 PyObject *obj;
2803 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2804 SWIG_TypeClientData(SWIGTYPE_p_wxColour, obj);
2805 Py_INCREF(obj);
2806 return Py_BuildValue((char *)"");
2807 }
2808 static PyObject *_wrap_new_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2809 PyObject *resultobj;
2810 int arg1 ;
2811 unsigned char *arg2 = (unsigned char *) 0 ;
2812 unsigned char *arg3 = (unsigned char *) 0 ;
2813 unsigned char *arg4 = (unsigned char *) 0 ;
2814 wxPalette *result;
2815 PyObject * obj0 = 0 ;
2816 PyObject * obj1 = 0 ;
2817 PyObject * obj2 = 0 ;
2818 PyObject * obj3 = 0 ;
2819 char *kwnames[] = {
2820 (char *) "n",(char *) "red",(char *) "green",(char *) "blue", NULL
2821 };
2822
2823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_Palette",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2824 {
2825 arg1 = (int)(SWIG_As_int(obj0));
2826 if (SWIG_arg_fail(1)) SWIG_fail;
2827 }
2828 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2829 if (SWIG_arg_fail(2)) SWIG_fail;
2830 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2831 if (SWIG_arg_fail(3)) SWIG_fail;
2832 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2833 if (SWIG_arg_fail(4)) SWIG_fail;
2834 {
2835 if (!wxPyCheckForApp()) SWIG_fail;
2836 PyThreadState* __tstate = wxPyBeginAllowThreads();
2837 result = (wxPalette *)new wxPalette(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
2838
2839 wxPyEndAllowThreads(__tstate);
2840 if (PyErr_Occurred()) SWIG_fail;
2841 }
2842 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 1);
2843 return resultobj;
2844 fail:
2845 return NULL;
2846 }
2847
2848
2849 static PyObject *_wrap_delete_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2850 PyObject *resultobj;
2851 wxPalette *arg1 = (wxPalette *) 0 ;
2852 PyObject * obj0 = 0 ;
2853 char *kwnames[] = {
2854 (char *) "self", NULL
2855 };
2856
2857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Palette",kwnames,&obj0)) goto fail;
2858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2859 if (SWIG_arg_fail(1)) SWIG_fail;
2860 {
2861 PyThreadState* __tstate = wxPyBeginAllowThreads();
2862 delete arg1;
2863
2864 wxPyEndAllowThreads(__tstate);
2865 if (PyErr_Occurred()) SWIG_fail;
2866 }
2867 Py_INCREF(Py_None); resultobj = Py_None;
2868 return resultobj;
2869 fail:
2870 return NULL;
2871 }
2872
2873
2874 static PyObject *_wrap_Palette_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2875 PyObject *resultobj;
2876 wxPalette *arg1 = (wxPalette *) 0 ;
2877 byte arg2 ;
2878 byte arg3 ;
2879 byte arg4 ;
2880 int result;
2881 PyObject * obj0 = 0 ;
2882 PyObject * obj1 = 0 ;
2883 PyObject * obj2 = 0 ;
2884 PyObject * obj3 = 0 ;
2885 char *kwnames[] = {
2886 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2887 };
2888
2889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Palette_GetPixel",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2891 if (SWIG_arg_fail(1)) SWIG_fail;
2892 {
2893 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2894 if (SWIG_arg_fail(2)) SWIG_fail;
2895 }
2896 {
2897 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2898 if (SWIG_arg_fail(3)) SWIG_fail;
2899 }
2900 {
2901 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2902 if (SWIG_arg_fail(4)) SWIG_fail;
2903 }
2904 {
2905 PyThreadState* __tstate = wxPyBeginAllowThreads();
2906 result = (int)(arg1)->GetPixel(arg2,arg3,arg4);
2907
2908 wxPyEndAllowThreads(__tstate);
2909 if (PyErr_Occurred()) SWIG_fail;
2910 }
2911 {
2912 resultobj = SWIG_From_int((int)(result));
2913 }
2914 return resultobj;
2915 fail:
2916 return NULL;
2917 }
2918
2919
2920 static PyObject *_wrap_Palette_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2921 PyObject *resultobj;
2922 wxPalette *arg1 = (wxPalette *) 0 ;
2923 int arg2 ;
2924 byte *arg3 = (byte *) 0 ;
2925 byte *arg4 = (byte *) 0 ;
2926 byte *arg5 = (byte *) 0 ;
2927 bool result;
2928 byte temp3 ;
2929 int res3 = 0 ;
2930 byte temp4 ;
2931 int res4 = 0 ;
2932 byte temp5 ;
2933 int res5 = 0 ;
2934 PyObject * obj0 = 0 ;
2935 PyObject * obj1 = 0 ;
2936 char *kwnames[] = {
2937 (char *) "self",(char *) "pixel", NULL
2938 };
2939
2940 arg3 = &temp3; res3 = SWIG_NEWOBJ;
2941 arg4 = &temp4; res4 = SWIG_NEWOBJ;
2942 arg5 = &temp5; res5 = SWIG_NEWOBJ;
2943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Palette_GetRGB",kwnames,&obj0,&obj1)) goto fail;
2944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2945 if (SWIG_arg_fail(1)) SWIG_fail;
2946 {
2947 arg2 = (int)(SWIG_As_int(obj1));
2948 if (SWIG_arg_fail(2)) SWIG_fail;
2949 }
2950 {
2951 PyThreadState* __tstate = wxPyBeginAllowThreads();
2952 result = (bool)(arg1)->GetRGB(arg2,arg3,arg4,arg5);
2953
2954 wxPyEndAllowThreads(__tstate);
2955 if (PyErr_Occurred()) SWIG_fail;
2956 }
2957 {
2958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2959 }
2960 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
2961 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
2962 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
2963 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
2964 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
2965 SWIG_From_unsigned_SS_char((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_unsigned_char, 0)));
2966 return resultobj;
2967 fail:
2968 return NULL;
2969 }
2970
2971
2972 static PyObject *_wrap_Palette_GetColoursCount(PyObject *, PyObject *args, PyObject *kwargs) {
2973 PyObject *resultobj;
2974 wxPalette *arg1 = (wxPalette *) 0 ;
2975 int result;
2976 PyObject * obj0 = 0 ;
2977 char *kwnames[] = {
2978 (char *) "self", NULL
2979 };
2980
2981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_GetColoursCount",kwnames,&obj0)) goto fail;
2982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2983 if (SWIG_arg_fail(1)) SWIG_fail;
2984 {
2985 PyThreadState* __tstate = wxPyBeginAllowThreads();
2986 result = (int)((wxPalette const *)arg1)->GetColoursCount();
2987
2988 wxPyEndAllowThreads(__tstate);
2989 if (PyErr_Occurred()) SWIG_fail;
2990 }
2991 {
2992 resultobj = SWIG_From_int((int)(result));
2993 }
2994 return resultobj;
2995 fail:
2996 return NULL;
2997 }
2998
2999
3000 static PyObject *_wrap_Palette_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3001 PyObject *resultobj;
3002 wxPalette *arg1 = (wxPalette *) 0 ;
3003 bool result;
3004 PyObject * obj0 = 0 ;
3005 char *kwnames[] = {
3006 (char *) "self", NULL
3007 };
3008
3009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_Ok",kwnames,&obj0)) goto fail;
3010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
3011 if (SWIG_arg_fail(1)) SWIG_fail;
3012 {
3013 PyThreadState* __tstate = wxPyBeginAllowThreads();
3014 result = (bool)(arg1)->Ok();
3015
3016 wxPyEndAllowThreads(__tstate);
3017 if (PyErr_Occurred()) SWIG_fail;
3018 }
3019 {
3020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3021 }
3022 return resultobj;
3023 fail:
3024 return NULL;
3025 }
3026
3027
3028 static PyObject * Palette_swigregister(PyObject *, PyObject *args) {
3029 PyObject *obj;
3030 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3031 SWIG_TypeClientData(SWIGTYPE_p_wxPalette, obj);
3032 Py_INCREF(obj);
3033 return Py_BuildValue((char *)"");
3034 }
3035 static PyObject *_wrap_new_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3036 PyObject *resultobj;
3037 wxColour *arg1 = 0 ;
3038 int arg2 = (int) 1 ;
3039 int arg3 = (int) wxSOLID ;
3040 wxPen *result;
3041 wxColour temp1 ;
3042 PyObject * obj0 = 0 ;
3043 PyObject * obj1 = 0 ;
3044 PyObject * obj2 = 0 ;
3045 char *kwnames[] = {
3046 (char *) "colour",(char *) "width",(char *) "style", NULL
3047 };
3048
3049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Pen",kwnames,&obj0,&obj1,&obj2)) goto fail;
3050 {
3051 arg1 = &temp1;
3052 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3053 }
3054 if (obj1) {
3055 {
3056 arg2 = (int)(SWIG_As_int(obj1));
3057 if (SWIG_arg_fail(2)) SWIG_fail;
3058 }
3059 }
3060 if (obj2) {
3061 {
3062 arg3 = (int)(SWIG_As_int(obj2));
3063 if (SWIG_arg_fail(3)) SWIG_fail;
3064 }
3065 }
3066 {
3067 if (!wxPyCheckForApp()) SWIG_fail;
3068 PyThreadState* __tstate = wxPyBeginAllowThreads();
3069 result = (wxPen *)new wxPen(*arg1,arg2,arg3);
3070
3071 wxPyEndAllowThreads(__tstate);
3072 if (PyErr_Occurred()) SWIG_fail;
3073 }
3074 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 1);
3075 return resultobj;
3076 fail:
3077 return NULL;
3078 }
3079
3080
3081 static PyObject *_wrap_delete_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3082 PyObject *resultobj;
3083 wxPen *arg1 = (wxPen *) 0 ;
3084 PyObject * obj0 = 0 ;
3085 char *kwnames[] = {
3086 (char *) "self", NULL
3087 };
3088
3089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Pen",kwnames,&obj0)) goto fail;
3090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3091 if (SWIG_arg_fail(1)) SWIG_fail;
3092 {
3093 PyThreadState* __tstate = wxPyBeginAllowThreads();
3094 delete arg1;
3095
3096 wxPyEndAllowThreads(__tstate);
3097 if (PyErr_Occurred()) SWIG_fail;
3098 }
3099 Py_INCREF(Py_None); resultobj = Py_None;
3100 return resultobj;
3101 fail:
3102 return NULL;
3103 }
3104
3105
3106 static PyObject *_wrap_Pen_GetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3107 PyObject *resultobj;
3108 wxPen *arg1 = (wxPen *) 0 ;
3109 int result;
3110 PyObject * obj0 = 0 ;
3111 char *kwnames[] = {
3112 (char *) "self", NULL
3113 };
3114
3115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetCap",kwnames,&obj0)) goto fail;
3116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3117 if (SWIG_arg_fail(1)) SWIG_fail;
3118 {
3119 PyThreadState* __tstate = wxPyBeginAllowThreads();
3120 result = (int)(arg1)->GetCap();
3121
3122 wxPyEndAllowThreads(__tstate);
3123 if (PyErr_Occurred()) SWIG_fail;
3124 }
3125 {
3126 resultobj = SWIG_From_int((int)(result));
3127 }
3128 return resultobj;
3129 fail:
3130 return NULL;
3131 }
3132
3133
3134 static PyObject *_wrap_Pen_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3135 PyObject *resultobj;
3136 wxPen *arg1 = (wxPen *) 0 ;
3137 wxColour result;
3138 PyObject * obj0 = 0 ;
3139 char *kwnames[] = {
3140 (char *) "self", NULL
3141 };
3142
3143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetColour",kwnames,&obj0)) goto fail;
3144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3145 if (SWIG_arg_fail(1)) SWIG_fail;
3146 {
3147 PyThreadState* __tstate = wxPyBeginAllowThreads();
3148 result = (arg1)->GetColour();
3149
3150 wxPyEndAllowThreads(__tstate);
3151 if (PyErr_Occurred()) SWIG_fail;
3152 }
3153 {
3154 wxColour * resultptr;
3155 resultptr = new wxColour((wxColour &)(result));
3156 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3157 }
3158 return resultobj;
3159 fail:
3160 return NULL;
3161 }
3162
3163
3164 static PyObject *_wrap_Pen_GetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3165 PyObject *resultobj;
3166 wxPen *arg1 = (wxPen *) 0 ;
3167 int result;
3168 PyObject * obj0 = 0 ;
3169 char *kwnames[] = {
3170 (char *) "self", NULL
3171 };
3172
3173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetJoin",kwnames,&obj0)) goto fail;
3174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3175 if (SWIG_arg_fail(1)) SWIG_fail;
3176 {
3177 PyThreadState* __tstate = wxPyBeginAllowThreads();
3178 result = (int)(arg1)->GetJoin();
3179
3180 wxPyEndAllowThreads(__tstate);
3181 if (PyErr_Occurred()) SWIG_fail;
3182 }
3183 {
3184 resultobj = SWIG_From_int((int)(result));
3185 }
3186 return resultobj;
3187 fail:
3188 return NULL;
3189 }
3190
3191
3192 static PyObject *_wrap_Pen_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3193 PyObject *resultobj;
3194 wxPen *arg1 = (wxPen *) 0 ;
3195 int result;
3196 PyObject * obj0 = 0 ;
3197 char *kwnames[] = {
3198 (char *) "self", NULL
3199 };
3200
3201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetStyle",kwnames,&obj0)) goto fail;
3202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3203 if (SWIG_arg_fail(1)) SWIG_fail;
3204 {
3205 PyThreadState* __tstate = wxPyBeginAllowThreads();
3206 result = (int)(arg1)->GetStyle();
3207
3208 wxPyEndAllowThreads(__tstate);
3209 if (PyErr_Occurred()) SWIG_fail;
3210 }
3211 {
3212 resultobj = SWIG_From_int((int)(result));
3213 }
3214 return resultobj;
3215 fail:
3216 return NULL;
3217 }
3218
3219
3220 static PyObject *_wrap_Pen_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3221 PyObject *resultobj;
3222 wxPen *arg1 = (wxPen *) 0 ;
3223 int result;
3224 PyObject * obj0 = 0 ;
3225 char *kwnames[] = {
3226 (char *) "self", NULL
3227 };
3228
3229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetWidth",kwnames,&obj0)) goto fail;
3230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3231 if (SWIG_arg_fail(1)) SWIG_fail;
3232 {
3233 PyThreadState* __tstate = wxPyBeginAllowThreads();
3234 result = (int)(arg1)->GetWidth();
3235
3236 wxPyEndAllowThreads(__tstate);
3237 if (PyErr_Occurred()) SWIG_fail;
3238 }
3239 {
3240 resultobj = SWIG_From_int((int)(result));
3241 }
3242 return resultobj;
3243 fail:
3244 return NULL;
3245 }
3246
3247
3248 static PyObject *_wrap_Pen_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3249 PyObject *resultobj;
3250 wxPen *arg1 = (wxPen *) 0 ;
3251 bool result;
3252 PyObject * obj0 = 0 ;
3253 char *kwnames[] = {
3254 (char *) "self", NULL
3255 };
3256
3257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_Ok",kwnames,&obj0)) goto fail;
3258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3259 if (SWIG_arg_fail(1)) SWIG_fail;
3260 {
3261 PyThreadState* __tstate = wxPyBeginAllowThreads();
3262 result = (bool)(arg1)->Ok();
3263
3264 wxPyEndAllowThreads(__tstate);
3265 if (PyErr_Occurred()) SWIG_fail;
3266 }
3267 {
3268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3269 }
3270 return resultobj;
3271 fail:
3272 return NULL;
3273 }
3274
3275
3276 static PyObject *_wrap_Pen_SetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3277 PyObject *resultobj;
3278 wxPen *arg1 = (wxPen *) 0 ;
3279 int arg2 ;
3280 PyObject * obj0 = 0 ;
3281 PyObject * obj1 = 0 ;
3282 char *kwnames[] = {
3283 (char *) "self",(char *) "cap_style", NULL
3284 };
3285
3286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetCap",kwnames,&obj0,&obj1)) 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 arg2 = (int)(SWIG_As_int(obj1));
3291 if (SWIG_arg_fail(2)) SWIG_fail;
3292 }
3293 {
3294 PyThreadState* __tstate = wxPyBeginAllowThreads();
3295 (arg1)->SetCap(arg2);
3296
3297 wxPyEndAllowThreads(__tstate);
3298 if (PyErr_Occurred()) SWIG_fail;
3299 }
3300 Py_INCREF(Py_None); resultobj = Py_None;
3301 return resultobj;
3302 fail:
3303 return NULL;
3304 }
3305
3306
3307 static PyObject *_wrap_Pen_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3308 PyObject *resultobj;
3309 wxPen *arg1 = (wxPen *) 0 ;
3310 wxColour *arg2 = 0 ;
3311 wxColour temp2 ;
3312 PyObject * obj0 = 0 ;
3313 PyObject * obj1 = 0 ;
3314 char *kwnames[] = {
3315 (char *) "self",(char *) "colour", NULL
3316 };
3317
3318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetColour",kwnames,&obj0,&obj1)) goto fail;
3319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3320 if (SWIG_arg_fail(1)) SWIG_fail;
3321 {
3322 arg2 = &temp2;
3323 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3324 }
3325 {
3326 PyThreadState* __tstate = wxPyBeginAllowThreads();
3327 (arg1)->SetColour(*arg2);
3328
3329 wxPyEndAllowThreads(__tstate);
3330 if (PyErr_Occurred()) SWIG_fail;
3331 }
3332 Py_INCREF(Py_None); resultobj = Py_None;
3333 return resultobj;
3334 fail:
3335 return NULL;
3336 }
3337
3338
3339 static PyObject *_wrap_Pen_SetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3340 PyObject *resultobj;
3341 wxPen *arg1 = (wxPen *) 0 ;
3342 int arg2 ;
3343 PyObject * obj0 = 0 ;
3344 PyObject * obj1 = 0 ;
3345 char *kwnames[] = {
3346 (char *) "self",(char *) "join_style", NULL
3347 };
3348
3349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetJoin",kwnames,&obj0,&obj1)) goto fail;
3350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3351 if (SWIG_arg_fail(1)) SWIG_fail;
3352 {
3353 arg2 = (int)(SWIG_As_int(obj1));
3354 if (SWIG_arg_fail(2)) SWIG_fail;
3355 }
3356 {
3357 PyThreadState* __tstate = wxPyBeginAllowThreads();
3358 (arg1)->SetJoin(arg2);
3359
3360 wxPyEndAllowThreads(__tstate);
3361 if (PyErr_Occurred()) SWIG_fail;
3362 }
3363 Py_INCREF(Py_None); resultobj = Py_None;
3364 return resultobj;
3365 fail:
3366 return NULL;
3367 }
3368
3369
3370 static PyObject *_wrap_Pen_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3371 PyObject *resultobj;
3372 wxPen *arg1 = (wxPen *) 0 ;
3373 int arg2 ;
3374 PyObject * obj0 = 0 ;
3375 PyObject * obj1 = 0 ;
3376 char *kwnames[] = {
3377 (char *) "self",(char *) "style", NULL
3378 };
3379
3380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3382 if (SWIG_arg_fail(1)) SWIG_fail;
3383 {
3384 arg2 = (int)(SWIG_As_int(obj1));
3385 if (SWIG_arg_fail(2)) SWIG_fail;
3386 }
3387 {
3388 PyThreadState* __tstate = wxPyBeginAllowThreads();
3389 (arg1)->SetStyle(arg2);
3390
3391 wxPyEndAllowThreads(__tstate);
3392 if (PyErr_Occurred()) SWIG_fail;
3393 }
3394 Py_INCREF(Py_None); resultobj = Py_None;
3395 return resultobj;
3396 fail:
3397 return NULL;
3398 }
3399
3400
3401 static PyObject *_wrap_Pen_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3402 PyObject *resultobj;
3403 wxPen *arg1 = (wxPen *) 0 ;
3404 int arg2 ;
3405 PyObject * obj0 = 0 ;
3406 PyObject * obj1 = 0 ;
3407 char *kwnames[] = {
3408 (char *) "self",(char *) "width", NULL
3409 };
3410
3411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3413 if (SWIG_arg_fail(1)) SWIG_fail;
3414 {
3415 arg2 = (int)(SWIG_As_int(obj1));
3416 if (SWIG_arg_fail(2)) SWIG_fail;
3417 }
3418 {
3419 PyThreadState* __tstate = wxPyBeginAllowThreads();
3420 (arg1)->SetWidth(arg2);
3421
3422 wxPyEndAllowThreads(__tstate);
3423 if (PyErr_Occurred()) SWIG_fail;
3424 }
3425 Py_INCREF(Py_None); resultobj = Py_None;
3426 return resultobj;
3427 fail:
3428 return NULL;
3429 }
3430
3431
3432 static PyObject *_wrap_Pen_SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3433 PyObject *resultobj;
3434 wxPen *arg1 = (wxPen *) 0 ;
3435 int arg2 ;
3436 wxDash *arg3 = (wxDash *) 0 ;
3437 PyObject * obj0 = 0 ;
3438 PyObject * obj1 = 0 ;
3439 char *kwnames[] = {
3440 (char *) "self",(char *) "dashes", NULL
3441 };
3442
3443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetDashes",kwnames,&obj0,&obj1)) goto fail;
3444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3445 if (SWIG_arg_fail(1)) SWIG_fail;
3446 {
3447 arg2 = PyList_Size(obj1);
3448 arg3 = (wxDash*)byte_LIST_helper(obj1);
3449 if (arg3 == NULL) SWIG_fail;
3450 }
3451 {
3452 PyThreadState* __tstate = wxPyBeginAllowThreads();
3453 (arg1)->SetDashes(arg2,arg3);
3454
3455 wxPyEndAllowThreads(__tstate);
3456 if (PyErr_Occurred()) SWIG_fail;
3457 }
3458 Py_INCREF(Py_None); resultobj = Py_None;
3459 {
3460 if (arg3) delete [] arg3;
3461 }
3462 return resultobj;
3463 fail:
3464 {
3465 if (arg3) delete [] arg3;
3466 }
3467 return NULL;
3468 }
3469
3470
3471 static PyObject *_wrap_Pen_GetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3472 PyObject *resultobj;
3473 wxPen *arg1 = (wxPen *) 0 ;
3474 PyObject *result;
3475 PyObject * obj0 = 0 ;
3476 char *kwnames[] = {
3477 (char *) "self", NULL
3478 };
3479
3480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetDashes",kwnames,&obj0)) goto fail;
3481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3482 if (SWIG_arg_fail(1)) SWIG_fail;
3483 {
3484 PyThreadState* __tstate = wxPyBeginAllowThreads();
3485 result = (PyObject *)wxPen_GetDashes(arg1);
3486
3487 wxPyEndAllowThreads(__tstate);
3488 if (PyErr_Occurred()) SWIG_fail;
3489 }
3490 resultobj = result;
3491 return resultobj;
3492 fail:
3493 return NULL;
3494 }
3495
3496
3497 static PyObject *_wrap_Pen__SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3498 PyObject *resultobj;
3499 wxPen *arg1 = (wxPen *) 0 ;
3500 PyObject *arg2 = (PyObject *) 0 ;
3501 PyObject *arg3 = (PyObject *) 0 ;
3502 PyObject * obj0 = 0 ;
3503 PyObject * obj1 = 0 ;
3504 PyObject * obj2 = 0 ;
3505 char *kwnames[] = {
3506 (char *) "self",(char *) "_self",(char *) "pyDashes", NULL
3507 };
3508
3509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Pen__SetDashes",kwnames,&obj0,&obj1,&obj2)) 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 arg2 = obj1;
3513 arg3 = obj2;
3514 {
3515 PyThreadState* __tstate = wxPyBeginAllowThreads();
3516 wxPen__SetDashes(arg1,arg2,arg3);
3517
3518 wxPyEndAllowThreads(__tstate);
3519 if (PyErr_Occurred()) SWIG_fail;
3520 }
3521 Py_INCREF(Py_None); resultobj = Py_None;
3522 return resultobj;
3523 fail:
3524 return NULL;
3525 }
3526
3527
3528 static PyObject *_wrap_Pen_GetDashCount(PyObject *, PyObject *args, PyObject *kwargs) {
3529 PyObject *resultobj;
3530 wxPen *arg1 = (wxPen *) 0 ;
3531 int result;
3532 PyObject * obj0 = 0 ;
3533 char *kwnames[] = {
3534 (char *) "self", NULL
3535 };
3536
3537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetDashCount",kwnames,&obj0)) goto fail;
3538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3539 if (SWIG_arg_fail(1)) SWIG_fail;
3540 {
3541 PyThreadState* __tstate = wxPyBeginAllowThreads();
3542 result = (int)((wxPen const *)arg1)->GetDashCount();
3543
3544 wxPyEndAllowThreads(__tstate);
3545 if (PyErr_Occurred()) SWIG_fail;
3546 }
3547 {
3548 resultobj = SWIG_From_int((int)(result));
3549 }
3550 return resultobj;
3551 fail:
3552 return NULL;
3553 }
3554
3555
3556 static PyObject *_wrap_Pen___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3557 PyObject *resultobj;
3558 wxPen *arg1 = (wxPen *) 0 ;
3559 wxPen *arg2 = (wxPen *) 0 ;
3560 bool result;
3561 PyObject * obj0 = 0 ;
3562 PyObject * obj1 = 0 ;
3563 char *kwnames[] = {
3564 (char *) "self",(char *) "other", NULL
3565 };
3566
3567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___eq__",kwnames,&obj0,&obj1)) goto fail;
3568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3569 if (SWIG_arg_fail(1)) SWIG_fail;
3570 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3571 if (SWIG_arg_fail(2)) SWIG_fail;
3572 {
3573 PyThreadState* __tstate = wxPyBeginAllowThreads();
3574 result = (bool)wxPen___eq__(arg1,(wxPen const *)arg2);
3575
3576 wxPyEndAllowThreads(__tstate);
3577 if (PyErr_Occurred()) SWIG_fail;
3578 }
3579 {
3580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3581 }
3582 return resultobj;
3583 fail:
3584 return NULL;
3585 }
3586
3587
3588 static PyObject *_wrap_Pen___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3589 PyObject *resultobj;
3590 wxPen *arg1 = (wxPen *) 0 ;
3591 wxPen *arg2 = (wxPen *) 0 ;
3592 bool result;
3593 PyObject * obj0 = 0 ;
3594 PyObject * obj1 = 0 ;
3595 char *kwnames[] = {
3596 (char *) "self",(char *) "other", NULL
3597 };
3598
3599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___ne__",kwnames,&obj0,&obj1)) goto fail;
3600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3601 if (SWIG_arg_fail(1)) SWIG_fail;
3602 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3603 if (SWIG_arg_fail(2)) SWIG_fail;
3604 {
3605 PyThreadState* __tstate = wxPyBeginAllowThreads();
3606 result = (bool)wxPen___ne__(arg1,(wxPen const *)arg2);
3607
3608 wxPyEndAllowThreads(__tstate);
3609 if (PyErr_Occurred()) SWIG_fail;
3610 }
3611 {
3612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3613 }
3614 return resultobj;
3615 fail:
3616 return NULL;
3617 }
3618
3619
3620 static PyObject * Pen_swigregister(PyObject *, PyObject *args) {
3621 PyObject *obj;
3622 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3623 SWIG_TypeClientData(SWIGTYPE_p_wxPen, obj);
3624 Py_INCREF(obj);
3625 return Py_BuildValue((char *)"");
3626 }
3627 static PyObject *_wrap_new_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3628 PyObject *resultobj;
3629 wxColour *arg1 = 0 ;
3630 int arg2 = (int) wxSOLID ;
3631 wxBrush *result;
3632 wxColour temp1 ;
3633 PyObject * obj0 = 0 ;
3634 PyObject * obj1 = 0 ;
3635 char *kwnames[] = {
3636 (char *) "colour",(char *) "style", NULL
3637 };
3638
3639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Brush",kwnames,&obj0,&obj1)) goto fail;
3640 {
3641 arg1 = &temp1;
3642 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3643 }
3644 if (obj1) {
3645 {
3646 arg2 = (int)(SWIG_As_int(obj1));
3647 if (SWIG_arg_fail(2)) SWIG_fail;
3648 }
3649 }
3650 {
3651 if (!wxPyCheckForApp()) SWIG_fail;
3652 PyThreadState* __tstate = wxPyBeginAllowThreads();
3653 result = (wxBrush *)new wxBrush((wxColour const &)*arg1,arg2);
3654
3655 wxPyEndAllowThreads(__tstate);
3656 if (PyErr_Occurred()) SWIG_fail;
3657 }
3658 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 1);
3659 return resultobj;
3660 fail:
3661 return NULL;
3662 }
3663
3664
3665 static PyObject *_wrap_delete_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3666 PyObject *resultobj;
3667 wxBrush *arg1 = (wxBrush *) 0 ;
3668 PyObject * obj0 = 0 ;
3669 char *kwnames[] = {
3670 (char *) "self", NULL
3671 };
3672
3673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Brush",kwnames,&obj0)) goto fail;
3674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3675 if (SWIG_arg_fail(1)) SWIG_fail;
3676 {
3677 PyThreadState* __tstate = wxPyBeginAllowThreads();
3678 delete arg1;
3679
3680 wxPyEndAllowThreads(__tstate);
3681 if (PyErr_Occurred()) SWIG_fail;
3682 }
3683 Py_INCREF(Py_None); resultobj = Py_None;
3684 return resultobj;
3685 fail:
3686 return NULL;
3687 }
3688
3689
3690 static PyObject *_wrap_Brush_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3691 PyObject *resultobj;
3692 wxBrush *arg1 = (wxBrush *) 0 ;
3693 wxColour *arg2 = 0 ;
3694 wxColour temp2 ;
3695 PyObject * obj0 = 0 ;
3696 PyObject * obj1 = 0 ;
3697 char *kwnames[] = {
3698 (char *) "self",(char *) "col", NULL
3699 };
3700
3701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetColour",kwnames,&obj0,&obj1)) goto fail;
3702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3703 if (SWIG_arg_fail(1)) SWIG_fail;
3704 {
3705 arg2 = &temp2;
3706 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3707 }
3708 {
3709 PyThreadState* __tstate = wxPyBeginAllowThreads();
3710 (arg1)->SetColour((wxColour const &)*arg2);
3711
3712 wxPyEndAllowThreads(__tstate);
3713 if (PyErr_Occurred()) SWIG_fail;
3714 }
3715 Py_INCREF(Py_None); resultobj = Py_None;
3716 return resultobj;
3717 fail:
3718 return NULL;
3719 }
3720
3721
3722 static PyObject *_wrap_Brush_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3723 PyObject *resultobj;
3724 wxBrush *arg1 = (wxBrush *) 0 ;
3725 int arg2 ;
3726 PyObject * obj0 = 0 ;
3727 PyObject * obj1 = 0 ;
3728 char *kwnames[] = {
3729 (char *) "self",(char *) "style", NULL
3730 };
3731
3732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3734 if (SWIG_arg_fail(1)) SWIG_fail;
3735 {
3736 arg2 = (int)(SWIG_As_int(obj1));
3737 if (SWIG_arg_fail(2)) SWIG_fail;
3738 }
3739 {
3740 PyThreadState* __tstate = wxPyBeginAllowThreads();
3741 (arg1)->SetStyle(arg2);
3742
3743 wxPyEndAllowThreads(__tstate);
3744 if (PyErr_Occurred()) SWIG_fail;
3745 }
3746 Py_INCREF(Py_None); resultobj = Py_None;
3747 return resultobj;
3748 fail:
3749 return NULL;
3750 }
3751
3752
3753 static PyObject *_wrap_Brush_SetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3754 PyObject *resultobj;
3755 wxBrush *arg1 = (wxBrush *) 0 ;
3756 wxBitmap *arg2 = 0 ;
3757 PyObject * obj0 = 0 ;
3758 PyObject * obj1 = 0 ;
3759 char *kwnames[] = {
3760 (char *) "self",(char *) "stipple", NULL
3761 };
3762
3763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStipple",kwnames,&obj0,&obj1)) goto fail;
3764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3765 if (SWIG_arg_fail(1)) SWIG_fail;
3766 {
3767 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3768 if (SWIG_arg_fail(2)) SWIG_fail;
3769 if (arg2 == NULL) {
3770 SWIG_null_ref("wxBitmap");
3771 }
3772 if (SWIG_arg_fail(2)) SWIG_fail;
3773 }
3774 {
3775 PyThreadState* __tstate = wxPyBeginAllowThreads();
3776 (arg1)->SetStipple((wxBitmap const &)*arg2);
3777
3778 wxPyEndAllowThreads(__tstate);
3779 if (PyErr_Occurred()) SWIG_fail;
3780 }
3781 Py_INCREF(Py_None); resultobj = Py_None;
3782 return resultobj;
3783 fail:
3784 return NULL;
3785 }
3786
3787
3788 static PyObject *_wrap_Brush_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3789 PyObject *resultobj;
3790 wxBrush *arg1 = (wxBrush *) 0 ;
3791 wxColour result;
3792 PyObject * obj0 = 0 ;
3793 char *kwnames[] = {
3794 (char *) "self", NULL
3795 };
3796
3797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetColour",kwnames,&obj0)) goto fail;
3798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3799 if (SWIG_arg_fail(1)) SWIG_fail;
3800 {
3801 PyThreadState* __tstate = wxPyBeginAllowThreads();
3802 result = ((wxBrush const *)arg1)->GetColour();
3803
3804 wxPyEndAllowThreads(__tstate);
3805 if (PyErr_Occurred()) SWIG_fail;
3806 }
3807 {
3808 wxColour * resultptr;
3809 resultptr = new wxColour((wxColour &)(result));
3810 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3811 }
3812 return resultobj;
3813 fail:
3814 return NULL;
3815 }
3816
3817
3818 static PyObject *_wrap_Brush_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3819 PyObject *resultobj;
3820 wxBrush *arg1 = (wxBrush *) 0 ;
3821 int result;
3822 PyObject * obj0 = 0 ;
3823 char *kwnames[] = {
3824 (char *) "self", NULL
3825 };
3826
3827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStyle",kwnames,&obj0)) goto fail;
3828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3829 if (SWIG_arg_fail(1)) SWIG_fail;
3830 {
3831 PyThreadState* __tstate = wxPyBeginAllowThreads();
3832 result = (int)((wxBrush const *)arg1)->GetStyle();
3833
3834 wxPyEndAllowThreads(__tstate);
3835 if (PyErr_Occurred()) SWIG_fail;
3836 }
3837 {
3838 resultobj = SWIG_From_int((int)(result));
3839 }
3840 return resultobj;
3841 fail:
3842 return NULL;
3843 }
3844
3845
3846 static PyObject *_wrap_Brush_GetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3847 PyObject *resultobj;
3848 wxBrush *arg1 = (wxBrush *) 0 ;
3849 wxBitmap *result;
3850 PyObject * obj0 = 0 ;
3851 char *kwnames[] = {
3852 (char *) "self", NULL
3853 };
3854
3855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStipple",kwnames,&obj0)) goto fail;
3856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3857 if (SWIG_arg_fail(1)) SWIG_fail;
3858 {
3859 PyThreadState* __tstate = wxPyBeginAllowThreads();
3860 result = (wxBitmap *)((wxBrush const *)arg1)->GetStipple();
3861
3862 wxPyEndAllowThreads(__tstate);
3863 if (PyErr_Occurred()) SWIG_fail;
3864 }
3865 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 0);
3866 return resultobj;
3867 fail:
3868 return NULL;
3869 }
3870
3871
3872 static PyObject *_wrap_Brush_IsHatch(PyObject *, PyObject *args, PyObject *kwargs) {
3873 PyObject *resultobj;
3874 wxBrush *arg1 = (wxBrush *) 0 ;
3875 bool result;
3876 PyObject * obj0 = 0 ;
3877 char *kwnames[] = {
3878 (char *) "self", NULL
3879 };
3880
3881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_IsHatch",kwnames,&obj0)) goto fail;
3882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3883 if (SWIG_arg_fail(1)) SWIG_fail;
3884 {
3885 PyThreadState* __tstate = wxPyBeginAllowThreads();
3886 result = (bool)((wxBrush const *)arg1)->IsHatch();
3887
3888 wxPyEndAllowThreads(__tstate);
3889 if (PyErr_Occurred()) SWIG_fail;
3890 }
3891 {
3892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3893 }
3894 return resultobj;
3895 fail:
3896 return NULL;
3897 }
3898
3899
3900 static PyObject *_wrap_Brush_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3901 PyObject *resultobj;
3902 wxBrush *arg1 = (wxBrush *) 0 ;
3903 bool result;
3904 PyObject * obj0 = 0 ;
3905 char *kwnames[] = {
3906 (char *) "self", NULL
3907 };
3908
3909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_Ok",kwnames,&obj0)) goto fail;
3910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3911 if (SWIG_arg_fail(1)) SWIG_fail;
3912 {
3913 PyThreadState* __tstate = wxPyBeginAllowThreads();
3914 result = (bool)(arg1)->Ok();
3915
3916 wxPyEndAllowThreads(__tstate);
3917 if (PyErr_Occurred()) SWIG_fail;
3918 }
3919 {
3920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3921 }
3922 return resultobj;
3923 fail:
3924 return NULL;
3925 }
3926
3927
3928 static PyObject * Brush_swigregister(PyObject *, PyObject *args) {
3929 PyObject *obj;
3930 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3931 SWIG_TypeClientData(SWIGTYPE_p_wxBrush, obj);
3932 Py_INCREF(obj);
3933 return Py_BuildValue((char *)"");
3934 }
3935 static PyObject *_wrap_new_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
3936 PyObject *resultobj;
3937 wxString *arg1 = 0 ;
3938 wxBitmapType arg2 = (wxBitmapType) wxBITMAP_TYPE_ANY ;
3939 wxBitmap *result;
3940 bool temp1 = false ;
3941 PyObject * obj0 = 0 ;
3942 PyObject * obj1 = 0 ;
3943 char *kwnames[] = {
3944 (char *) "name",(char *) "type", NULL
3945 };
3946
3947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Bitmap",kwnames,&obj0,&obj1)) goto fail;
3948 {
3949 arg1 = wxString_in_helper(obj0);
3950 if (arg1 == NULL) SWIG_fail;
3951 temp1 = true;
3952 }
3953 if (obj1) {
3954 {
3955 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
3956 if (SWIG_arg_fail(2)) SWIG_fail;
3957 }
3958 }
3959 {
3960 if (!wxPyCheckForApp()) SWIG_fail;
3961 PyThreadState* __tstate = wxPyBeginAllowThreads();
3962 result = (wxBitmap *)new wxBitmap((wxString const &)*arg1,(wxBitmapType )arg2);
3963
3964 wxPyEndAllowThreads(__tstate);
3965 if (PyErr_Occurred()) SWIG_fail;
3966 }
3967 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
3968 {
3969 if (temp1)
3970 delete arg1;
3971 }
3972 return resultobj;
3973 fail:
3974 {
3975 if (temp1)
3976 delete arg1;
3977 }
3978 return NULL;
3979 }
3980
3981
3982 static PyObject *_wrap_delete_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
3983 PyObject *resultobj;
3984 wxBitmap *arg1 = (wxBitmap *) 0 ;
3985 PyObject * obj0 = 0 ;
3986 char *kwnames[] = {
3987 (char *) "self", NULL
3988 };
3989
3990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Bitmap",kwnames,&obj0)) goto fail;
3991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3992 if (SWIG_arg_fail(1)) SWIG_fail;
3993 {
3994 PyThreadState* __tstate = wxPyBeginAllowThreads();
3995 delete arg1;
3996
3997 wxPyEndAllowThreads(__tstate);
3998 if (PyErr_Occurred()) SWIG_fail;
3999 }
4000 Py_INCREF(Py_None); resultobj = Py_None;
4001 return resultobj;
4002 fail:
4003 return NULL;
4004 }
4005
4006
4007 static PyObject *_wrap_new_EmptyBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4008 PyObject *resultobj;
4009 int arg1 ;
4010 int arg2 ;
4011 int arg3 = (int) -1 ;
4012 wxBitmap *result;
4013 PyObject * obj0 = 0 ;
4014 PyObject * obj1 = 0 ;
4015 PyObject * obj2 = 0 ;
4016 char *kwnames[] = {
4017 (char *) "width",(char *) "height",(char *) "depth", NULL
4018 };
4019
4020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_EmptyBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
4021 {
4022 arg1 = (int)(SWIG_As_int(obj0));
4023 if (SWIG_arg_fail(1)) SWIG_fail;
4024 }
4025 {
4026 arg2 = (int)(SWIG_As_int(obj1));
4027 if (SWIG_arg_fail(2)) SWIG_fail;
4028 }
4029 if (obj2) {
4030 {
4031 arg3 = (int)(SWIG_As_int(obj2));
4032 if (SWIG_arg_fail(3)) SWIG_fail;
4033 }
4034 }
4035 {
4036 if (!wxPyCheckForApp()) SWIG_fail;
4037 PyThreadState* __tstate = wxPyBeginAllowThreads();
4038 result = (wxBitmap *)new wxBitmap(arg1,arg2,arg3);
4039
4040 wxPyEndAllowThreads(__tstate);
4041 if (PyErr_Occurred()) SWIG_fail;
4042 }
4043 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4044 return resultobj;
4045 fail:
4046 return NULL;
4047 }
4048
4049
4050 static PyObject *_wrap_new_BitmapFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4051 PyObject *resultobj;
4052 wxIcon *arg1 = 0 ;
4053 wxBitmap *result;
4054 PyObject * obj0 = 0 ;
4055 char *kwnames[] = {
4056 (char *) "icon", NULL
4057 };
4058
4059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromIcon",kwnames,&obj0)) goto fail;
4060 {
4061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4062 if (SWIG_arg_fail(1)) SWIG_fail;
4063 if (arg1 == NULL) {
4064 SWIG_null_ref("wxIcon");
4065 }
4066 if (SWIG_arg_fail(1)) SWIG_fail;
4067 }
4068 {
4069 if (!wxPyCheckForApp()) SWIG_fail;
4070 PyThreadState* __tstate = wxPyBeginAllowThreads();
4071 result = (wxBitmap *)new wxBitmap((wxIcon const &)*arg1);
4072
4073 wxPyEndAllowThreads(__tstate);
4074 if (PyErr_Occurred()) SWIG_fail;
4075 }
4076 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4077 return resultobj;
4078 fail:
4079 return NULL;
4080 }
4081
4082
4083 static PyObject *_wrap_new_BitmapFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
4084 PyObject *resultobj;
4085 wxImage *arg1 = 0 ;
4086 int arg2 = (int) -1 ;
4087 wxBitmap *result;
4088 PyObject * obj0 = 0 ;
4089 PyObject * obj1 = 0 ;
4090 char *kwnames[] = {
4091 (char *) "image",(char *) "depth", NULL
4092 };
4093
4094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BitmapFromImage",kwnames,&obj0,&obj1)) goto fail;
4095 {
4096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
4097 if (SWIG_arg_fail(1)) SWIG_fail;
4098 if (arg1 == NULL) {
4099 SWIG_null_ref("wxImage");
4100 }
4101 if (SWIG_arg_fail(1)) SWIG_fail;
4102 }
4103 if (obj1) {
4104 {
4105 arg2 = (int)(SWIG_As_int(obj1));
4106 if (SWIG_arg_fail(2)) SWIG_fail;
4107 }
4108 }
4109 {
4110 if (!wxPyCheckForApp()) SWIG_fail;
4111 PyThreadState* __tstate = wxPyBeginAllowThreads();
4112 result = (wxBitmap *)new wxBitmap((wxImage const &)*arg1,arg2);
4113
4114 wxPyEndAllowThreads(__tstate);
4115 if (PyErr_Occurred()) SWIG_fail;
4116 }
4117 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4118 return resultobj;
4119 fail:
4120 return NULL;
4121 }
4122
4123
4124 static PyObject *_wrap_new_BitmapFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
4125 PyObject *resultobj;
4126 PyObject *arg1 = (PyObject *) 0 ;
4127 wxBitmap *result;
4128 PyObject * obj0 = 0 ;
4129 char *kwnames[] = {
4130 (char *) "listOfStrings", NULL
4131 };
4132
4133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromXPMData",kwnames,&obj0)) goto fail;
4134 arg1 = obj0;
4135 {
4136 if (!wxPyCheckForApp()) SWIG_fail;
4137 PyThreadState* __tstate = wxPyBeginAllowThreads();
4138 result = (wxBitmap *)new_wxBitmap(arg1);
4139
4140 wxPyEndAllowThreads(__tstate);
4141 if (PyErr_Occurred()) SWIG_fail;
4142 }
4143 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4144 return resultobj;
4145 fail:
4146 return NULL;
4147 }
4148
4149
4150 static PyObject *_wrap_new_BitmapFromBits(PyObject *, PyObject *args, PyObject *kwargs) {
4151 PyObject *resultobj;
4152 PyObject *arg1 = (PyObject *) 0 ;
4153 int arg2 ;
4154 int arg3 ;
4155 int arg4 = (int) 1 ;
4156 wxBitmap *result;
4157 PyObject * obj0 = 0 ;
4158 PyObject * obj1 = 0 ;
4159 PyObject * obj2 = 0 ;
4160 PyObject * obj3 = 0 ;
4161 char *kwnames[] = {
4162 (char *) "bits",(char *) "width",(char *) "height",(char *) "depth", NULL
4163 };
4164
4165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:new_BitmapFromBits",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4166 arg1 = obj0;
4167 {
4168 arg2 = (int)(SWIG_As_int(obj1));
4169 if (SWIG_arg_fail(2)) SWIG_fail;
4170 }
4171 {
4172 arg3 = (int)(SWIG_As_int(obj2));
4173 if (SWIG_arg_fail(3)) SWIG_fail;
4174 }
4175 if (obj3) {
4176 {
4177 arg4 = (int)(SWIG_As_int(obj3));
4178 if (SWIG_arg_fail(4)) SWIG_fail;
4179 }
4180 }
4181 {
4182 if (!wxPyCheckForApp()) SWIG_fail;
4183 PyThreadState* __tstate = wxPyBeginAllowThreads();
4184 result = (wxBitmap *)new_wxBitmap(arg1,arg2,arg3,arg4);
4185
4186 wxPyEndAllowThreads(__tstate);
4187 if (PyErr_Occurred()) SWIG_fail;
4188 }
4189 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4190 return resultobj;
4191 fail:
4192 return NULL;
4193 }
4194
4195
4196 static PyObject *_wrap_Bitmap_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
4197 PyObject *resultobj;
4198 wxBitmap *arg1 = (wxBitmap *) 0 ;
4199 bool result;
4200 PyObject * obj0 = 0 ;
4201 char *kwnames[] = {
4202 (char *) "self", NULL
4203 };
4204
4205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_Ok",kwnames,&obj0)) goto fail;
4206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4207 if (SWIG_arg_fail(1)) SWIG_fail;
4208 {
4209 PyThreadState* __tstate = wxPyBeginAllowThreads();
4210 result = (bool)(arg1)->Ok();
4211
4212 wxPyEndAllowThreads(__tstate);
4213 if (PyErr_Occurred()) SWIG_fail;
4214 }
4215 {
4216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4217 }
4218 return resultobj;
4219 fail:
4220 return NULL;
4221 }
4222
4223
4224 static PyObject *_wrap_Bitmap_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4225 PyObject *resultobj;
4226 wxBitmap *arg1 = (wxBitmap *) 0 ;
4227 int result;
4228 PyObject * obj0 = 0 ;
4229 char *kwnames[] = {
4230 (char *) "self", NULL
4231 };
4232
4233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetWidth",kwnames,&obj0)) goto fail;
4234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4235 if (SWIG_arg_fail(1)) SWIG_fail;
4236 {
4237 PyThreadState* __tstate = wxPyBeginAllowThreads();
4238 result = (int)(arg1)->GetWidth();
4239
4240 wxPyEndAllowThreads(__tstate);
4241 if (PyErr_Occurred()) SWIG_fail;
4242 }
4243 {
4244 resultobj = SWIG_From_int((int)(result));
4245 }
4246 return resultobj;
4247 fail:
4248 return NULL;
4249 }
4250
4251
4252 static PyObject *_wrap_Bitmap_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4253 PyObject *resultobj;
4254 wxBitmap *arg1 = (wxBitmap *) 0 ;
4255 int result;
4256 PyObject * obj0 = 0 ;
4257 char *kwnames[] = {
4258 (char *) "self", NULL
4259 };
4260
4261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetHeight",kwnames,&obj0)) goto fail;
4262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4263 if (SWIG_arg_fail(1)) SWIG_fail;
4264 {
4265 PyThreadState* __tstate = wxPyBeginAllowThreads();
4266 result = (int)(arg1)->GetHeight();
4267
4268 wxPyEndAllowThreads(__tstate);
4269 if (PyErr_Occurred()) SWIG_fail;
4270 }
4271 {
4272 resultobj = SWIG_From_int((int)(result));
4273 }
4274 return resultobj;
4275 fail:
4276 return NULL;
4277 }
4278
4279
4280 static PyObject *_wrap_Bitmap_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4281 PyObject *resultobj;
4282 wxBitmap *arg1 = (wxBitmap *) 0 ;
4283 int result;
4284 PyObject * obj0 = 0 ;
4285 char *kwnames[] = {
4286 (char *) "self", NULL
4287 };
4288
4289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetDepth",kwnames,&obj0)) goto fail;
4290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4291 if (SWIG_arg_fail(1)) SWIG_fail;
4292 {
4293 PyThreadState* __tstate = wxPyBeginAllowThreads();
4294 result = (int)(arg1)->GetDepth();
4295
4296 wxPyEndAllowThreads(__tstate);
4297 if (PyErr_Occurred()) SWIG_fail;
4298 }
4299 {
4300 resultobj = SWIG_From_int((int)(result));
4301 }
4302 return resultobj;
4303 fail:
4304 return NULL;
4305 }
4306
4307
4308 static PyObject *_wrap_Bitmap_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4309 PyObject *resultobj;
4310 wxBitmap *arg1 = (wxBitmap *) 0 ;
4311 wxSize result;
4312 PyObject * obj0 = 0 ;
4313 char *kwnames[] = {
4314 (char *) "self", NULL
4315 };
4316
4317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetSize",kwnames,&obj0)) goto fail;
4318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4319 if (SWIG_arg_fail(1)) SWIG_fail;
4320 {
4321 PyThreadState* __tstate = wxPyBeginAllowThreads();
4322 result = wxBitmap_GetSize(arg1);
4323
4324 wxPyEndAllowThreads(__tstate);
4325 if (PyErr_Occurred()) SWIG_fail;
4326 }
4327 {
4328 wxSize * resultptr;
4329 resultptr = new wxSize((wxSize &)(result));
4330 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
4331 }
4332 return resultobj;
4333 fail:
4334 return NULL;
4335 }
4336
4337
4338 static PyObject *_wrap_Bitmap_ConvertToImage(PyObject *, PyObject *args, PyObject *kwargs) {
4339 PyObject *resultobj;
4340 wxBitmap *arg1 = (wxBitmap *) 0 ;
4341 SwigValueWrapper<wxImage > result;
4342 PyObject * obj0 = 0 ;
4343 char *kwnames[] = {
4344 (char *) "self", NULL
4345 };
4346
4347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_ConvertToImage",kwnames,&obj0)) goto fail;
4348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4349 if (SWIG_arg_fail(1)) SWIG_fail;
4350 {
4351 PyThreadState* __tstate = wxPyBeginAllowThreads();
4352 result = ((wxBitmap const *)arg1)->ConvertToImage();
4353
4354 wxPyEndAllowThreads(__tstate);
4355 if (PyErr_Occurred()) SWIG_fail;
4356 }
4357 {
4358 wxImage * resultptr;
4359 resultptr = new wxImage((wxImage &)(result));
4360 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
4361 }
4362 return resultobj;
4363 fail:
4364 return NULL;
4365 }
4366
4367
4368 static PyObject *_wrap_Bitmap_GetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4369 PyObject *resultobj;
4370 wxBitmap *arg1 = (wxBitmap *) 0 ;
4371 wxMask *result;
4372 PyObject * obj0 = 0 ;
4373 char *kwnames[] = {
4374 (char *) "self", NULL
4375 };
4376
4377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetMask",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 = (wxMask *)((wxBitmap const *)arg1)->GetMask();
4383
4384 wxPyEndAllowThreads(__tstate);
4385 if (PyErr_Occurred()) SWIG_fail;
4386 }
4387 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 0);
4388 return resultobj;
4389 fail:
4390 return NULL;
4391 }
4392
4393
4394 static PyObject *_wrap_Bitmap_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4395 PyObject *resultobj;
4396 wxBitmap *arg1 = (wxBitmap *) 0 ;
4397 wxMask *arg2 = (wxMask *) 0 ;
4398 PyObject * obj0 = 0 ;
4399 PyObject * obj1 = 0 ;
4400 char *kwnames[] = {
4401 (char *) "self",(char *) "mask", NULL
4402 };
4403
4404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMask",kwnames,&obj0,&obj1)) goto fail;
4405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4406 if (SWIG_arg_fail(1)) SWIG_fail;
4407 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMask, SWIG_POINTER_EXCEPTION | 0);
4408 if (SWIG_arg_fail(2)) SWIG_fail;
4409 {
4410 PyThreadState* __tstate = wxPyBeginAllowThreads();
4411 (arg1)->SetMask(arg2);
4412
4413 wxPyEndAllowThreads(__tstate);
4414 if (PyErr_Occurred()) SWIG_fail;
4415 }
4416 Py_INCREF(Py_None); resultobj = Py_None;
4417 return resultobj;
4418 fail:
4419 return NULL;
4420 }
4421
4422
4423 static PyObject *_wrap_Bitmap_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
4424 PyObject *resultobj;
4425 wxBitmap *arg1 = (wxBitmap *) 0 ;
4426 wxColour *arg2 = 0 ;
4427 wxColour temp2 ;
4428 PyObject * obj0 = 0 ;
4429 PyObject * obj1 = 0 ;
4430 char *kwnames[] = {
4431 (char *) "self",(char *) "colour", NULL
4432 };
4433
4434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMaskColour",kwnames,&obj0,&obj1)) goto fail;
4435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4436 if (SWIG_arg_fail(1)) SWIG_fail;
4437 {
4438 arg2 = &temp2;
4439 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4440 }
4441 {
4442 PyThreadState* __tstate = wxPyBeginAllowThreads();
4443 wxBitmap_SetMaskColour(arg1,(wxColour const &)*arg2);
4444
4445 wxPyEndAllowThreads(__tstate);
4446 if (PyErr_Occurred()) SWIG_fail;
4447 }
4448 Py_INCREF(Py_None); resultobj = Py_None;
4449 return resultobj;
4450 fail:
4451 return NULL;
4452 }
4453
4454
4455 static PyObject *_wrap_Bitmap_GetSubBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4456 PyObject *resultobj;
4457 wxBitmap *arg1 = (wxBitmap *) 0 ;
4458 wxRect *arg2 = 0 ;
4459 SwigValueWrapper<wxBitmap > result;
4460 wxRect temp2 ;
4461 PyObject * obj0 = 0 ;
4462 PyObject * obj1 = 0 ;
4463 char *kwnames[] = {
4464 (char *) "self",(char *) "rect", NULL
4465 };
4466
4467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_GetSubBitmap",kwnames,&obj0,&obj1)) goto fail;
4468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4469 if (SWIG_arg_fail(1)) SWIG_fail;
4470 {
4471 arg2 = &temp2;
4472 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4473 }
4474 {
4475 PyThreadState* __tstate = wxPyBeginAllowThreads();
4476 result = ((wxBitmap const *)arg1)->GetSubBitmap((wxRect const &)*arg2);
4477
4478 wxPyEndAllowThreads(__tstate);
4479 if (PyErr_Occurred()) SWIG_fail;
4480 }
4481 {
4482 wxBitmap * resultptr;
4483 resultptr = new wxBitmap((wxBitmap &)(result));
4484 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
4485 }
4486 return resultobj;
4487 fail:
4488 return NULL;
4489 }
4490
4491
4492 static PyObject *_wrap_Bitmap_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
4493 PyObject *resultobj;
4494 wxBitmap *arg1 = (wxBitmap *) 0 ;
4495 wxString *arg2 = 0 ;
4496 wxBitmapType arg3 ;
4497 wxPalette *arg4 = (wxPalette *) NULL ;
4498 bool result;
4499 bool temp2 = false ;
4500 PyObject * obj0 = 0 ;
4501 PyObject * obj1 = 0 ;
4502 PyObject * obj2 = 0 ;
4503 PyObject * obj3 = 0 ;
4504 char *kwnames[] = {
4505 (char *) "self",(char *) "name",(char *) "type",(char *) "palette", NULL
4506 };
4507
4508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Bitmap_SaveFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4510 if (SWIG_arg_fail(1)) SWIG_fail;
4511 {
4512 arg2 = wxString_in_helper(obj1);
4513 if (arg2 == NULL) SWIG_fail;
4514 temp2 = true;
4515 }
4516 {
4517 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4518 if (SWIG_arg_fail(3)) SWIG_fail;
4519 }
4520 if (obj3) {
4521 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
4522 if (SWIG_arg_fail(4)) SWIG_fail;
4523 }
4524 {
4525 PyThreadState* __tstate = wxPyBeginAllowThreads();
4526 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxBitmapType )arg3,arg4);
4527
4528 wxPyEndAllowThreads(__tstate);
4529 if (PyErr_Occurred()) SWIG_fail;
4530 }
4531 {
4532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4533 }
4534 {
4535 if (temp2)
4536 delete arg2;
4537 }
4538 return resultobj;
4539 fail:
4540 {
4541 if (temp2)
4542 delete arg2;
4543 }
4544 return NULL;
4545 }
4546
4547
4548 static PyObject *_wrap_Bitmap_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
4549 PyObject *resultobj;
4550 wxBitmap *arg1 = (wxBitmap *) 0 ;
4551 wxString *arg2 = 0 ;
4552 wxBitmapType arg3 ;
4553 bool result;
4554 bool temp2 = false ;
4555 PyObject * obj0 = 0 ;
4556 PyObject * obj1 = 0 ;
4557 PyObject * obj2 = 0 ;
4558 char *kwnames[] = {
4559 (char *) "self",(char *) "name",(char *) "type", NULL
4560 };
4561
4562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Bitmap_LoadFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
4563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4564 if (SWIG_arg_fail(1)) SWIG_fail;
4565 {
4566 arg2 = wxString_in_helper(obj1);
4567 if (arg2 == NULL) SWIG_fail;
4568 temp2 = true;
4569 }
4570 {
4571 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4572 if (SWIG_arg_fail(3)) SWIG_fail;
4573 }
4574 {
4575 PyThreadState* __tstate = wxPyBeginAllowThreads();
4576 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxBitmapType )arg3);
4577
4578 wxPyEndAllowThreads(__tstate);
4579 if (PyErr_Occurred()) SWIG_fail;
4580 }
4581 {
4582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4583 }
4584 {
4585 if (temp2)
4586 delete arg2;
4587 }
4588 return resultobj;
4589 fail:
4590 {
4591 if (temp2)
4592 delete arg2;
4593 }
4594 return NULL;
4595 }
4596
4597
4598 static PyObject *_wrap_Bitmap_GetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
4599 PyObject *resultobj;
4600 wxBitmap *arg1 = (wxBitmap *) 0 ;
4601 wxPalette *result;
4602 PyObject * obj0 = 0 ;
4603 char *kwnames[] = {
4604 (char *) "self", NULL
4605 };
4606
4607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetPalette",kwnames,&obj0)) goto fail;
4608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4609 if (SWIG_arg_fail(1)) SWIG_fail;
4610 {
4611 PyThreadState* __tstate = wxPyBeginAllowThreads();
4612 result = (wxPalette *)((wxBitmap const *)arg1)->GetPalette();
4613
4614 wxPyEndAllowThreads(__tstate);
4615 if (PyErr_Occurred()) SWIG_fail;
4616 }
4617 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 0);
4618 return resultobj;
4619 fail:
4620 return NULL;
4621 }
4622
4623
4624 static PyObject *_wrap_Bitmap_CopyFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4625 PyObject *resultobj;
4626 wxBitmap *arg1 = (wxBitmap *) 0 ;
4627 wxIcon *arg2 = 0 ;
4628 bool result;
4629 PyObject * obj0 = 0 ;
4630 PyObject * obj1 = 0 ;
4631 char *kwnames[] = {
4632 (char *) "self",(char *) "icon", NULL
4633 };
4634
4635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_CopyFromIcon",kwnames,&obj0,&obj1)) goto fail;
4636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4637 if (SWIG_arg_fail(1)) SWIG_fail;
4638 {
4639 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4640 if (SWIG_arg_fail(2)) SWIG_fail;
4641 if (arg2 == NULL) {
4642 SWIG_null_ref("wxIcon");
4643 }
4644 if (SWIG_arg_fail(2)) SWIG_fail;
4645 }
4646 {
4647 PyThreadState* __tstate = wxPyBeginAllowThreads();
4648 result = (bool)(arg1)->CopyFromIcon((wxIcon const &)*arg2);
4649
4650 wxPyEndAllowThreads(__tstate);
4651 if (PyErr_Occurred()) SWIG_fail;
4652 }
4653 {
4654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4655 }
4656 return resultobj;
4657 fail:
4658 return NULL;
4659 }
4660
4661
4662 static PyObject *_wrap_Bitmap_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4663 PyObject *resultobj;
4664 wxBitmap *arg1 = (wxBitmap *) 0 ;
4665 int arg2 ;
4666 PyObject * obj0 = 0 ;
4667 PyObject * obj1 = 0 ;
4668 char *kwnames[] = {
4669 (char *) "self",(char *) "height", NULL
4670 };
4671
4672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetHeight",kwnames,&obj0,&obj1)) goto fail;
4673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4674 if (SWIG_arg_fail(1)) SWIG_fail;
4675 {
4676 arg2 = (int)(SWIG_As_int(obj1));
4677 if (SWIG_arg_fail(2)) SWIG_fail;
4678 }
4679 {
4680 PyThreadState* __tstate = wxPyBeginAllowThreads();
4681 (arg1)->SetHeight(arg2);
4682
4683 wxPyEndAllowThreads(__tstate);
4684 if (PyErr_Occurred()) SWIG_fail;
4685 }
4686 Py_INCREF(Py_None); resultobj = Py_None;
4687 return resultobj;
4688 fail:
4689 return NULL;
4690 }
4691
4692
4693 static PyObject *_wrap_Bitmap_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4694 PyObject *resultobj;
4695 wxBitmap *arg1 = (wxBitmap *) 0 ;
4696 int arg2 ;
4697 PyObject * obj0 = 0 ;
4698 PyObject * obj1 = 0 ;
4699 char *kwnames[] = {
4700 (char *) "self",(char *) "width", NULL
4701 };
4702
4703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetWidth",kwnames,&obj0,&obj1)) goto fail;
4704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4705 if (SWIG_arg_fail(1)) SWIG_fail;
4706 {
4707 arg2 = (int)(SWIG_As_int(obj1));
4708 if (SWIG_arg_fail(2)) SWIG_fail;
4709 }
4710 {
4711 PyThreadState* __tstate = wxPyBeginAllowThreads();
4712 (arg1)->SetWidth(arg2);
4713
4714 wxPyEndAllowThreads(__tstate);
4715 if (PyErr_Occurred()) SWIG_fail;
4716 }
4717 Py_INCREF(Py_None); resultobj = Py_None;
4718 return resultobj;
4719 fail:
4720 return NULL;
4721 }
4722
4723
4724 static PyObject *_wrap_Bitmap_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4725 PyObject *resultobj;
4726 wxBitmap *arg1 = (wxBitmap *) 0 ;
4727 int arg2 ;
4728 PyObject * obj0 = 0 ;
4729 PyObject * obj1 = 0 ;
4730 char *kwnames[] = {
4731 (char *) "self",(char *) "depth", NULL
4732 };
4733
4734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetDepth",kwnames,&obj0,&obj1)) goto fail;
4735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4736 if (SWIG_arg_fail(1)) SWIG_fail;
4737 {
4738 arg2 = (int)(SWIG_As_int(obj1));
4739 if (SWIG_arg_fail(2)) SWIG_fail;
4740 }
4741 {
4742 PyThreadState* __tstate = wxPyBeginAllowThreads();
4743 (arg1)->SetDepth(arg2);
4744
4745 wxPyEndAllowThreads(__tstate);
4746 if (PyErr_Occurred()) SWIG_fail;
4747 }
4748 Py_INCREF(Py_None); resultobj = Py_None;
4749 return resultobj;
4750 fail:
4751 return NULL;
4752 }
4753
4754
4755 static PyObject *_wrap_Bitmap_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4756 PyObject *resultobj;
4757 wxBitmap *arg1 = (wxBitmap *) 0 ;
4758 wxSize *arg2 = 0 ;
4759 wxSize temp2 ;
4760 PyObject * obj0 = 0 ;
4761 PyObject * obj1 = 0 ;
4762 char *kwnames[] = {
4763 (char *) "self",(char *) "size", NULL
4764 };
4765
4766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetSize",kwnames,&obj0,&obj1)) goto fail;
4767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4768 if (SWIG_arg_fail(1)) SWIG_fail;
4769 {
4770 arg2 = &temp2;
4771 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4772 }
4773 {
4774 PyThreadState* __tstate = wxPyBeginAllowThreads();
4775 wxBitmap_SetSize(arg1,(wxSize const &)*arg2);
4776
4777 wxPyEndAllowThreads(__tstate);
4778 if (PyErr_Occurred()) SWIG_fail;
4779 }
4780 Py_INCREF(Py_None); resultobj = Py_None;
4781 return resultobj;
4782 fail:
4783 return NULL;
4784 }
4785
4786
4787 static PyObject *_wrap_Bitmap___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4788 PyObject *resultobj;
4789 wxBitmap *arg1 = (wxBitmap *) 0 ;
4790 wxBitmap *arg2 = (wxBitmap *) 0 ;
4791 bool result;
4792 PyObject * obj0 = 0 ;
4793 PyObject * obj1 = 0 ;
4794 char *kwnames[] = {
4795 (char *) "self",(char *) "other", NULL
4796 };
4797
4798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___eq__",kwnames,&obj0,&obj1)) goto fail;
4799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4800 if (SWIG_arg_fail(1)) SWIG_fail;
4801 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4802 if (SWIG_arg_fail(2)) SWIG_fail;
4803 {
4804 PyThreadState* __tstate = wxPyBeginAllowThreads();
4805 result = (bool)wxBitmap___eq__(arg1,(wxBitmap const *)arg2);
4806
4807 wxPyEndAllowThreads(__tstate);
4808 if (PyErr_Occurred()) SWIG_fail;
4809 }
4810 {
4811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4812 }
4813 return resultobj;
4814 fail:
4815 return NULL;
4816 }
4817
4818
4819 static PyObject *_wrap_Bitmap___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4820 PyObject *resultobj;
4821 wxBitmap *arg1 = (wxBitmap *) 0 ;
4822 wxBitmap *arg2 = (wxBitmap *) 0 ;
4823 bool result;
4824 PyObject * obj0 = 0 ;
4825 PyObject * obj1 = 0 ;
4826 char *kwnames[] = {
4827 (char *) "self",(char *) "other", NULL
4828 };
4829
4830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___ne__",kwnames,&obj0,&obj1)) goto fail;
4831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4832 if (SWIG_arg_fail(1)) SWIG_fail;
4833 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4834 if (SWIG_arg_fail(2)) SWIG_fail;
4835 {
4836 PyThreadState* __tstate = wxPyBeginAllowThreads();
4837 result = (bool)wxBitmap___ne__(arg1,(wxBitmap const *)arg2);
4838
4839 wxPyEndAllowThreads(__tstate);
4840 if (PyErr_Occurred()) SWIG_fail;
4841 }
4842 {
4843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4844 }
4845 return resultobj;
4846 fail:
4847 return NULL;
4848 }
4849
4850
4851 static PyObject * Bitmap_swigregister(PyObject *, PyObject *args) {
4852 PyObject *obj;
4853 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4854 SWIG_TypeClientData(SWIGTYPE_p_wxBitmap, obj);
4855 Py_INCREF(obj);
4856 return Py_BuildValue((char *)"");
4857 }
4858 static PyObject *_wrap_new_Mask(PyObject *, PyObject *args, PyObject *kwargs) {
4859 PyObject *resultobj;
4860 wxBitmap *arg1 = 0 ;
4861 wxColour const &arg2_defvalue = wxNullColour ;
4862 wxColour *arg2 = (wxColour *) &arg2_defvalue ;
4863 wxMask *result;
4864 wxColour temp2 ;
4865 PyObject * obj0 = 0 ;
4866 PyObject * obj1 = 0 ;
4867 char *kwnames[] = {
4868 (char *) "bitmap",(char *) "colour", NULL
4869 };
4870
4871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Mask",kwnames,&obj0,&obj1)) goto fail;
4872 {
4873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4874 if (SWIG_arg_fail(1)) SWIG_fail;
4875 if (arg1 == NULL) {
4876 SWIG_null_ref("wxBitmap");
4877 }
4878 if (SWIG_arg_fail(1)) SWIG_fail;
4879 }
4880 if (obj1) {
4881 {
4882 arg2 = &temp2;
4883 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4884 }
4885 }
4886 {
4887 if (!wxPyCheckForApp()) SWIG_fail;
4888 PyThreadState* __tstate = wxPyBeginAllowThreads();
4889 result = (wxMask *)new_wxMask((wxBitmap const &)*arg1,(wxColour const &)*arg2);
4890
4891 wxPyEndAllowThreads(__tstate);
4892 if (PyErr_Occurred()) SWIG_fail;
4893 }
4894 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 1);
4895 return resultobj;
4896 fail:
4897 return NULL;
4898 }
4899
4900
4901 static PyObject * Mask_swigregister(PyObject *, PyObject *args) {
4902 PyObject *obj;
4903 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4904 SWIG_TypeClientData(SWIGTYPE_p_wxMask, obj);
4905 Py_INCREF(obj);
4906 return Py_BuildValue((char *)"");
4907 }
4908 static PyObject *_wrap_new_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
4909 PyObject *resultobj;
4910 wxString *arg1 = 0 ;
4911 wxBitmapType arg2 ;
4912 int arg3 = (int) -1 ;
4913 int arg4 = (int) -1 ;
4914 wxIcon *result;
4915 bool temp1 = false ;
4916 PyObject * obj0 = 0 ;
4917 PyObject * obj1 = 0 ;
4918 PyObject * obj2 = 0 ;
4919 PyObject * obj3 = 0 ;
4920 char *kwnames[] = {
4921 (char *) "name",(char *) "type",(char *) "desiredWidth",(char *) "desiredHeight", NULL
4922 };
4923
4924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Icon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4925 {
4926 arg1 = wxString_in_helper(obj0);
4927 if (arg1 == NULL) SWIG_fail;
4928 temp1 = true;
4929 }
4930 {
4931 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
4932 if (SWIG_arg_fail(2)) SWIG_fail;
4933 }
4934 if (obj2) {
4935 {
4936 arg3 = (int)(SWIG_As_int(obj2));
4937 if (SWIG_arg_fail(3)) SWIG_fail;
4938 }
4939 }
4940 if (obj3) {
4941 {
4942 arg4 = (int)(SWIG_As_int(obj3));
4943 if (SWIG_arg_fail(4)) SWIG_fail;
4944 }
4945 }
4946 {
4947 if (!wxPyCheckForApp()) SWIG_fail;
4948 PyThreadState* __tstate = wxPyBeginAllowThreads();
4949 result = (wxIcon *)new wxIcon((wxString const &)*arg1,(wxBitmapType )arg2,arg3,arg4);
4950
4951 wxPyEndAllowThreads(__tstate);
4952 if (PyErr_Occurred()) SWIG_fail;
4953 }
4954 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
4955 {
4956 if (temp1)
4957 delete arg1;
4958 }
4959 return resultobj;
4960 fail:
4961 {
4962 if (temp1)
4963 delete arg1;
4964 }
4965 return NULL;
4966 }
4967
4968
4969 static PyObject *_wrap_delete_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
4970 PyObject *resultobj;
4971 wxIcon *arg1 = (wxIcon *) 0 ;
4972 PyObject * obj0 = 0 ;
4973 char *kwnames[] = {
4974 (char *) "self", NULL
4975 };
4976
4977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Icon",kwnames,&obj0)) goto fail;
4978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4979 if (SWIG_arg_fail(1)) SWIG_fail;
4980 {
4981 PyThreadState* __tstate = wxPyBeginAllowThreads();
4982 delete arg1;
4983
4984 wxPyEndAllowThreads(__tstate);
4985 if (PyErr_Occurred()) SWIG_fail;
4986 }
4987 Py_INCREF(Py_None); resultobj = Py_None;
4988 return resultobj;
4989 fail:
4990 return NULL;
4991 }
4992
4993
4994 static PyObject *_wrap_new_EmptyIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4995 PyObject *resultobj;
4996 wxIcon *result;
4997 char *kwnames[] = {
4998 NULL
4999 };
5000
5001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EmptyIcon",kwnames)) goto fail;
5002 {
5003 if (!wxPyCheckForApp()) SWIG_fail;
5004 PyThreadState* __tstate = wxPyBeginAllowThreads();
5005 result = (wxIcon *)new wxIcon();
5006
5007 wxPyEndAllowThreads(__tstate);
5008 if (PyErr_Occurred()) SWIG_fail;
5009 }
5010 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5011 return resultobj;
5012 fail:
5013 return NULL;
5014 }
5015
5016
5017 static PyObject *_wrap_new_IconFromLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5018 PyObject *resultobj;
5019 wxIconLocation *arg1 = 0 ;
5020 wxIcon *result;
5021 PyObject * obj0 = 0 ;
5022 char *kwnames[] = {
5023 (char *) "loc", NULL
5024 };
5025
5026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromLocation",kwnames,&obj0)) goto fail;
5027 {
5028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5029 if (SWIG_arg_fail(1)) SWIG_fail;
5030 if (arg1 == NULL) {
5031 SWIG_null_ref("wxIconLocation");
5032 }
5033 if (SWIG_arg_fail(1)) SWIG_fail;
5034 }
5035 {
5036 if (!wxPyCheckForApp()) SWIG_fail;
5037 PyThreadState* __tstate = wxPyBeginAllowThreads();
5038 result = (wxIcon *)new wxIcon((wxIconLocation const &)*arg1);
5039
5040 wxPyEndAllowThreads(__tstate);
5041 if (PyErr_Occurred()) SWIG_fail;
5042 }
5043 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5044 return resultobj;
5045 fail:
5046 return NULL;
5047 }
5048
5049
5050 static PyObject *_wrap_new_IconFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5051 PyObject *resultobj;
5052 wxBitmap *arg1 = 0 ;
5053 wxIcon *result;
5054 PyObject * obj0 = 0 ;
5055 char *kwnames[] = {
5056 (char *) "bmp", NULL
5057 };
5058
5059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromBitmap",kwnames,&obj0)) goto fail;
5060 {
5061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5062 if (SWIG_arg_fail(1)) SWIG_fail;
5063 if (arg1 == NULL) {
5064 SWIG_null_ref("wxBitmap");
5065 }
5066 if (SWIG_arg_fail(1)) SWIG_fail;
5067 }
5068 {
5069 if (!wxPyCheckForApp()) SWIG_fail;
5070 PyThreadState* __tstate = wxPyBeginAllowThreads();
5071 result = (wxIcon *)new_wxIcon((wxBitmap const &)*arg1);
5072
5073 wxPyEndAllowThreads(__tstate);
5074 if (PyErr_Occurred()) SWIG_fail;
5075 }
5076 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5077 return resultobj;
5078 fail:
5079 return NULL;
5080 }
5081
5082
5083 static PyObject *_wrap_new_IconFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
5084 PyObject *resultobj;
5085 PyObject *arg1 = (PyObject *) 0 ;
5086 wxIcon *result;
5087 PyObject * obj0 = 0 ;
5088 char *kwnames[] = {
5089 (char *) "listOfStrings", NULL
5090 };
5091
5092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromXPMData",kwnames,&obj0)) goto fail;
5093 arg1 = obj0;
5094 {
5095 if (!wxPyCheckForApp()) SWIG_fail;
5096 PyThreadState* __tstate = wxPyBeginAllowThreads();
5097 result = (wxIcon *)new_wxIcon(arg1);
5098
5099 wxPyEndAllowThreads(__tstate);
5100 if (PyErr_Occurred()) SWIG_fail;
5101 }
5102 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5103 return resultobj;
5104 fail:
5105 return NULL;
5106 }
5107
5108
5109 static PyObject *_wrap_Icon_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
5110 PyObject *resultobj;
5111 wxIcon *arg1 = (wxIcon *) 0 ;
5112 wxString *arg2 = 0 ;
5113 wxBitmapType arg3 ;
5114 bool result;
5115 bool temp2 = false ;
5116 PyObject * obj0 = 0 ;
5117 PyObject * obj1 = 0 ;
5118 PyObject * obj2 = 0 ;
5119 char *kwnames[] = {
5120 (char *) "self",(char *) "name",(char *) "type", NULL
5121 };
5122
5123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Icon_LoadFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
5124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5125 if (SWIG_arg_fail(1)) SWIG_fail;
5126 {
5127 arg2 = wxString_in_helper(obj1);
5128 if (arg2 == NULL) SWIG_fail;
5129 temp2 = true;
5130 }
5131 {
5132 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
5133 if (SWIG_arg_fail(3)) SWIG_fail;
5134 }
5135 {
5136 PyThreadState* __tstate = wxPyBeginAllowThreads();
5137 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxBitmapType )arg3);
5138
5139 wxPyEndAllowThreads(__tstate);
5140 if (PyErr_Occurred()) SWIG_fail;
5141 }
5142 {
5143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5144 }
5145 {
5146 if (temp2)
5147 delete arg2;
5148 }
5149 return resultobj;
5150 fail:
5151 {
5152 if (temp2)
5153 delete arg2;
5154 }
5155 return NULL;
5156 }
5157
5158
5159 static PyObject *_wrap_Icon_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
5160 PyObject *resultobj;
5161 wxIcon *arg1 = (wxIcon *) 0 ;
5162 bool result;
5163 PyObject * obj0 = 0 ;
5164 char *kwnames[] = {
5165 (char *) "self", NULL
5166 };
5167
5168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_Ok",kwnames,&obj0)) goto fail;
5169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5170 if (SWIG_arg_fail(1)) SWIG_fail;
5171 {
5172 PyThreadState* __tstate = wxPyBeginAllowThreads();
5173 result = (bool)(arg1)->Ok();
5174
5175 wxPyEndAllowThreads(__tstate);
5176 if (PyErr_Occurred()) SWIG_fail;
5177 }
5178 {
5179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5180 }
5181 return resultobj;
5182 fail:
5183 return NULL;
5184 }
5185
5186
5187 static PyObject *_wrap_Icon_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5188 PyObject *resultobj;
5189 wxIcon *arg1 = (wxIcon *) 0 ;
5190 int result;
5191 PyObject * obj0 = 0 ;
5192 char *kwnames[] = {
5193 (char *) "self", NULL
5194 };
5195
5196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetWidth",kwnames,&obj0)) goto fail;
5197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5198 if (SWIG_arg_fail(1)) SWIG_fail;
5199 {
5200 PyThreadState* __tstate = wxPyBeginAllowThreads();
5201 result = (int)(arg1)->GetWidth();
5202
5203 wxPyEndAllowThreads(__tstate);
5204 if (PyErr_Occurred()) SWIG_fail;
5205 }
5206 {
5207 resultobj = SWIG_From_int((int)(result));
5208 }
5209 return resultobj;
5210 fail:
5211 return NULL;
5212 }
5213
5214
5215 static PyObject *_wrap_Icon_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5216 PyObject *resultobj;
5217 wxIcon *arg1 = (wxIcon *) 0 ;
5218 int result;
5219 PyObject * obj0 = 0 ;
5220 char *kwnames[] = {
5221 (char *) "self", NULL
5222 };
5223
5224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetHeight",kwnames,&obj0)) goto fail;
5225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5226 if (SWIG_arg_fail(1)) SWIG_fail;
5227 {
5228 PyThreadState* __tstate = wxPyBeginAllowThreads();
5229 result = (int)(arg1)->GetHeight();
5230
5231 wxPyEndAllowThreads(__tstate);
5232 if (PyErr_Occurred()) SWIG_fail;
5233 }
5234 {
5235 resultobj = SWIG_From_int((int)(result));
5236 }
5237 return resultobj;
5238 fail:
5239 return NULL;
5240 }
5241
5242
5243 static PyObject *_wrap_Icon_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5244 PyObject *resultobj;
5245 wxIcon *arg1 = (wxIcon *) 0 ;
5246 int result;
5247 PyObject * obj0 = 0 ;
5248 char *kwnames[] = {
5249 (char *) "self", NULL
5250 };
5251
5252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetDepth",kwnames,&obj0)) goto fail;
5253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5254 if (SWIG_arg_fail(1)) SWIG_fail;
5255 {
5256 PyThreadState* __tstate = wxPyBeginAllowThreads();
5257 result = (int)(arg1)->GetDepth();
5258
5259 wxPyEndAllowThreads(__tstate);
5260 if (PyErr_Occurred()) SWIG_fail;
5261 }
5262 {
5263 resultobj = SWIG_From_int((int)(result));
5264 }
5265 return resultobj;
5266 fail:
5267 return NULL;
5268 }
5269
5270
5271 static PyObject *_wrap_Icon_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5272 PyObject *resultobj;
5273 wxIcon *arg1 = (wxIcon *) 0 ;
5274 int arg2 ;
5275 PyObject * obj0 = 0 ;
5276 PyObject * obj1 = 0 ;
5277 char *kwnames[] = {
5278 (char *) "self",(char *) "w", NULL
5279 };
5280
5281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5283 if (SWIG_arg_fail(1)) SWIG_fail;
5284 {
5285 arg2 = (int)(SWIG_As_int(obj1));
5286 if (SWIG_arg_fail(2)) SWIG_fail;
5287 }
5288 {
5289 PyThreadState* __tstate = wxPyBeginAllowThreads();
5290 (arg1)->SetWidth(arg2);
5291
5292 wxPyEndAllowThreads(__tstate);
5293 if (PyErr_Occurred()) SWIG_fail;
5294 }
5295 Py_INCREF(Py_None); resultobj = Py_None;
5296 return resultobj;
5297 fail:
5298 return NULL;
5299 }
5300
5301
5302 static PyObject *_wrap_Icon_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5303 PyObject *resultobj;
5304 wxIcon *arg1 = (wxIcon *) 0 ;
5305 int arg2 ;
5306 PyObject * obj0 = 0 ;
5307 PyObject * obj1 = 0 ;
5308 char *kwnames[] = {
5309 (char *) "self",(char *) "h", NULL
5310 };
5311
5312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5314 if (SWIG_arg_fail(1)) SWIG_fail;
5315 {
5316 arg2 = (int)(SWIG_As_int(obj1));
5317 if (SWIG_arg_fail(2)) SWIG_fail;
5318 }
5319 {
5320 PyThreadState* __tstate = wxPyBeginAllowThreads();
5321 (arg1)->SetHeight(arg2);
5322
5323 wxPyEndAllowThreads(__tstate);
5324 if (PyErr_Occurred()) SWIG_fail;
5325 }
5326 Py_INCREF(Py_None); resultobj = Py_None;
5327 return resultobj;
5328 fail:
5329 return NULL;
5330 }
5331
5332
5333 static PyObject *_wrap_Icon_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5334 PyObject *resultobj;
5335 wxIcon *arg1 = (wxIcon *) 0 ;
5336 int arg2 ;
5337 PyObject * obj0 = 0 ;
5338 PyObject * obj1 = 0 ;
5339 char *kwnames[] = {
5340 (char *) "self",(char *) "d", NULL
5341 };
5342
5343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetDepth",kwnames,&obj0,&obj1)) goto fail;
5344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5345 if (SWIG_arg_fail(1)) SWIG_fail;
5346 {
5347 arg2 = (int)(SWIG_As_int(obj1));
5348 if (SWIG_arg_fail(2)) SWIG_fail;
5349 }
5350 {
5351 PyThreadState* __tstate = wxPyBeginAllowThreads();
5352 (arg1)->SetDepth(arg2);
5353
5354 wxPyEndAllowThreads(__tstate);
5355 if (PyErr_Occurred()) SWIG_fail;
5356 }
5357 Py_INCREF(Py_None); resultobj = Py_None;
5358 return resultobj;
5359 fail:
5360 return NULL;
5361 }
5362
5363
5364 static PyObject *_wrap_Icon_CopyFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5365 PyObject *resultobj;
5366 wxIcon *arg1 = (wxIcon *) 0 ;
5367 wxBitmap *arg2 = 0 ;
5368 PyObject * obj0 = 0 ;
5369 PyObject * obj1 = 0 ;
5370 char *kwnames[] = {
5371 (char *) "self",(char *) "bmp", NULL
5372 };
5373
5374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_CopyFromBitmap",kwnames,&obj0,&obj1)) goto fail;
5375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5376 if (SWIG_arg_fail(1)) SWIG_fail;
5377 {
5378 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5379 if (SWIG_arg_fail(2)) SWIG_fail;
5380 if (arg2 == NULL) {
5381 SWIG_null_ref("wxBitmap");
5382 }
5383 if (SWIG_arg_fail(2)) SWIG_fail;
5384 }
5385 {
5386 PyThreadState* __tstate = wxPyBeginAllowThreads();
5387 (arg1)->CopyFromBitmap((wxBitmap const &)*arg2);
5388
5389 wxPyEndAllowThreads(__tstate);
5390 if (PyErr_Occurred()) SWIG_fail;
5391 }
5392 Py_INCREF(Py_None); resultobj = Py_None;
5393 return resultobj;
5394 fail:
5395 return NULL;
5396 }
5397
5398
5399 static PyObject * Icon_swigregister(PyObject *, PyObject *args) {
5400 PyObject *obj;
5401 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5402 SWIG_TypeClientData(SWIGTYPE_p_wxIcon, obj);
5403 Py_INCREF(obj);
5404 return Py_BuildValue((char *)"");
5405 }
5406 static PyObject *_wrap_new_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5407 PyObject *resultobj;
5408 wxString *arg1 = (wxString *) &wxPyEmptyString ;
5409 int arg2 = (int) 0 ;
5410 wxIconLocation *result;
5411 bool temp1 = false ;
5412 PyObject * obj0 = 0 ;
5413 PyObject * obj1 = 0 ;
5414 char *kwnames[] = {
5415 (char *) "filename",(char *) "num", NULL
5416 };
5417
5418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconLocation",kwnames,&obj0,&obj1)) goto fail;
5419 if (obj0) {
5420 {
5421 arg1 = wxString_in_helper(obj0);
5422 if (arg1 == NULL) SWIG_fail;
5423 temp1 = true;
5424 }
5425 }
5426 if (obj1) {
5427 {
5428 arg2 = (int)(SWIG_As_int(obj1));
5429 if (SWIG_arg_fail(2)) SWIG_fail;
5430 }
5431 }
5432 {
5433 PyThreadState* __tstate = wxPyBeginAllowThreads();
5434 result = (wxIconLocation *)new_wxIconLocation((wxString const *)arg1,arg2);
5435
5436 wxPyEndAllowThreads(__tstate);
5437 if (PyErr_Occurred()) SWIG_fail;
5438 }
5439 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconLocation, 1);
5440 {
5441 if (temp1)
5442 delete arg1;
5443 }
5444 return resultobj;
5445 fail:
5446 {
5447 if (temp1)
5448 delete arg1;
5449 }
5450 return NULL;
5451 }
5452
5453
5454 static PyObject *_wrap_delete_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5455 PyObject *resultobj;
5456 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5457 PyObject * obj0 = 0 ;
5458 char *kwnames[] = {
5459 (char *) "self", NULL
5460 };
5461
5462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconLocation",kwnames,&obj0)) goto fail;
5463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5464 if (SWIG_arg_fail(1)) SWIG_fail;
5465 {
5466 PyThreadState* __tstate = wxPyBeginAllowThreads();
5467 delete arg1;
5468
5469 wxPyEndAllowThreads(__tstate);
5470 if (PyErr_Occurred()) SWIG_fail;
5471 }
5472 Py_INCREF(Py_None); resultobj = Py_None;
5473 return resultobj;
5474 fail:
5475 return NULL;
5476 }
5477
5478
5479 static PyObject *_wrap_IconLocation_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
5480 PyObject *resultobj;
5481 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5482 bool result;
5483 PyObject * obj0 = 0 ;
5484 char *kwnames[] = {
5485 (char *) "self", NULL
5486 };
5487
5488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_IsOk",kwnames,&obj0)) goto fail;
5489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5490 if (SWIG_arg_fail(1)) SWIG_fail;
5491 {
5492 PyThreadState* __tstate = wxPyBeginAllowThreads();
5493 result = (bool)((wxIconLocation const *)arg1)->IsOk();
5494
5495 wxPyEndAllowThreads(__tstate);
5496 if (PyErr_Occurred()) SWIG_fail;
5497 }
5498 {
5499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5500 }
5501 return resultobj;
5502 fail:
5503 return NULL;
5504 }
5505
5506
5507 static PyObject *_wrap_IconLocation_SetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5508 PyObject *resultobj;
5509 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5510 wxString *arg2 = 0 ;
5511 bool temp2 = false ;
5512 PyObject * obj0 = 0 ;
5513 PyObject * obj1 = 0 ;
5514 char *kwnames[] = {
5515 (char *) "self",(char *) "filename", NULL
5516 };
5517
5518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetFileName",kwnames,&obj0,&obj1)) goto fail;
5519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5520 if (SWIG_arg_fail(1)) SWIG_fail;
5521 {
5522 arg2 = wxString_in_helper(obj1);
5523 if (arg2 == NULL) SWIG_fail;
5524 temp2 = true;
5525 }
5526 {
5527 PyThreadState* __tstate = wxPyBeginAllowThreads();
5528 (arg1)->SetFileName((wxString const &)*arg2);
5529
5530 wxPyEndAllowThreads(__tstate);
5531 if (PyErr_Occurred()) SWIG_fail;
5532 }
5533 Py_INCREF(Py_None); resultobj = Py_None;
5534 {
5535 if (temp2)
5536 delete arg2;
5537 }
5538 return resultobj;
5539 fail:
5540 {
5541 if (temp2)
5542 delete arg2;
5543 }
5544 return NULL;
5545 }
5546
5547
5548 static PyObject *_wrap_IconLocation_GetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5549 PyObject *resultobj;
5550 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5551 wxString *result;
5552 PyObject * obj0 = 0 ;
5553 char *kwnames[] = {
5554 (char *) "self", NULL
5555 };
5556
5557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetFileName",kwnames,&obj0)) goto fail;
5558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5559 if (SWIG_arg_fail(1)) SWIG_fail;
5560 {
5561 PyThreadState* __tstate = wxPyBeginAllowThreads();
5562 {
5563 wxString const &_result_ref = ((wxIconLocation const *)arg1)->GetFileName();
5564 result = (wxString *) &_result_ref;
5565 }
5566
5567 wxPyEndAllowThreads(__tstate);
5568 if (PyErr_Occurred()) SWIG_fail;
5569 }
5570 {
5571 #if wxUSE_UNICODE
5572 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
5573 #else
5574 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
5575 #endif
5576 }
5577 return resultobj;
5578 fail:
5579 return NULL;
5580 }
5581
5582
5583 static PyObject *_wrap_IconLocation_SetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5584 PyObject *resultobj;
5585 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5586 int arg2 ;
5587 PyObject * obj0 = 0 ;
5588 PyObject * obj1 = 0 ;
5589 char *kwnames[] = {
5590 (char *) "self",(char *) "num", NULL
5591 };
5592
5593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetIndex",kwnames,&obj0,&obj1)) goto fail;
5594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5595 if (SWIG_arg_fail(1)) SWIG_fail;
5596 {
5597 arg2 = (int)(SWIG_As_int(obj1));
5598 if (SWIG_arg_fail(2)) SWIG_fail;
5599 }
5600 {
5601 PyThreadState* __tstate = wxPyBeginAllowThreads();
5602 wxIconLocation_SetIndex(arg1,arg2);
5603
5604 wxPyEndAllowThreads(__tstate);
5605 if (PyErr_Occurred()) SWIG_fail;
5606 }
5607 Py_INCREF(Py_None); resultobj = Py_None;
5608 return resultobj;
5609 fail:
5610 return NULL;
5611 }
5612
5613
5614 static PyObject *_wrap_IconLocation_GetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5615 PyObject *resultobj;
5616 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5617 int result;
5618 PyObject * obj0 = 0 ;
5619 char *kwnames[] = {
5620 (char *) "self", NULL
5621 };
5622
5623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetIndex",kwnames,&obj0)) goto fail;
5624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5625 if (SWIG_arg_fail(1)) SWIG_fail;
5626 {
5627 PyThreadState* __tstate = wxPyBeginAllowThreads();
5628 result = (int)wxIconLocation_GetIndex(arg1);
5629
5630 wxPyEndAllowThreads(__tstate);
5631 if (PyErr_Occurred()) SWIG_fail;
5632 }
5633 {
5634 resultobj = SWIG_From_int((int)(result));
5635 }
5636 return resultobj;
5637 fail:
5638 return NULL;
5639 }
5640
5641
5642 static PyObject * IconLocation_swigregister(PyObject *, PyObject *args) {
5643 PyObject *obj;
5644 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5645 SWIG_TypeClientData(SWIGTYPE_p_wxIconLocation, obj);
5646 Py_INCREF(obj);
5647 return Py_BuildValue((char *)"");
5648 }
5649 static PyObject *_wrap_new_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
5650 PyObject *resultobj;
5651 wxIconBundle *result;
5652 char *kwnames[] = {
5653 NULL
5654 };
5655
5656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IconBundle",kwnames)) goto fail;
5657 {
5658 PyThreadState* __tstate = wxPyBeginAllowThreads();
5659 result = (wxIconBundle *)new wxIconBundle();
5660
5661 wxPyEndAllowThreads(__tstate);
5662 if (PyErr_Occurred()) SWIG_fail;
5663 }
5664 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5665 return resultobj;
5666 fail:
5667 return NULL;
5668 }
5669
5670
5671 static PyObject *_wrap_new_IconBundleFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
5672 PyObject *resultobj;
5673 wxString *arg1 = 0 ;
5674 long arg2 ;
5675 wxIconBundle *result;
5676 bool temp1 = false ;
5677 PyObject * obj0 = 0 ;
5678 PyObject * obj1 = 0 ;
5679 char *kwnames[] = {
5680 (char *) "file",(char *) "type", NULL
5681 };
5682
5683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_IconBundleFromFile",kwnames,&obj0,&obj1)) goto fail;
5684 {
5685 arg1 = wxString_in_helper(obj0);
5686 if (arg1 == NULL) SWIG_fail;
5687 temp1 = true;
5688 }
5689 {
5690 arg2 = (long)(SWIG_As_long(obj1));
5691 if (SWIG_arg_fail(2)) SWIG_fail;
5692 }
5693 {
5694 PyThreadState* __tstate = wxPyBeginAllowThreads();
5695 result = (wxIconBundle *)new wxIconBundle((wxString const &)*arg1,arg2);
5696
5697 wxPyEndAllowThreads(__tstate);
5698 if (PyErr_Occurred()) SWIG_fail;
5699 }
5700 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5701 {
5702 if (temp1)
5703 delete arg1;
5704 }
5705 return resultobj;
5706 fail:
5707 {
5708 if (temp1)
5709 delete arg1;
5710 }
5711 return NULL;
5712 }
5713
5714
5715 static PyObject *_wrap_new_IconBundleFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5716 PyObject *resultobj;
5717 wxIcon *arg1 = 0 ;
5718 wxIconBundle *result;
5719 PyObject * obj0 = 0 ;
5720 char *kwnames[] = {
5721 (char *) "icon", NULL
5722 };
5723
5724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconBundleFromIcon",kwnames,&obj0)) goto fail;
5725 {
5726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5727 if (SWIG_arg_fail(1)) SWIG_fail;
5728 if (arg1 == NULL) {
5729 SWIG_null_ref("wxIcon");
5730 }
5731 if (SWIG_arg_fail(1)) SWIG_fail;
5732 }
5733 {
5734 PyThreadState* __tstate = wxPyBeginAllowThreads();
5735 result = (wxIconBundle *)new wxIconBundle((wxIcon const &)*arg1);
5736
5737 wxPyEndAllowThreads(__tstate);
5738 if (PyErr_Occurred()) SWIG_fail;
5739 }
5740 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5741 return resultobj;
5742 fail:
5743 return NULL;
5744 }
5745
5746
5747 static PyObject *_wrap_delete_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
5748 PyObject *resultobj;
5749 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5750 PyObject * obj0 = 0 ;
5751 char *kwnames[] = {
5752 (char *) "self", NULL
5753 };
5754
5755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconBundle",kwnames,&obj0)) goto fail;
5756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5757 if (SWIG_arg_fail(1)) SWIG_fail;
5758 {
5759 PyThreadState* __tstate = wxPyBeginAllowThreads();
5760 delete arg1;
5761
5762 wxPyEndAllowThreads(__tstate);
5763 if (PyErr_Occurred()) SWIG_fail;
5764 }
5765 Py_INCREF(Py_None); resultobj = Py_None;
5766 return resultobj;
5767 fail:
5768 return NULL;
5769 }
5770
5771
5772 static PyObject *_wrap_IconBundle_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5773 PyObject *resultobj;
5774 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5775 wxIcon *arg2 = 0 ;
5776 PyObject * obj0 = 0 ;
5777 PyObject * obj1 = 0 ;
5778 char *kwnames[] = {
5779 (char *) "self",(char *) "icon", NULL
5780 };
5781
5782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_AddIcon",kwnames,&obj0,&obj1)) goto fail;
5783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5784 if (SWIG_arg_fail(1)) SWIG_fail;
5785 {
5786 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5787 if (SWIG_arg_fail(2)) SWIG_fail;
5788 if (arg2 == NULL) {
5789 SWIG_null_ref("wxIcon");
5790 }
5791 if (SWIG_arg_fail(2)) SWIG_fail;
5792 }
5793 {
5794 PyThreadState* __tstate = wxPyBeginAllowThreads();
5795 (arg1)->AddIcon((wxIcon const &)*arg2);
5796
5797 wxPyEndAllowThreads(__tstate);
5798 if (PyErr_Occurred()) SWIG_fail;
5799 }
5800 Py_INCREF(Py_None); resultobj = Py_None;
5801 return resultobj;
5802 fail:
5803 return NULL;
5804 }
5805
5806
5807 static PyObject *_wrap_IconBundle_AddIconFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
5808 PyObject *resultobj;
5809 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5810 wxString *arg2 = 0 ;
5811 long arg3 ;
5812 bool temp2 = false ;
5813 PyObject * obj0 = 0 ;
5814 PyObject * obj1 = 0 ;
5815 PyObject * obj2 = 0 ;
5816 char *kwnames[] = {
5817 (char *) "self",(char *) "file",(char *) "type", NULL
5818 };
5819
5820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IconBundle_AddIconFromFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
5821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5822 if (SWIG_arg_fail(1)) SWIG_fail;
5823 {
5824 arg2 = wxString_in_helper(obj1);
5825 if (arg2 == NULL) SWIG_fail;
5826 temp2 = true;
5827 }
5828 {
5829 arg3 = (long)(SWIG_As_long(obj2));
5830 if (SWIG_arg_fail(3)) SWIG_fail;
5831 }
5832 {
5833 PyThreadState* __tstate = wxPyBeginAllowThreads();
5834 (arg1)->AddIcon((wxString const &)*arg2,arg3);
5835
5836 wxPyEndAllowThreads(__tstate);
5837 if (PyErr_Occurred()) SWIG_fail;
5838 }
5839 Py_INCREF(Py_None); resultobj = Py_None;
5840 {
5841 if (temp2)
5842 delete arg2;
5843 }
5844 return resultobj;
5845 fail:
5846 {
5847 if (temp2)
5848 delete arg2;
5849 }
5850 return NULL;
5851 }
5852
5853
5854 static PyObject *_wrap_IconBundle_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5855 PyObject *resultobj;
5856 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5857 wxSize *arg2 = 0 ;
5858 wxIcon *result;
5859 wxSize temp2 ;
5860 PyObject * obj0 = 0 ;
5861 PyObject * obj1 = 0 ;
5862 char *kwnames[] = {
5863 (char *) "self",(char *) "size", NULL
5864 };
5865
5866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_GetIcon",kwnames,&obj0,&obj1)) goto fail;
5867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5868 if (SWIG_arg_fail(1)) SWIG_fail;
5869 {
5870 arg2 = &temp2;
5871 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5872 }
5873 {
5874 PyThreadState* __tstate = wxPyBeginAllowThreads();
5875 {
5876 wxIcon const &_result_ref = ((wxIconBundle const *)arg1)->GetIcon((wxSize const &)*arg2);
5877 result = (wxIcon *) &_result_ref;
5878 }
5879
5880 wxPyEndAllowThreads(__tstate);
5881 if (PyErr_Occurred()) SWIG_fail;
5882 }
5883 {
5884 wxIcon* resultptr = new wxIcon(*result);
5885 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxIcon, 1);
5886 }
5887 return resultobj;
5888 fail:
5889 return NULL;
5890 }
5891
5892
5893 static PyObject * IconBundle_swigregister(PyObject *, PyObject *args) {
5894 PyObject *obj;
5895 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5896 SWIG_TypeClientData(SWIGTYPE_p_wxIconBundle, obj);
5897 Py_INCREF(obj);
5898 return Py_BuildValue((char *)"");
5899 }
5900 static PyObject *_wrap_new_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
5901 PyObject *resultobj;
5902 wxString *arg1 = 0 ;
5903 long arg2 ;
5904 int arg3 = (int) 0 ;
5905 int arg4 = (int) 0 ;
5906 wxCursor *result;
5907 bool temp1 = false ;
5908 PyObject * obj0 = 0 ;
5909 PyObject * obj1 = 0 ;
5910 PyObject * obj2 = 0 ;
5911 PyObject * obj3 = 0 ;
5912 char *kwnames[] = {
5913 (char *) "cursorName",(char *) "type",(char *) "hotSpotX",(char *) "hotSpotY", NULL
5914 };
5915
5916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Cursor",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5917 {
5918 arg1 = wxString_in_helper(obj0);
5919 if (arg1 == NULL) SWIG_fail;
5920 temp1 = true;
5921 }
5922 {
5923 arg2 = (long)(SWIG_As_long(obj1));
5924 if (SWIG_arg_fail(2)) SWIG_fail;
5925 }
5926 if (obj2) {
5927 {
5928 arg3 = (int)(SWIG_As_int(obj2));
5929 if (SWIG_arg_fail(3)) SWIG_fail;
5930 }
5931 }
5932 if (obj3) {
5933 {
5934 arg4 = (int)(SWIG_As_int(obj3));
5935 if (SWIG_arg_fail(4)) SWIG_fail;
5936 }
5937 }
5938 {
5939 if (!wxPyCheckForApp()) SWIG_fail;
5940 PyThreadState* __tstate = wxPyBeginAllowThreads();
5941 result = (wxCursor *)new_wxCursor((wxString const &)*arg1,arg2,arg3,arg4);
5942
5943 wxPyEndAllowThreads(__tstate);
5944 if (PyErr_Occurred()) SWIG_fail;
5945 }
5946 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
5947 {
5948 if (temp1)
5949 delete arg1;
5950 }
5951 return resultobj;
5952 fail:
5953 {
5954 if (temp1)
5955 delete arg1;
5956 }
5957 return NULL;
5958 }
5959
5960
5961 static PyObject *_wrap_delete_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
5962 PyObject *resultobj;
5963 wxCursor *arg1 = (wxCursor *) 0 ;
5964 PyObject * obj0 = 0 ;
5965 char *kwnames[] = {
5966 (char *) "self", NULL
5967 };
5968
5969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Cursor",kwnames,&obj0)) goto fail;
5970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5971 if (SWIG_arg_fail(1)) SWIG_fail;
5972 {
5973 PyThreadState* __tstate = wxPyBeginAllowThreads();
5974 delete arg1;
5975
5976 wxPyEndAllowThreads(__tstate);
5977 if (PyErr_Occurred()) SWIG_fail;
5978 }
5979 Py_INCREF(Py_None); resultobj = Py_None;
5980 return resultobj;
5981 fail:
5982 return NULL;
5983 }
5984
5985
5986 static PyObject *_wrap_new_StockCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5987 PyObject *resultobj;
5988 int arg1 ;
5989 wxCursor *result;
5990 PyObject * obj0 = 0 ;
5991 char *kwnames[] = {
5992 (char *) "id", NULL
5993 };
5994
5995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_StockCursor",kwnames,&obj0)) goto fail;
5996 {
5997 arg1 = (int)(SWIG_As_int(obj0));
5998 if (SWIG_arg_fail(1)) SWIG_fail;
5999 }
6000 {
6001 if (!wxPyCheckForApp()) SWIG_fail;
6002 PyThreadState* __tstate = wxPyBeginAllowThreads();
6003 result = (wxCursor *)new wxCursor(arg1);
6004
6005 wxPyEndAllowThreads(__tstate);
6006 if (PyErr_Occurred()) SWIG_fail;
6007 }
6008 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6009 return resultobj;
6010 fail:
6011 return NULL;
6012 }
6013
6014
6015 static PyObject *_wrap_new_CursorFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
6016 PyObject *resultobj;
6017 wxImage *arg1 = 0 ;
6018 wxCursor *result;
6019 PyObject * obj0 = 0 ;
6020 char *kwnames[] = {
6021 (char *) "image", NULL
6022 };
6023
6024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CursorFromImage",kwnames,&obj0)) goto fail;
6025 {
6026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
6027 if (SWIG_arg_fail(1)) SWIG_fail;
6028 if (arg1 == NULL) {
6029 SWIG_null_ref("wxImage");
6030 }
6031 if (SWIG_arg_fail(1)) SWIG_fail;
6032 }
6033 {
6034 if (!wxPyCheckForApp()) SWIG_fail;
6035 PyThreadState* __tstate = wxPyBeginAllowThreads();
6036 result = (wxCursor *)new wxCursor((wxImage const &)*arg1);
6037
6038 wxPyEndAllowThreads(__tstate);
6039 if (PyErr_Occurred()) SWIG_fail;
6040 }
6041 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6042 return resultobj;
6043 fail:
6044 return NULL;
6045 }
6046
6047
6048 static PyObject *_wrap_Cursor_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
6049 PyObject *resultobj;
6050 wxCursor *arg1 = (wxCursor *) 0 ;
6051 bool result;
6052 PyObject * obj0 = 0 ;
6053 char *kwnames[] = {
6054 (char *) "self", NULL
6055 };
6056
6057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_Ok",kwnames,&obj0)) goto fail;
6058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6059 if (SWIG_arg_fail(1)) SWIG_fail;
6060 {
6061 PyThreadState* __tstate = wxPyBeginAllowThreads();
6062 result = (bool)(arg1)->Ok();
6063
6064 wxPyEndAllowThreads(__tstate);
6065 if (PyErr_Occurred()) SWIG_fail;
6066 }
6067 {
6068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6069 }
6070 return resultobj;
6071 fail:
6072 return NULL;
6073 }
6074
6075
6076 static PyObject * Cursor_swigregister(PyObject *, PyObject *args) {
6077 PyObject *obj;
6078 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6079 SWIG_TypeClientData(SWIGTYPE_p_wxCursor, obj);
6080 Py_INCREF(obj);
6081 return Py_BuildValue((char *)"");
6082 }
6083 static PyObject *_wrap_new_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6084 PyObject *resultobj;
6085 int arg1 = (int) 0 ;
6086 int arg2 = (int) 0 ;
6087 int arg3 = (int) 0 ;
6088 int arg4 = (int) 0 ;
6089 wxRegion *result;
6090 PyObject * obj0 = 0 ;
6091 PyObject * obj1 = 0 ;
6092 PyObject * obj2 = 0 ;
6093 PyObject * obj3 = 0 ;
6094 char *kwnames[] = {
6095 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6096 };
6097
6098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Region",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6099 if (obj0) {
6100 {
6101 arg1 = (int)(SWIG_As_int(obj0));
6102 if (SWIG_arg_fail(1)) SWIG_fail;
6103 }
6104 }
6105 if (obj1) {
6106 {
6107 arg2 = (int)(SWIG_As_int(obj1));
6108 if (SWIG_arg_fail(2)) SWIG_fail;
6109 }
6110 }
6111 if (obj2) {
6112 {
6113 arg3 = (int)(SWIG_As_int(obj2));
6114 if (SWIG_arg_fail(3)) SWIG_fail;
6115 }
6116 }
6117 if (obj3) {
6118 {
6119 arg4 = (int)(SWIG_As_int(obj3));
6120 if (SWIG_arg_fail(4)) SWIG_fail;
6121 }
6122 }
6123 {
6124 if (!wxPyCheckForApp()) SWIG_fail;
6125 PyThreadState* __tstate = wxPyBeginAllowThreads();
6126 result = (wxRegion *)new wxRegion(arg1,arg2,arg3,arg4);
6127
6128 wxPyEndAllowThreads(__tstate);
6129 if (PyErr_Occurred()) SWIG_fail;
6130 }
6131 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6132 return resultobj;
6133 fail:
6134 return NULL;
6135 }
6136
6137
6138 static PyObject *_wrap_new_RegionFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
6139 PyObject *resultobj;
6140 wxBitmap *arg1 = 0 ;
6141 wxRegion *result;
6142 PyObject * obj0 = 0 ;
6143 char *kwnames[] = {
6144 (char *) "bmp", NULL
6145 };
6146
6147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionFromBitmap",kwnames,&obj0)) goto fail;
6148 {
6149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6150 if (SWIG_arg_fail(1)) SWIG_fail;
6151 if (arg1 == NULL) {
6152 SWIG_null_ref("wxBitmap");
6153 }
6154 if (SWIG_arg_fail(1)) SWIG_fail;
6155 }
6156 {
6157 if (!wxPyCheckForApp()) SWIG_fail;
6158 PyThreadState* __tstate = wxPyBeginAllowThreads();
6159 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1);
6160
6161 wxPyEndAllowThreads(__tstate);
6162 if (PyErr_Occurred()) SWIG_fail;
6163 }
6164 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6165 return resultobj;
6166 fail:
6167 return NULL;
6168 }
6169
6170
6171 static PyObject *_wrap_new_RegionFromBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
6172 PyObject *resultobj;
6173 wxBitmap *arg1 = 0 ;
6174 wxColour *arg2 = 0 ;
6175 int arg3 = (int) 0 ;
6176 wxRegion *result;
6177 wxColour temp2 ;
6178 PyObject * obj0 = 0 ;
6179 PyObject * obj1 = 0 ;
6180 PyObject * obj2 = 0 ;
6181 char *kwnames[] = {
6182 (char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
6183 };
6184
6185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_RegionFromBitmapColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
6186 {
6187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6188 if (SWIG_arg_fail(1)) SWIG_fail;
6189 if (arg1 == NULL) {
6190 SWIG_null_ref("wxBitmap");
6191 }
6192 if (SWIG_arg_fail(1)) SWIG_fail;
6193 }
6194 {
6195 arg2 = &temp2;
6196 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6197 }
6198 if (obj2) {
6199 {
6200 arg3 = (int)(SWIG_As_int(obj2));
6201 if (SWIG_arg_fail(3)) SWIG_fail;
6202 }
6203 }
6204 {
6205 if (!wxPyCheckForApp()) SWIG_fail;
6206 PyThreadState* __tstate = wxPyBeginAllowThreads();
6207 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1,(wxColour const &)*arg2,arg3);
6208
6209 wxPyEndAllowThreads(__tstate);
6210 if (PyErr_Occurred()) SWIG_fail;
6211 }
6212 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6213 return resultobj;
6214 fail:
6215 return NULL;
6216 }
6217
6218
6219 static PyObject *_wrap_new_RegionFromPoints(PyObject *, PyObject *args, PyObject *kwargs) {
6220 PyObject *resultobj;
6221 int arg1 ;
6222 wxPoint *arg2 = (wxPoint *) 0 ;
6223 int arg3 = (int) wxWINDING_RULE ;
6224 wxRegion *result;
6225 PyObject * obj0 = 0 ;
6226 PyObject * obj1 = 0 ;
6227 char *kwnames[] = {
6228 (char *) "points",(char *) "fillStyle", NULL
6229 };
6230
6231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_RegionFromPoints",kwnames,&obj0,&obj1)) goto fail;
6232 {
6233 arg2 = wxPoint_LIST_helper(obj0, &arg1);
6234 if (arg2 == NULL) SWIG_fail;
6235 }
6236 if (obj1) {
6237 {
6238 arg3 = (int)(SWIG_As_int(obj1));
6239 if (SWIG_arg_fail(3)) SWIG_fail;
6240 }
6241 }
6242 {
6243 if (!wxPyCheckForApp()) SWIG_fail;
6244 PyThreadState* __tstate = wxPyBeginAllowThreads();
6245 result = (wxRegion *)new wxRegion(arg1,arg2,arg3);
6246
6247 wxPyEndAllowThreads(__tstate);
6248 if (PyErr_Occurred()) SWIG_fail;
6249 }
6250 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6251 {
6252 if (arg2) delete [] arg2;
6253 }
6254 return resultobj;
6255 fail:
6256 {
6257 if (arg2) delete [] arg2;
6258 }
6259 return NULL;
6260 }
6261
6262
6263 static PyObject *_wrap_delete_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6264 PyObject *resultobj;
6265 wxRegion *arg1 = (wxRegion *) 0 ;
6266 PyObject * obj0 = 0 ;
6267 char *kwnames[] = {
6268 (char *) "self", NULL
6269 };
6270
6271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Region",kwnames,&obj0)) goto fail;
6272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6273 if (SWIG_arg_fail(1)) SWIG_fail;
6274 {
6275 PyThreadState* __tstate = wxPyBeginAllowThreads();
6276 delete arg1;
6277
6278 wxPyEndAllowThreads(__tstate);
6279 if (PyErr_Occurred()) SWIG_fail;
6280 }
6281 Py_INCREF(Py_None); resultobj = Py_None;
6282 return resultobj;
6283 fail:
6284 return NULL;
6285 }
6286
6287
6288 static PyObject *_wrap_Region_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
6289 PyObject *resultobj;
6290 wxRegion *arg1 = (wxRegion *) 0 ;
6291 PyObject * obj0 = 0 ;
6292 char *kwnames[] = {
6293 (char *) "self", NULL
6294 };
6295
6296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_Clear",kwnames,&obj0)) goto fail;
6297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6298 if (SWIG_arg_fail(1)) SWIG_fail;
6299 {
6300 PyThreadState* __tstate = wxPyBeginAllowThreads();
6301 (arg1)->Clear();
6302
6303 wxPyEndAllowThreads(__tstate);
6304 if (PyErr_Occurred()) SWIG_fail;
6305 }
6306 Py_INCREF(Py_None); resultobj = Py_None;
6307 return resultobj;
6308 fail:
6309 return NULL;
6310 }
6311
6312
6313 static PyObject *_wrap_Region_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
6314 PyObject *resultobj;
6315 wxRegion *arg1 = (wxRegion *) 0 ;
6316 int arg2 ;
6317 int arg3 ;
6318 bool result;
6319 PyObject * obj0 = 0 ;
6320 PyObject * obj1 = 0 ;
6321 PyObject * obj2 = 0 ;
6322 char *kwnames[] = {
6323 (char *) "self",(char *) "x",(char *) "y", NULL
6324 };
6325
6326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Offset",kwnames,&obj0,&obj1,&obj2)) goto fail;
6327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6328 if (SWIG_arg_fail(1)) SWIG_fail;
6329 {
6330 arg2 = (int)(SWIG_As_int(obj1));
6331 if (SWIG_arg_fail(2)) SWIG_fail;
6332 }
6333 {
6334 arg3 = (int)(SWIG_As_int(obj2));
6335 if (SWIG_arg_fail(3)) SWIG_fail;
6336 }
6337 {
6338 PyThreadState* __tstate = wxPyBeginAllowThreads();
6339 result = (bool)(arg1)->Offset(arg2,arg3);
6340
6341 wxPyEndAllowThreads(__tstate);
6342 if (PyErr_Occurred()) SWIG_fail;
6343 }
6344 {
6345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6346 }
6347 return resultobj;
6348 fail:
6349 return NULL;
6350 }
6351
6352
6353 static PyObject *_wrap_Region_Contains(PyObject *, PyObject *args, PyObject *kwargs) {
6354 PyObject *resultobj;
6355 wxRegion *arg1 = (wxRegion *) 0 ;
6356 int arg2 ;
6357 int arg3 ;
6358 wxRegionContain result;
6359 PyObject * obj0 = 0 ;
6360 PyObject * obj1 = 0 ;
6361 PyObject * obj2 = 0 ;
6362 char *kwnames[] = {
6363 (char *) "self",(char *) "x",(char *) "y", NULL
6364 };
6365
6366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Contains",kwnames,&obj0,&obj1,&obj2)) goto fail;
6367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6368 if (SWIG_arg_fail(1)) SWIG_fail;
6369 {
6370 arg2 = (int)(SWIG_As_int(obj1));
6371 if (SWIG_arg_fail(2)) SWIG_fail;
6372 }
6373 {
6374 arg3 = (int)(SWIG_As_int(obj2));
6375 if (SWIG_arg_fail(3)) SWIG_fail;
6376 }
6377 {
6378 PyThreadState* __tstate = wxPyBeginAllowThreads();
6379 result = (wxRegionContain)(arg1)->Contains(arg2,arg3);
6380
6381 wxPyEndAllowThreads(__tstate);
6382 if (PyErr_Occurred()) SWIG_fail;
6383 }
6384 resultobj = SWIG_From_int((result));
6385 return resultobj;
6386 fail:
6387 return NULL;
6388 }
6389
6390
6391 static PyObject *_wrap_Region_ContainsPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6392 PyObject *resultobj;
6393 wxRegion *arg1 = (wxRegion *) 0 ;
6394 wxPoint *arg2 = 0 ;
6395 wxRegionContain result;
6396 wxPoint temp2 ;
6397 PyObject * obj0 = 0 ;
6398 PyObject * obj1 = 0 ;
6399 char *kwnames[] = {
6400 (char *) "self",(char *) "pt", NULL
6401 };
6402
6403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsPoint",kwnames,&obj0,&obj1)) goto fail;
6404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6405 if (SWIG_arg_fail(1)) SWIG_fail;
6406 {
6407 arg2 = &temp2;
6408 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6409 }
6410 {
6411 PyThreadState* __tstate = wxPyBeginAllowThreads();
6412 result = (wxRegionContain)(arg1)->Contains((wxPoint const &)*arg2);
6413
6414 wxPyEndAllowThreads(__tstate);
6415 if (PyErr_Occurred()) SWIG_fail;
6416 }
6417 resultobj = SWIG_From_int((result));
6418 return resultobj;
6419 fail:
6420 return NULL;
6421 }
6422
6423
6424 static PyObject *_wrap_Region_ContainsRect(PyObject *, PyObject *args, PyObject *kwargs) {
6425 PyObject *resultobj;
6426 wxRegion *arg1 = (wxRegion *) 0 ;
6427 wxRect *arg2 = 0 ;
6428 wxRegionContain result;
6429 wxRect temp2 ;
6430 PyObject * obj0 = 0 ;
6431 PyObject * obj1 = 0 ;
6432 char *kwnames[] = {
6433 (char *) "self",(char *) "rect", NULL
6434 };
6435
6436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsRect",kwnames,&obj0,&obj1)) goto fail;
6437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6438 if (SWIG_arg_fail(1)) SWIG_fail;
6439 {
6440 arg2 = &temp2;
6441 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6442 }
6443 {
6444 PyThreadState* __tstate = wxPyBeginAllowThreads();
6445 result = (wxRegionContain)(arg1)->Contains((wxRect const &)*arg2);
6446
6447 wxPyEndAllowThreads(__tstate);
6448 if (PyErr_Occurred()) SWIG_fail;
6449 }
6450 resultobj = SWIG_From_int((result));
6451 return resultobj;
6452 fail:
6453 return NULL;
6454 }
6455
6456
6457 static PyObject *_wrap_Region_ContainsRectDim(PyObject *, PyObject *args, PyObject *kwargs) {
6458 PyObject *resultobj;
6459 wxRegion *arg1 = (wxRegion *) 0 ;
6460 int arg2 ;
6461 int arg3 ;
6462 int arg4 ;
6463 int arg5 ;
6464 wxRegionContain result;
6465 PyObject * obj0 = 0 ;
6466 PyObject * obj1 = 0 ;
6467 PyObject * obj2 = 0 ;
6468 PyObject * obj3 = 0 ;
6469 PyObject * obj4 = 0 ;
6470 char *kwnames[] = {
6471 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
6472 };
6473
6474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_ContainsRectDim",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6476 if (SWIG_arg_fail(1)) SWIG_fail;
6477 {
6478 arg2 = (int)(SWIG_As_int(obj1));
6479 if (SWIG_arg_fail(2)) SWIG_fail;
6480 }
6481 {
6482 arg3 = (int)(SWIG_As_int(obj2));
6483 if (SWIG_arg_fail(3)) SWIG_fail;
6484 }
6485 {
6486 arg4 = (int)(SWIG_As_int(obj3));
6487 if (SWIG_arg_fail(4)) SWIG_fail;
6488 }
6489 {
6490 arg5 = (int)(SWIG_As_int(obj4));
6491 if (SWIG_arg_fail(5)) SWIG_fail;
6492 }
6493 {
6494 PyThreadState* __tstate = wxPyBeginAllowThreads();
6495 result = (wxRegionContain)(arg1)->Contains(arg2,arg3,arg4,arg5);
6496
6497 wxPyEndAllowThreads(__tstate);
6498 if (PyErr_Occurred()) SWIG_fail;
6499 }
6500 resultobj = SWIG_From_int((result));
6501 return resultobj;
6502 fail:
6503 return NULL;
6504 }
6505
6506
6507 static PyObject *_wrap_Region_GetBox(PyObject *, PyObject *args, PyObject *kwargs) {
6508 PyObject *resultobj;
6509 wxRegion *arg1 = (wxRegion *) 0 ;
6510 wxRect result;
6511 PyObject * obj0 = 0 ;
6512 char *kwnames[] = {
6513 (char *) "self", NULL
6514 };
6515
6516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_GetBox",kwnames,&obj0)) goto fail;
6517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6518 if (SWIG_arg_fail(1)) SWIG_fail;
6519 {
6520 PyThreadState* __tstate = wxPyBeginAllowThreads();
6521 result = (arg1)->GetBox();
6522
6523 wxPyEndAllowThreads(__tstate);
6524 if (PyErr_Occurred()) SWIG_fail;
6525 }
6526 {
6527 wxRect * resultptr;
6528 resultptr = new wxRect((wxRect &)(result));
6529 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6530 }
6531 return resultobj;
6532 fail:
6533 return NULL;
6534 }
6535
6536
6537 static PyObject *_wrap_Region_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
6538 PyObject *resultobj;
6539 wxRegion *arg1 = (wxRegion *) 0 ;
6540 int arg2 ;
6541 int arg3 ;
6542 int arg4 ;
6543 int arg5 ;
6544 bool result;
6545 PyObject * obj0 = 0 ;
6546 PyObject * obj1 = 0 ;
6547 PyObject * obj2 = 0 ;
6548 PyObject * obj3 = 0 ;
6549 PyObject * obj4 = 0 ;
6550 char *kwnames[] = {
6551 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6552 };
6553
6554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Intersect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6556 if (SWIG_arg_fail(1)) SWIG_fail;
6557 {
6558 arg2 = (int)(SWIG_As_int(obj1));
6559 if (SWIG_arg_fail(2)) SWIG_fail;
6560 }
6561 {
6562 arg3 = (int)(SWIG_As_int(obj2));
6563 if (SWIG_arg_fail(3)) SWIG_fail;
6564 }
6565 {
6566 arg4 = (int)(SWIG_As_int(obj3));
6567 if (SWIG_arg_fail(4)) SWIG_fail;
6568 }
6569 {
6570 arg5 = (int)(SWIG_As_int(obj4));
6571 if (SWIG_arg_fail(5)) SWIG_fail;
6572 }
6573 {
6574 PyThreadState* __tstate = wxPyBeginAllowThreads();
6575 result = (bool)(arg1)->Intersect(arg2,arg3,arg4,arg5);
6576
6577 wxPyEndAllowThreads(__tstate);
6578 if (PyErr_Occurred()) SWIG_fail;
6579 }
6580 {
6581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6582 }
6583 return resultobj;
6584 fail:
6585 return NULL;
6586 }
6587
6588
6589 static PyObject *_wrap_Region_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6590 PyObject *resultobj;
6591 wxRegion *arg1 = (wxRegion *) 0 ;
6592 wxRect *arg2 = 0 ;
6593 bool result;
6594 wxRect temp2 ;
6595 PyObject * obj0 = 0 ;
6596 PyObject * obj1 = 0 ;
6597 char *kwnames[] = {
6598 (char *) "self",(char *) "rect", NULL
6599 };
6600
6601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6603 if (SWIG_arg_fail(1)) SWIG_fail;
6604 {
6605 arg2 = &temp2;
6606 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6607 }
6608 {
6609 PyThreadState* __tstate = wxPyBeginAllowThreads();
6610 result = (bool)(arg1)->Intersect((wxRect const &)*arg2);
6611
6612 wxPyEndAllowThreads(__tstate);
6613 if (PyErr_Occurred()) SWIG_fail;
6614 }
6615 {
6616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6617 }
6618 return resultobj;
6619 fail:
6620 return NULL;
6621 }
6622
6623
6624 static PyObject *_wrap_Region_IntersectRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6625 PyObject *resultobj;
6626 wxRegion *arg1 = (wxRegion *) 0 ;
6627 wxRegion *arg2 = 0 ;
6628 bool result;
6629 PyObject * obj0 = 0 ;
6630 PyObject * obj1 = 0 ;
6631 char *kwnames[] = {
6632 (char *) "self",(char *) "region", NULL
6633 };
6634
6635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRegion",kwnames,&obj0,&obj1)) goto fail;
6636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6637 if (SWIG_arg_fail(1)) SWIG_fail;
6638 {
6639 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6640 if (SWIG_arg_fail(2)) SWIG_fail;
6641 if (arg2 == NULL) {
6642 SWIG_null_ref("wxRegion");
6643 }
6644 if (SWIG_arg_fail(2)) SWIG_fail;
6645 }
6646 {
6647 PyThreadState* __tstate = wxPyBeginAllowThreads();
6648 result = (bool)(arg1)->Intersect((wxRegion const &)*arg2);
6649
6650 wxPyEndAllowThreads(__tstate);
6651 if (PyErr_Occurred()) SWIG_fail;
6652 }
6653 {
6654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6655 }
6656 return resultobj;
6657 fail:
6658 return NULL;
6659 }
6660
6661
6662 static PyObject *_wrap_Region_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
6663 PyObject *resultobj;
6664 wxRegion *arg1 = (wxRegion *) 0 ;
6665 bool result;
6666 PyObject * obj0 = 0 ;
6667 char *kwnames[] = {
6668 (char *) "self", NULL
6669 };
6670
6671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_IsEmpty",kwnames,&obj0)) goto fail;
6672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6673 if (SWIG_arg_fail(1)) SWIG_fail;
6674 {
6675 PyThreadState* __tstate = wxPyBeginAllowThreads();
6676 result = (bool)(arg1)->IsEmpty();
6677
6678 wxPyEndAllowThreads(__tstate);
6679 if (PyErr_Occurred()) SWIG_fail;
6680 }
6681 {
6682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6683 }
6684 return resultobj;
6685 fail:
6686 return NULL;
6687 }
6688
6689
6690 static PyObject *_wrap_Region_Union(PyObject *, PyObject *args, PyObject *kwargs) {
6691 PyObject *resultobj;
6692 wxRegion *arg1 = (wxRegion *) 0 ;
6693 int arg2 ;
6694 int arg3 ;
6695 int arg4 ;
6696 int arg5 ;
6697 bool result;
6698 PyObject * obj0 = 0 ;
6699 PyObject * obj1 = 0 ;
6700 PyObject * obj2 = 0 ;
6701 PyObject * obj3 = 0 ;
6702 PyObject * obj4 = 0 ;
6703 char *kwnames[] = {
6704 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6705 };
6706
6707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Union",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6709 if (SWIG_arg_fail(1)) SWIG_fail;
6710 {
6711 arg2 = (int)(SWIG_As_int(obj1));
6712 if (SWIG_arg_fail(2)) SWIG_fail;
6713 }
6714 {
6715 arg3 = (int)(SWIG_As_int(obj2));
6716 if (SWIG_arg_fail(3)) SWIG_fail;
6717 }
6718 {
6719 arg4 = (int)(SWIG_As_int(obj3));
6720 if (SWIG_arg_fail(4)) SWIG_fail;
6721 }
6722 {
6723 arg5 = (int)(SWIG_As_int(obj4));
6724 if (SWIG_arg_fail(5)) SWIG_fail;
6725 }
6726 {
6727 PyThreadState* __tstate = wxPyBeginAllowThreads();
6728 result = (bool)(arg1)->Union(arg2,arg3,arg4,arg5);
6729
6730 wxPyEndAllowThreads(__tstate);
6731 if (PyErr_Occurred()) SWIG_fail;
6732 }
6733 {
6734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6735 }
6736 return resultobj;
6737 fail:
6738 return NULL;
6739 }
6740
6741
6742 static PyObject *_wrap_Region_UnionRect(PyObject *, PyObject *args, PyObject *kwargs) {
6743 PyObject *resultobj;
6744 wxRegion *arg1 = (wxRegion *) 0 ;
6745 wxRect *arg2 = 0 ;
6746 bool result;
6747 wxRect temp2 ;
6748 PyObject * obj0 = 0 ;
6749 PyObject * obj1 = 0 ;
6750 char *kwnames[] = {
6751 (char *) "self",(char *) "rect", NULL
6752 };
6753
6754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRect",kwnames,&obj0,&obj1)) goto fail;
6755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6756 if (SWIG_arg_fail(1)) SWIG_fail;
6757 {
6758 arg2 = &temp2;
6759 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6760 }
6761 {
6762 PyThreadState* __tstate = wxPyBeginAllowThreads();
6763 result = (bool)(arg1)->Union((wxRect const &)*arg2);
6764
6765 wxPyEndAllowThreads(__tstate);
6766 if (PyErr_Occurred()) SWIG_fail;
6767 }
6768 {
6769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6770 }
6771 return resultobj;
6772 fail:
6773 return NULL;
6774 }
6775
6776
6777 static PyObject *_wrap_Region_UnionRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6778 PyObject *resultobj;
6779 wxRegion *arg1 = (wxRegion *) 0 ;
6780 wxRegion *arg2 = 0 ;
6781 bool result;
6782 PyObject * obj0 = 0 ;
6783 PyObject * obj1 = 0 ;
6784 char *kwnames[] = {
6785 (char *) "self",(char *) "region", NULL
6786 };
6787
6788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRegion",kwnames,&obj0,&obj1)) goto fail;
6789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6790 if (SWIG_arg_fail(1)) SWIG_fail;
6791 {
6792 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6793 if (SWIG_arg_fail(2)) SWIG_fail;
6794 if (arg2 == NULL) {
6795 SWIG_null_ref("wxRegion");
6796 }
6797 if (SWIG_arg_fail(2)) SWIG_fail;
6798 }
6799 {
6800 PyThreadState* __tstate = wxPyBeginAllowThreads();
6801 result = (bool)(arg1)->Union((wxRegion const &)*arg2);
6802
6803 wxPyEndAllowThreads(__tstate);
6804 if (PyErr_Occurred()) SWIG_fail;
6805 }
6806 {
6807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6808 }
6809 return resultobj;
6810 fail:
6811 return NULL;
6812 }
6813
6814
6815 static PyObject *_wrap_Region_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
6816 PyObject *resultobj;
6817 wxRegion *arg1 = (wxRegion *) 0 ;
6818 int arg2 ;
6819 int arg3 ;
6820 int arg4 ;
6821 int arg5 ;
6822 bool result;
6823 PyObject * obj0 = 0 ;
6824 PyObject * obj1 = 0 ;
6825 PyObject * obj2 = 0 ;
6826 PyObject * obj3 = 0 ;
6827 PyObject * obj4 = 0 ;
6828 char *kwnames[] = {
6829 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6830 };
6831
6832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Subtract",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6834 if (SWIG_arg_fail(1)) SWIG_fail;
6835 {
6836 arg2 = (int)(SWIG_As_int(obj1));
6837 if (SWIG_arg_fail(2)) SWIG_fail;
6838 }
6839 {
6840 arg3 = (int)(SWIG_As_int(obj2));
6841 if (SWIG_arg_fail(3)) SWIG_fail;
6842 }
6843 {
6844 arg4 = (int)(SWIG_As_int(obj3));
6845 if (SWIG_arg_fail(4)) SWIG_fail;
6846 }
6847 {
6848 arg5 = (int)(SWIG_As_int(obj4));
6849 if (SWIG_arg_fail(5)) SWIG_fail;
6850 }
6851 {
6852 PyThreadState* __tstate = wxPyBeginAllowThreads();
6853 result = (bool)(arg1)->Subtract(arg2,arg3,arg4,arg5);
6854
6855 wxPyEndAllowThreads(__tstate);
6856 if (PyErr_Occurred()) SWIG_fail;
6857 }
6858 {
6859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6860 }
6861 return resultobj;
6862 fail:
6863 return NULL;
6864 }
6865
6866
6867 static PyObject *_wrap_Region_SubtractRect(PyObject *, PyObject *args, PyObject *kwargs) {
6868 PyObject *resultobj;
6869 wxRegion *arg1 = (wxRegion *) 0 ;
6870 wxRect *arg2 = 0 ;
6871 bool result;
6872 wxRect temp2 ;
6873 PyObject * obj0 = 0 ;
6874 PyObject * obj1 = 0 ;
6875 char *kwnames[] = {
6876 (char *) "self",(char *) "rect", NULL
6877 };
6878
6879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRect",kwnames,&obj0,&obj1)) goto fail;
6880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6881 if (SWIG_arg_fail(1)) SWIG_fail;
6882 {
6883 arg2 = &temp2;
6884 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6885 }
6886 {
6887 PyThreadState* __tstate = wxPyBeginAllowThreads();
6888 result = (bool)(arg1)->Subtract((wxRect const &)*arg2);
6889
6890 wxPyEndAllowThreads(__tstate);
6891 if (PyErr_Occurred()) SWIG_fail;
6892 }
6893 {
6894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6895 }
6896 return resultobj;
6897 fail:
6898 return NULL;
6899 }
6900
6901
6902 static PyObject *_wrap_Region_SubtractRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6903 PyObject *resultobj;
6904 wxRegion *arg1 = (wxRegion *) 0 ;
6905 wxRegion *arg2 = 0 ;
6906 bool result;
6907 PyObject * obj0 = 0 ;
6908 PyObject * obj1 = 0 ;
6909 char *kwnames[] = {
6910 (char *) "self",(char *) "region", NULL
6911 };
6912
6913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRegion",kwnames,&obj0,&obj1)) goto fail;
6914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6915 if (SWIG_arg_fail(1)) SWIG_fail;
6916 {
6917 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6918 if (SWIG_arg_fail(2)) SWIG_fail;
6919 if (arg2 == NULL) {
6920 SWIG_null_ref("wxRegion");
6921 }
6922 if (SWIG_arg_fail(2)) SWIG_fail;
6923 }
6924 {
6925 PyThreadState* __tstate = wxPyBeginAllowThreads();
6926 result = (bool)(arg1)->Subtract((wxRegion const &)*arg2);
6927
6928 wxPyEndAllowThreads(__tstate);
6929 if (PyErr_Occurred()) SWIG_fail;
6930 }
6931 {
6932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6933 }
6934 return resultobj;
6935 fail:
6936 return NULL;
6937 }
6938
6939
6940 static PyObject *_wrap_Region_Xor(PyObject *, PyObject *args, PyObject *kwargs) {
6941 PyObject *resultobj;
6942 wxRegion *arg1 = (wxRegion *) 0 ;
6943 int arg2 ;
6944 int arg3 ;
6945 int arg4 ;
6946 int arg5 ;
6947 bool result;
6948 PyObject * obj0 = 0 ;
6949 PyObject * obj1 = 0 ;
6950 PyObject * obj2 = 0 ;
6951 PyObject * obj3 = 0 ;
6952 PyObject * obj4 = 0 ;
6953 char *kwnames[] = {
6954 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6955 };
6956
6957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Xor",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6959 if (SWIG_arg_fail(1)) SWIG_fail;
6960 {
6961 arg2 = (int)(SWIG_As_int(obj1));
6962 if (SWIG_arg_fail(2)) SWIG_fail;
6963 }
6964 {
6965 arg3 = (int)(SWIG_As_int(obj2));
6966 if (SWIG_arg_fail(3)) SWIG_fail;
6967 }
6968 {
6969 arg4 = (int)(SWIG_As_int(obj3));
6970 if (SWIG_arg_fail(4)) SWIG_fail;
6971 }
6972 {
6973 arg5 = (int)(SWIG_As_int(obj4));
6974 if (SWIG_arg_fail(5)) SWIG_fail;
6975 }
6976 {
6977 PyThreadState* __tstate = wxPyBeginAllowThreads();
6978 result = (bool)(arg1)->Xor(arg2,arg3,arg4,arg5);
6979
6980 wxPyEndAllowThreads(__tstate);
6981 if (PyErr_Occurred()) SWIG_fail;
6982 }
6983 {
6984 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6985 }
6986 return resultobj;
6987 fail:
6988 return NULL;
6989 }
6990
6991
6992 static PyObject *_wrap_Region_XorRect(PyObject *, PyObject *args, PyObject *kwargs) {
6993 PyObject *resultobj;
6994 wxRegion *arg1 = (wxRegion *) 0 ;
6995 wxRect *arg2 = 0 ;
6996 bool result;
6997 wxRect temp2 ;
6998 PyObject * obj0 = 0 ;
6999 PyObject * obj1 = 0 ;
7000 char *kwnames[] = {
7001 (char *) "self",(char *) "rect", NULL
7002 };
7003
7004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRect",kwnames,&obj0,&obj1)) goto fail;
7005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7006 if (SWIG_arg_fail(1)) SWIG_fail;
7007 {
7008 arg2 = &temp2;
7009 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7010 }
7011 {
7012 PyThreadState* __tstate = wxPyBeginAllowThreads();
7013 result = (bool)(arg1)->Xor((wxRect const &)*arg2);
7014
7015 wxPyEndAllowThreads(__tstate);
7016 if (PyErr_Occurred()) SWIG_fail;
7017 }
7018 {
7019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7020 }
7021 return resultobj;
7022 fail:
7023 return NULL;
7024 }
7025
7026
7027 static PyObject *_wrap_Region_XorRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7028 PyObject *resultobj;
7029 wxRegion *arg1 = (wxRegion *) 0 ;
7030 wxRegion *arg2 = 0 ;
7031 bool result;
7032 PyObject * obj0 = 0 ;
7033 PyObject * obj1 = 0 ;
7034 char *kwnames[] = {
7035 (char *) "self",(char *) "region", NULL
7036 };
7037
7038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRegion",kwnames,&obj0,&obj1)) goto fail;
7039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7040 if (SWIG_arg_fail(1)) SWIG_fail;
7041 {
7042 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7043 if (SWIG_arg_fail(2)) SWIG_fail;
7044 if (arg2 == NULL) {
7045 SWIG_null_ref("wxRegion");
7046 }
7047 if (SWIG_arg_fail(2)) SWIG_fail;
7048 }
7049 {
7050 PyThreadState* __tstate = wxPyBeginAllowThreads();
7051 result = (bool)(arg1)->Xor((wxRegion const &)*arg2);
7052
7053 wxPyEndAllowThreads(__tstate);
7054 if (PyErr_Occurred()) SWIG_fail;
7055 }
7056 {
7057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7058 }
7059 return resultobj;
7060 fail:
7061 return NULL;
7062 }
7063
7064
7065 static PyObject *_wrap_Region_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7066 PyObject *resultobj;
7067 wxRegion *arg1 = (wxRegion *) 0 ;
7068 SwigValueWrapper<wxBitmap > result;
7069 PyObject * obj0 = 0 ;
7070 char *kwnames[] = {
7071 (char *) "self", NULL
7072 };
7073
7074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_ConvertToBitmap",kwnames,&obj0)) goto fail;
7075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7076 if (SWIG_arg_fail(1)) SWIG_fail;
7077 {
7078 PyThreadState* __tstate = wxPyBeginAllowThreads();
7079 result = (arg1)->ConvertToBitmap();
7080
7081 wxPyEndAllowThreads(__tstate);
7082 if (PyErr_Occurred()) SWIG_fail;
7083 }
7084 {
7085 wxBitmap * resultptr;
7086 resultptr = new wxBitmap((wxBitmap &)(result));
7087 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
7088 }
7089 return resultobj;
7090 fail:
7091 return NULL;
7092 }
7093
7094
7095 static PyObject *_wrap_Region_UnionBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7096 PyObject *resultobj;
7097 wxRegion *arg1 = (wxRegion *) 0 ;
7098 wxBitmap *arg2 = 0 ;
7099 bool result;
7100 PyObject * obj0 = 0 ;
7101 PyObject * obj1 = 0 ;
7102 char *kwnames[] = {
7103 (char *) "self",(char *) "bmp", NULL
7104 };
7105
7106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionBitmap",kwnames,&obj0,&obj1)) goto fail;
7107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7108 if (SWIG_arg_fail(1)) SWIG_fail;
7109 {
7110 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7111 if (SWIG_arg_fail(2)) SWIG_fail;
7112 if (arg2 == NULL) {
7113 SWIG_null_ref("wxBitmap");
7114 }
7115 if (SWIG_arg_fail(2)) SWIG_fail;
7116 }
7117 {
7118 PyThreadState* __tstate = wxPyBeginAllowThreads();
7119 result = (bool)(arg1)->Union((wxBitmap const &)*arg2);
7120
7121 wxPyEndAllowThreads(__tstate);
7122 if (PyErr_Occurred()) SWIG_fail;
7123 }
7124 {
7125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7126 }
7127 return resultobj;
7128 fail:
7129 return NULL;
7130 }
7131
7132
7133 static PyObject *_wrap_Region_UnionBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
7134 PyObject *resultobj;
7135 wxRegion *arg1 = (wxRegion *) 0 ;
7136 wxBitmap *arg2 = 0 ;
7137 wxColour *arg3 = 0 ;
7138 int arg4 = (int) 0 ;
7139 bool result;
7140 wxColour temp3 ;
7141 PyObject * obj0 = 0 ;
7142 PyObject * obj1 = 0 ;
7143 PyObject * obj2 = 0 ;
7144 PyObject * obj3 = 0 ;
7145 char *kwnames[] = {
7146 (char *) "self",(char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
7147 };
7148
7149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Region_UnionBitmapColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7151 if (SWIG_arg_fail(1)) SWIG_fail;
7152 {
7153 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7154 if (SWIG_arg_fail(2)) SWIG_fail;
7155 if (arg2 == NULL) {
7156 SWIG_null_ref("wxBitmap");
7157 }
7158 if (SWIG_arg_fail(2)) SWIG_fail;
7159 }
7160 {
7161 arg3 = &temp3;
7162 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
7163 }
7164 if (obj3) {
7165 {
7166 arg4 = (int)(SWIG_As_int(obj3));
7167 if (SWIG_arg_fail(4)) SWIG_fail;
7168 }
7169 }
7170 {
7171 PyThreadState* __tstate = wxPyBeginAllowThreads();
7172 result = (bool)(arg1)->Union((wxBitmap const &)*arg2,(wxColour const &)*arg3,arg4);
7173
7174 wxPyEndAllowThreads(__tstate);
7175 if (PyErr_Occurred()) SWIG_fail;
7176 }
7177 {
7178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7179 }
7180 return resultobj;
7181 fail:
7182 return NULL;
7183 }
7184
7185
7186 static PyObject * Region_swigregister(PyObject *, PyObject *args) {
7187 PyObject *obj;
7188 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7189 SWIG_TypeClientData(SWIGTYPE_p_wxRegion, obj);
7190 Py_INCREF(obj);
7191 return Py_BuildValue((char *)"");
7192 }
7193 static PyObject *_wrap_new_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7194 PyObject *resultobj;
7195 wxRegion *arg1 = 0 ;
7196 wxRegionIterator *result;
7197 PyObject * obj0 = 0 ;
7198 char *kwnames[] = {
7199 (char *) "region", NULL
7200 };
7201
7202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionIterator",kwnames,&obj0)) goto fail;
7203 {
7204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7205 if (SWIG_arg_fail(1)) SWIG_fail;
7206 if (arg1 == NULL) {
7207 SWIG_null_ref("wxRegion");
7208 }
7209 if (SWIG_arg_fail(1)) SWIG_fail;
7210 }
7211 {
7212 if (!wxPyCheckForApp()) SWIG_fail;
7213 PyThreadState* __tstate = wxPyBeginAllowThreads();
7214 result = (wxRegionIterator *)new wxRegionIterator((wxRegion const &)*arg1);
7215
7216 wxPyEndAllowThreads(__tstate);
7217 if (PyErr_Occurred()) SWIG_fail;
7218 }
7219 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegionIterator, 1);
7220 return resultobj;
7221 fail:
7222 return NULL;
7223 }
7224
7225
7226 static PyObject *_wrap_delete_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7227 PyObject *resultobj;
7228 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7229 PyObject * obj0 = 0 ;
7230 char *kwnames[] = {
7231 (char *) "self", NULL
7232 };
7233
7234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RegionIterator",kwnames,&obj0)) goto fail;
7235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7236 if (SWIG_arg_fail(1)) SWIG_fail;
7237 {
7238 PyThreadState* __tstate = wxPyBeginAllowThreads();
7239 delete arg1;
7240
7241 wxPyEndAllowThreads(__tstate);
7242 if (PyErr_Occurred()) SWIG_fail;
7243 }
7244 Py_INCREF(Py_None); resultobj = Py_None;
7245 return resultobj;
7246 fail:
7247 return NULL;
7248 }
7249
7250
7251 static PyObject *_wrap_RegionIterator_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
7252 PyObject *resultobj;
7253 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7254 int result;
7255 PyObject * obj0 = 0 ;
7256 char *kwnames[] = {
7257 (char *) "self", NULL
7258 };
7259
7260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetX",kwnames,&obj0)) goto fail;
7261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7262 if (SWIG_arg_fail(1)) SWIG_fail;
7263 {
7264 PyThreadState* __tstate = wxPyBeginAllowThreads();
7265 result = (int)(arg1)->GetX();
7266
7267 wxPyEndAllowThreads(__tstate);
7268 if (PyErr_Occurred()) SWIG_fail;
7269 }
7270 {
7271 resultobj = SWIG_From_int((int)(result));
7272 }
7273 return resultobj;
7274 fail:
7275 return NULL;
7276 }
7277
7278
7279 static PyObject *_wrap_RegionIterator_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
7280 PyObject *resultobj;
7281 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7282 int result;
7283 PyObject * obj0 = 0 ;
7284 char *kwnames[] = {
7285 (char *) "self", NULL
7286 };
7287
7288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetY",kwnames,&obj0)) goto fail;
7289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7290 if (SWIG_arg_fail(1)) SWIG_fail;
7291 {
7292 PyThreadState* __tstate = wxPyBeginAllowThreads();
7293 result = (int)(arg1)->GetY();
7294
7295 wxPyEndAllowThreads(__tstate);
7296 if (PyErr_Occurred()) SWIG_fail;
7297 }
7298 {
7299 resultobj = SWIG_From_int((int)(result));
7300 }
7301 return resultobj;
7302 fail:
7303 return NULL;
7304 }
7305
7306
7307 static PyObject *_wrap_RegionIterator_GetW(PyObject *, PyObject *args, PyObject *kwargs) {
7308 PyObject *resultobj;
7309 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7310 int result;
7311 PyObject * obj0 = 0 ;
7312 char *kwnames[] = {
7313 (char *) "self", NULL
7314 };
7315
7316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetW",kwnames,&obj0)) goto fail;
7317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7318 if (SWIG_arg_fail(1)) SWIG_fail;
7319 {
7320 PyThreadState* __tstate = wxPyBeginAllowThreads();
7321 result = (int)(arg1)->GetW();
7322
7323 wxPyEndAllowThreads(__tstate);
7324 if (PyErr_Occurred()) SWIG_fail;
7325 }
7326 {
7327 resultobj = SWIG_From_int((int)(result));
7328 }
7329 return resultobj;
7330 fail:
7331 return NULL;
7332 }
7333
7334
7335 static PyObject *_wrap_RegionIterator_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
7336 PyObject *resultobj;
7337 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7338 int result;
7339 PyObject * obj0 = 0 ;
7340 char *kwnames[] = {
7341 (char *) "self", NULL
7342 };
7343
7344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetWidth",kwnames,&obj0)) goto fail;
7345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7346 if (SWIG_arg_fail(1)) SWIG_fail;
7347 {
7348 PyThreadState* __tstate = wxPyBeginAllowThreads();
7349 result = (int)(arg1)->GetWidth();
7350
7351 wxPyEndAllowThreads(__tstate);
7352 if (PyErr_Occurred()) SWIG_fail;
7353 }
7354 {
7355 resultobj = SWIG_From_int((int)(result));
7356 }
7357 return resultobj;
7358 fail:
7359 return NULL;
7360 }
7361
7362
7363 static PyObject *_wrap_RegionIterator_GetH(PyObject *, PyObject *args, PyObject *kwargs) {
7364 PyObject *resultobj;
7365 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7366 int result;
7367 PyObject * obj0 = 0 ;
7368 char *kwnames[] = {
7369 (char *) "self", NULL
7370 };
7371
7372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetH",kwnames,&obj0)) goto fail;
7373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7374 if (SWIG_arg_fail(1)) SWIG_fail;
7375 {
7376 PyThreadState* __tstate = wxPyBeginAllowThreads();
7377 result = (int)(arg1)->GetH();
7378
7379 wxPyEndAllowThreads(__tstate);
7380 if (PyErr_Occurred()) SWIG_fail;
7381 }
7382 {
7383 resultobj = SWIG_From_int((int)(result));
7384 }
7385 return resultobj;
7386 fail:
7387 return NULL;
7388 }
7389
7390
7391 static PyObject *_wrap_RegionIterator_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
7392 PyObject *resultobj;
7393 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7394 int result;
7395 PyObject * obj0 = 0 ;
7396 char *kwnames[] = {
7397 (char *) "self", NULL
7398 };
7399
7400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetHeight",kwnames,&obj0)) goto fail;
7401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7402 if (SWIG_arg_fail(1)) SWIG_fail;
7403 {
7404 PyThreadState* __tstate = wxPyBeginAllowThreads();
7405 result = (int)(arg1)->GetHeight();
7406
7407 wxPyEndAllowThreads(__tstate);
7408 if (PyErr_Occurred()) SWIG_fail;
7409 }
7410 {
7411 resultobj = SWIG_From_int((int)(result));
7412 }
7413 return resultobj;
7414 fail:
7415 return NULL;
7416 }
7417
7418
7419 static PyObject *_wrap_RegionIterator_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
7420 PyObject *resultobj;
7421 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7422 wxRect result;
7423 PyObject * obj0 = 0 ;
7424 char *kwnames[] = {
7425 (char *) "self", NULL
7426 };
7427
7428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetRect",kwnames,&obj0)) goto fail;
7429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7430 if (SWIG_arg_fail(1)) SWIG_fail;
7431 {
7432 PyThreadState* __tstate = wxPyBeginAllowThreads();
7433 result = (arg1)->GetRect();
7434
7435 wxPyEndAllowThreads(__tstate);
7436 if (PyErr_Occurred()) SWIG_fail;
7437 }
7438 {
7439 wxRect * resultptr;
7440 resultptr = new wxRect((wxRect &)(result));
7441 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
7442 }
7443 return resultobj;
7444 fail:
7445 return NULL;
7446 }
7447
7448
7449 static PyObject *_wrap_RegionIterator_HaveRects(PyObject *, PyObject *args, PyObject *kwargs) {
7450 PyObject *resultobj;
7451 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7452 bool result;
7453 PyObject * obj0 = 0 ;
7454 char *kwnames[] = {
7455 (char *) "self", NULL
7456 };
7457
7458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_HaveRects",kwnames,&obj0)) goto fail;
7459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7460 if (SWIG_arg_fail(1)) SWIG_fail;
7461 {
7462 PyThreadState* __tstate = wxPyBeginAllowThreads();
7463 result = (bool)(arg1)->HaveRects();
7464
7465 wxPyEndAllowThreads(__tstate);
7466 if (PyErr_Occurred()) SWIG_fail;
7467 }
7468 {
7469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7470 }
7471 return resultobj;
7472 fail:
7473 return NULL;
7474 }
7475
7476
7477 static PyObject *_wrap_RegionIterator_Reset(PyObject *, PyObject *args, PyObject *kwargs) {
7478 PyObject *resultobj;
7479 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7480 PyObject * obj0 = 0 ;
7481 char *kwnames[] = {
7482 (char *) "self", NULL
7483 };
7484
7485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Reset",kwnames,&obj0)) goto fail;
7486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7487 if (SWIG_arg_fail(1)) SWIG_fail;
7488 {
7489 PyThreadState* __tstate = wxPyBeginAllowThreads();
7490 (arg1)->Reset();
7491
7492 wxPyEndAllowThreads(__tstate);
7493 if (PyErr_Occurred()) SWIG_fail;
7494 }
7495 Py_INCREF(Py_None); resultobj = Py_None;
7496 return resultobj;
7497 fail:
7498 return NULL;
7499 }
7500
7501
7502 static PyObject *_wrap_RegionIterator_Next(PyObject *, PyObject *args, PyObject *kwargs) {
7503 PyObject *resultobj;
7504 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7505 PyObject * obj0 = 0 ;
7506 char *kwnames[] = {
7507 (char *) "self", NULL
7508 };
7509
7510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Next",kwnames,&obj0)) goto fail;
7511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7512 if (SWIG_arg_fail(1)) SWIG_fail;
7513 {
7514 PyThreadState* __tstate = wxPyBeginAllowThreads();
7515 wxRegionIterator_Next(arg1);
7516
7517 wxPyEndAllowThreads(__tstate);
7518 if (PyErr_Occurred()) SWIG_fail;
7519 }
7520 Py_INCREF(Py_None); resultobj = Py_None;
7521 return resultobj;
7522 fail:
7523 return NULL;
7524 }
7525
7526
7527 static PyObject *_wrap_RegionIterator___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
7528 PyObject *resultobj;
7529 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7530 bool result;
7531 PyObject * obj0 = 0 ;
7532 char *kwnames[] = {
7533 (char *) "self", NULL
7534 };
7535
7536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator___nonzero__",kwnames,&obj0)) goto fail;
7537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7538 if (SWIG_arg_fail(1)) SWIG_fail;
7539 {
7540 PyThreadState* __tstate = wxPyBeginAllowThreads();
7541 result = (bool)wxRegionIterator___nonzero__(arg1);
7542
7543 wxPyEndAllowThreads(__tstate);
7544 if (PyErr_Occurred()) SWIG_fail;
7545 }
7546 {
7547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7548 }
7549 return resultobj;
7550 fail:
7551 return NULL;
7552 }
7553
7554
7555 static PyObject * RegionIterator_swigregister(PyObject *, PyObject *args) {
7556 PyObject *obj;
7557 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7558 SWIG_TypeClientData(SWIGTYPE_p_wxRegionIterator, obj);
7559 Py_INCREF(obj);
7560 return Py_BuildValue((char *)"");
7561 }
7562 static PyObject *_wrap_new_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7563 PyObject *resultobj;
7564 wxNativeFontInfo *result;
7565 char *kwnames[] = {
7566 NULL
7567 };
7568
7569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeFontInfo",kwnames)) goto fail;
7570 {
7571 PyThreadState* __tstate = wxPyBeginAllowThreads();
7572 result = (wxNativeFontInfo *)new wxNativeFontInfo();
7573
7574 wxPyEndAllowThreads(__tstate);
7575 if (PyErr_Occurred()) SWIG_fail;
7576 }
7577 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 1);
7578 return resultobj;
7579 fail:
7580 return NULL;
7581 }
7582
7583
7584 static PyObject *_wrap_delete_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7585 PyObject *resultobj;
7586 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7587 PyObject * obj0 = 0 ;
7588 char *kwnames[] = {
7589 (char *) "self", NULL
7590 };
7591
7592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeFontInfo",kwnames,&obj0)) goto fail;
7593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7594 if (SWIG_arg_fail(1)) SWIG_fail;
7595 {
7596 PyThreadState* __tstate = wxPyBeginAllowThreads();
7597 delete arg1;
7598
7599 wxPyEndAllowThreads(__tstate);
7600 if (PyErr_Occurred()) SWIG_fail;
7601 }
7602 Py_INCREF(Py_None); resultobj = Py_None;
7603 return resultobj;
7604 fail:
7605 return NULL;
7606 }
7607
7608
7609 static PyObject *_wrap_NativeFontInfo_Init(PyObject *, PyObject *args, PyObject *kwargs) {
7610 PyObject *resultobj;
7611 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7612 PyObject * obj0 = 0 ;
7613 char *kwnames[] = {
7614 (char *) "self", NULL
7615 };
7616
7617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_Init",kwnames,&obj0)) goto fail;
7618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7619 if (SWIG_arg_fail(1)) SWIG_fail;
7620 {
7621 PyThreadState* __tstate = wxPyBeginAllowThreads();
7622 (arg1)->Init();
7623
7624 wxPyEndAllowThreads(__tstate);
7625 if (PyErr_Occurred()) SWIG_fail;
7626 }
7627 Py_INCREF(Py_None); resultobj = Py_None;
7628 return resultobj;
7629 fail:
7630 return NULL;
7631 }
7632
7633
7634 static PyObject *_wrap_NativeFontInfo_InitFromFont(PyObject *, PyObject *args, PyObject *kwargs) {
7635 PyObject *resultobj;
7636 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7637 wxFont *arg2 = 0 ;
7638 PyObject * obj0 = 0 ;
7639 PyObject * obj1 = 0 ;
7640 char *kwnames[] = {
7641 (char *) "self",(char *) "font", NULL
7642 };
7643
7644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_InitFromFont",kwnames,&obj0,&obj1)) goto fail;
7645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7646 if (SWIG_arg_fail(1)) SWIG_fail;
7647 {
7648 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
7649 if (SWIG_arg_fail(2)) SWIG_fail;
7650 if (arg2 == NULL) {
7651 SWIG_null_ref("wxFont");
7652 }
7653 if (SWIG_arg_fail(2)) SWIG_fail;
7654 }
7655 {
7656 PyThreadState* __tstate = wxPyBeginAllowThreads();
7657 (arg1)->InitFromFont((wxFont const &)*arg2);
7658
7659 wxPyEndAllowThreads(__tstate);
7660 if (PyErr_Occurred()) SWIG_fail;
7661 }
7662 Py_INCREF(Py_None); resultobj = Py_None;
7663 return resultobj;
7664 fail:
7665 return NULL;
7666 }
7667
7668
7669 static PyObject *_wrap_NativeFontInfo_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
7670 PyObject *resultobj;
7671 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7672 int result;
7673 PyObject * obj0 = 0 ;
7674 char *kwnames[] = {
7675 (char *) "self", NULL
7676 };
7677
7678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetPointSize",kwnames,&obj0)) goto fail;
7679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7680 if (SWIG_arg_fail(1)) SWIG_fail;
7681 {
7682 PyThreadState* __tstate = wxPyBeginAllowThreads();
7683 result = (int)((wxNativeFontInfo const *)arg1)->GetPointSize();
7684
7685 wxPyEndAllowThreads(__tstate);
7686 if (PyErr_Occurred()) SWIG_fail;
7687 }
7688 {
7689 resultobj = SWIG_From_int((int)(result));
7690 }
7691 return resultobj;
7692 fail:
7693 return NULL;
7694 }
7695
7696
7697 static PyObject *_wrap_NativeFontInfo_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
7698 PyObject *resultobj;
7699 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7700 wxFontStyle result;
7701 PyObject * obj0 = 0 ;
7702 char *kwnames[] = {
7703 (char *) "self", NULL
7704 };
7705
7706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetStyle",kwnames,&obj0)) goto fail;
7707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7708 if (SWIG_arg_fail(1)) SWIG_fail;
7709 {
7710 PyThreadState* __tstate = wxPyBeginAllowThreads();
7711 result = (wxFontStyle)((wxNativeFontInfo const *)arg1)->GetStyle();
7712
7713 wxPyEndAllowThreads(__tstate);
7714 if (PyErr_Occurred()) SWIG_fail;
7715 }
7716 resultobj = SWIG_From_int((result));
7717 return resultobj;
7718 fail:
7719 return NULL;
7720 }
7721
7722
7723 static PyObject *_wrap_NativeFontInfo_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
7724 PyObject *resultobj;
7725 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7726 wxFontWeight result;
7727 PyObject * obj0 = 0 ;
7728 char *kwnames[] = {
7729 (char *) "self", NULL
7730 };
7731
7732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetWeight",kwnames,&obj0)) goto fail;
7733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7734 if (SWIG_arg_fail(1)) SWIG_fail;
7735 {
7736 PyThreadState* __tstate = wxPyBeginAllowThreads();
7737 result = (wxFontWeight)((wxNativeFontInfo const *)arg1)->GetWeight();
7738
7739 wxPyEndAllowThreads(__tstate);
7740 if (PyErr_Occurred()) SWIG_fail;
7741 }
7742 resultobj = SWIG_From_int((result));
7743 return resultobj;
7744 fail:
7745 return NULL;
7746 }
7747
7748
7749 static PyObject *_wrap_NativeFontInfo_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
7750 PyObject *resultobj;
7751 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7752 bool result;
7753 PyObject * obj0 = 0 ;
7754 char *kwnames[] = {
7755 (char *) "self", NULL
7756 };
7757
7758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetUnderlined",kwnames,&obj0)) goto fail;
7759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7760 if (SWIG_arg_fail(1)) SWIG_fail;
7761 {
7762 PyThreadState* __tstate = wxPyBeginAllowThreads();
7763 result = (bool)((wxNativeFontInfo const *)arg1)->GetUnderlined();
7764
7765 wxPyEndAllowThreads(__tstate);
7766 if (PyErr_Occurred()) SWIG_fail;
7767 }
7768 {
7769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7770 }
7771 return resultobj;
7772 fail:
7773 return NULL;
7774 }
7775
7776
7777 static PyObject *_wrap_NativeFontInfo_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
7778 PyObject *resultobj;
7779 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7780 wxString result;
7781 PyObject * obj0 = 0 ;
7782 char *kwnames[] = {
7783 (char *) "self", NULL
7784 };
7785
7786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFaceName",kwnames,&obj0)) goto fail;
7787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7788 if (SWIG_arg_fail(1)) SWIG_fail;
7789 {
7790 PyThreadState* __tstate = wxPyBeginAllowThreads();
7791 result = ((wxNativeFontInfo const *)arg1)->GetFaceName();
7792
7793 wxPyEndAllowThreads(__tstate);
7794 if (PyErr_Occurred()) SWIG_fail;
7795 }
7796 {
7797 #if wxUSE_UNICODE
7798 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7799 #else
7800 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7801 #endif
7802 }
7803 return resultobj;
7804 fail:
7805 return NULL;
7806 }
7807
7808
7809 static PyObject *_wrap_NativeFontInfo_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
7810 PyObject *resultobj;
7811 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7812 wxFontFamily result;
7813 PyObject * obj0 = 0 ;
7814 char *kwnames[] = {
7815 (char *) "self", NULL
7816 };
7817
7818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFamily",kwnames,&obj0)) goto fail;
7819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7820 if (SWIG_arg_fail(1)) SWIG_fail;
7821 {
7822 PyThreadState* __tstate = wxPyBeginAllowThreads();
7823 result = (wxFontFamily)((wxNativeFontInfo const *)arg1)->GetFamily();
7824
7825 wxPyEndAllowThreads(__tstate);
7826 if (PyErr_Occurred()) SWIG_fail;
7827 }
7828 resultobj = SWIG_From_int((result));
7829 return resultobj;
7830 fail:
7831 return NULL;
7832 }
7833
7834
7835 static PyObject *_wrap_NativeFontInfo_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
7836 PyObject *resultobj;
7837 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7838 wxFontEncoding result;
7839 PyObject * obj0 = 0 ;
7840 char *kwnames[] = {
7841 (char *) "self", NULL
7842 };
7843
7844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetEncoding",kwnames,&obj0)) goto fail;
7845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7846 if (SWIG_arg_fail(1)) SWIG_fail;
7847 {
7848 PyThreadState* __tstate = wxPyBeginAllowThreads();
7849 result = (wxFontEncoding)((wxNativeFontInfo const *)arg1)->GetEncoding();
7850
7851 wxPyEndAllowThreads(__tstate);
7852 if (PyErr_Occurred()) SWIG_fail;
7853 }
7854 resultobj = SWIG_From_int((result));
7855 return resultobj;
7856 fail:
7857 return NULL;
7858 }
7859
7860
7861 static PyObject *_wrap_NativeFontInfo_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
7862 PyObject *resultobj;
7863 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7864 int arg2 ;
7865 PyObject * obj0 = 0 ;
7866 PyObject * obj1 = 0 ;
7867 char *kwnames[] = {
7868 (char *) "self",(char *) "pointsize", NULL
7869 };
7870
7871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
7872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7873 if (SWIG_arg_fail(1)) SWIG_fail;
7874 {
7875 arg2 = (int)(SWIG_As_int(obj1));
7876 if (SWIG_arg_fail(2)) SWIG_fail;
7877 }
7878 {
7879 PyThreadState* __tstate = wxPyBeginAllowThreads();
7880 (arg1)->SetPointSize(arg2);
7881
7882 wxPyEndAllowThreads(__tstate);
7883 if (PyErr_Occurred()) SWIG_fail;
7884 }
7885 Py_INCREF(Py_None); resultobj = Py_None;
7886 return resultobj;
7887 fail:
7888 return NULL;
7889 }
7890
7891
7892 static PyObject *_wrap_NativeFontInfo_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
7893 PyObject *resultobj;
7894 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7895 wxFontStyle arg2 ;
7896 PyObject * obj0 = 0 ;
7897 PyObject * obj1 = 0 ;
7898 char *kwnames[] = {
7899 (char *) "self",(char *) "style", NULL
7900 };
7901
7902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetStyle",kwnames,&obj0,&obj1)) goto fail;
7903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7904 if (SWIG_arg_fail(1)) SWIG_fail;
7905 {
7906 arg2 = (wxFontStyle)(SWIG_As_int(obj1));
7907 if (SWIG_arg_fail(2)) SWIG_fail;
7908 }
7909 {
7910 PyThreadState* __tstate = wxPyBeginAllowThreads();
7911 (arg1)->SetStyle((wxFontStyle )arg2);
7912
7913 wxPyEndAllowThreads(__tstate);
7914 if (PyErr_Occurred()) SWIG_fail;
7915 }
7916 Py_INCREF(Py_None); resultobj = Py_None;
7917 return resultobj;
7918 fail:
7919 return NULL;
7920 }
7921
7922
7923 static PyObject *_wrap_NativeFontInfo_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
7924 PyObject *resultobj;
7925 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7926 wxFontWeight arg2 ;
7927 PyObject * obj0 = 0 ;
7928 PyObject * obj1 = 0 ;
7929 char *kwnames[] = {
7930 (char *) "self",(char *) "weight", NULL
7931 };
7932
7933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetWeight",kwnames,&obj0,&obj1)) goto fail;
7934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7935 if (SWIG_arg_fail(1)) SWIG_fail;
7936 {
7937 arg2 = (wxFontWeight)(SWIG_As_int(obj1));
7938 if (SWIG_arg_fail(2)) SWIG_fail;
7939 }
7940 {
7941 PyThreadState* __tstate = wxPyBeginAllowThreads();
7942 (arg1)->SetWeight((wxFontWeight )arg2);
7943
7944 wxPyEndAllowThreads(__tstate);
7945 if (PyErr_Occurred()) SWIG_fail;
7946 }
7947 Py_INCREF(Py_None); resultobj = Py_None;
7948 return resultobj;
7949 fail:
7950 return NULL;
7951 }
7952
7953
7954 static PyObject *_wrap_NativeFontInfo_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
7955 PyObject *resultobj;
7956 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7957 bool arg2 ;
7958 PyObject * obj0 = 0 ;
7959 PyObject * obj1 = 0 ;
7960 char *kwnames[] = {
7961 (char *) "self",(char *) "underlined", NULL
7962 };
7963
7964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
7965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7966 if (SWIG_arg_fail(1)) SWIG_fail;
7967 {
7968 arg2 = (bool)(SWIG_As_bool(obj1));
7969 if (SWIG_arg_fail(2)) SWIG_fail;
7970 }
7971 {
7972 PyThreadState* __tstate = wxPyBeginAllowThreads();
7973 (arg1)->SetUnderlined(arg2);
7974
7975 wxPyEndAllowThreads(__tstate);
7976 if (PyErr_Occurred()) SWIG_fail;
7977 }
7978 Py_INCREF(Py_None); resultobj = Py_None;
7979 return resultobj;
7980 fail:
7981 return NULL;
7982 }
7983
7984
7985 static PyObject *_wrap_NativeFontInfo_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
7986 PyObject *resultobj;
7987 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7988 wxString arg2 ;
7989 PyObject * obj0 = 0 ;
7990 PyObject * obj1 = 0 ;
7991 char *kwnames[] = {
7992 (char *) "self",(char *) "facename", NULL
7993 };
7994
7995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
7996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7997 if (SWIG_arg_fail(1)) SWIG_fail;
7998 {
7999 wxString* sptr = wxString_in_helper(obj1);
8000 if (sptr == NULL) SWIG_fail;
8001 arg2 = *sptr;
8002 delete sptr;
8003 }
8004 {
8005 PyThreadState* __tstate = wxPyBeginAllowThreads();
8006 (arg1)->SetFaceName(arg2);
8007
8008 wxPyEndAllowThreads(__tstate);
8009 if (PyErr_Occurred()) SWIG_fail;
8010 }
8011 Py_INCREF(Py_None); resultobj = Py_None;
8012 return resultobj;
8013 fail:
8014 return NULL;
8015 }
8016
8017
8018 static PyObject *_wrap_NativeFontInfo_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
8019 PyObject *resultobj;
8020 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8021 wxFontFamily arg2 ;
8022 PyObject * obj0 = 0 ;
8023 PyObject * obj1 = 0 ;
8024 char *kwnames[] = {
8025 (char *) "self",(char *) "family", NULL
8026 };
8027
8028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFamily",kwnames,&obj0,&obj1)) goto fail;
8029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8030 if (SWIG_arg_fail(1)) SWIG_fail;
8031 {
8032 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
8033 if (SWIG_arg_fail(2)) SWIG_fail;
8034 }
8035 {
8036 PyThreadState* __tstate = wxPyBeginAllowThreads();
8037 (arg1)->SetFamily((wxFontFamily )arg2);
8038
8039 wxPyEndAllowThreads(__tstate);
8040 if (PyErr_Occurred()) SWIG_fail;
8041 }
8042 Py_INCREF(Py_None); resultobj = Py_None;
8043 return resultobj;
8044 fail:
8045 return NULL;
8046 }
8047
8048
8049 static PyObject *_wrap_NativeFontInfo_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8050 PyObject *resultobj;
8051 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8052 wxFontEncoding arg2 ;
8053 PyObject * obj0 = 0 ;
8054 PyObject * obj1 = 0 ;
8055 char *kwnames[] = {
8056 (char *) "self",(char *) "encoding", NULL
8057 };
8058
8059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
8060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8061 if (SWIG_arg_fail(1)) SWIG_fail;
8062 {
8063 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8064 if (SWIG_arg_fail(2)) SWIG_fail;
8065 }
8066 {
8067 PyThreadState* __tstate = wxPyBeginAllowThreads();
8068 (arg1)->SetEncoding((wxFontEncoding )arg2);
8069
8070 wxPyEndAllowThreads(__tstate);
8071 if (PyErr_Occurred()) SWIG_fail;
8072 }
8073 Py_INCREF(Py_None); resultobj = Py_None;
8074 return resultobj;
8075 fail:
8076 return NULL;
8077 }
8078
8079
8080 static PyObject *_wrap_NativeFontInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
8081 PyObject *resultobj;
8082 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8083 wxString *arg2 = 0 ;
8084 bool result;
8085 bool temp2 = false ;
8086 PyObject * obj0 = 0 ;
8087 PyObject * obj1 = 0 ;
8088 char *kwnames[] = {
8089 (char *) "self",(char *) "s", NULL
8090 };
8091
8092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
8093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8094 if (SWIG_arg_fail(1)) SWIG_fail;
8095 {
8096 arg2 = wxString_in_helper(obj1);
8097 if (arg2 == NULL) SWIG_fail;
8098 temp2 = true;
8099 }
8100 {
8101 PyThreadState* __tstate = wxPyBeginAllowThreads();
8102 result = (bool)(arg1)->FromString((wxString const &)*arg2);
8103
8104 wxPyEndAllowThreads(__tstate);
8105 if (PyErr_Occurred()) SWIG_fail;
8106 }
8107 {
8108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8109 }
8110 {
8111 if (temp2)
8112 delete arg2;
8113 }
8114 return resultobj;
8115 fail:
8116 {
8117 if (temp2)
8118 delete arg2;
8119 }
8120 return NULL;
8121 }
8122
8123
8124 static PyObject *_wrap_NativeFontInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
8125 PyObject *resultobj;
8126 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8127 wxString result;
8128 PyObject * obj0 = 0 ;
8129 char *kwnames[] = {
8130 (char *) "self", NULL
8131 };
8132
8133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToString",kwnames,&obj0)) goto fail;
8134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8135 if (SWIG_arg_fail(1)) SWIG_fail;
8136 {
8137 PyThreadState* __tstate = wxPyBeginAllowThreads();
8138 result = ((wxNativeFontInfo const *)arg1)->ToString();
8139
8140 wxPyEndAllowThreads(__tstate);
8141 if (PyErr_Occurred()) SWIG_fail;
8142 }
8143 {
8144 #if wxUSE_UNICODE
8145 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8146 #else
8147 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8148 #endif
8149 }
8150 return resultobj;
8151 fail:
8152 return NULL;
8153 }
8154
8155
8156 static PyObject *_wrap_NativeFontInfo___str__(PyObject *, PyObject *args, PyObject *kwargs) {
8157 PyObject *resultobj;
8158 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8159 wxString result;
8160 PyObject * obj0 = 0 ;
8161 char *kwnames[] = {
8162 (char *) "self", NULL
8163 };
8164
8165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo___str__",kwnames,&obj0)) goto fail;
8166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8167 if (SWIG_arg_fail(1)) SWIG_fail;
8168 {
8169 PyThreadState* __tstate = wxPyBeginAllowThreads();
8170 result = wxNativeFontInfo___str__(arg1);
8171
8172 wxPyEndAllowThreads(__tstate);
8173 if (PyErr_Occurred()) SWIG_fail;
8174 }
8175 {
8176 #if wxUSE_UNICODE
8177 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8178 #else
8179 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8180 #endif
8181 }
8182 return resultobj;
8183 fail:
8184 return NULL;
8185 }
8186
8187
8188 static PyObject *_wrap_NativeFontInfo_FromUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8189 PyObject *resultobj;
8190 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8191 wxString *arg2 = 0 ;
8192 bool result;
8193 bool temp2 = false ;
8194 PyObject * obj0 = 0 ;
8195 PyObject * obj1 = 0 ;
8196 char *kwnames[] = {
8197 (char *) "self",(char *) "s", NULL
8198 };
8199
8200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromUserString",kwnames,&obj0,&obj1)) goto fail;
8201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8202 if (SWIG_arg_fail(1)) SWIG_fail;
8203 {
8204 arg2 = wxString_in_helper(obj1);
8205 if (arg2 == NULL) SWIG_fail;
8206 temp2 = true;
8207 }
8208 {
8209 PyThreadState* __tstate = wxPyBeginAllowThreads();
8210 result = (bool)(arg1)->FromUserString((wxString const &)*arg2);
8211
8212 wxPyEndAllowThreads(__tstate);
8213 if (PyErr_Occurred()) SWIG_fail;
8214 }
8215 {
8216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8217 }
8218 {
8219 if (temp2)
8220 delete arg2;
8221 }
8222 return resultobj;
8223 fail:
8224 {
8225 if (temp2)
8226 delete arg2;
8227 }
8228 return NULL;
8229 }
8230
8231
8232 static PyObject *_wrap_NativeFontInfo_ToUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8233 PyObject *resultobj;
8234 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8235 wxString result;
8236 PyObject * obj0 = 0 ;
8237 char *kwnames[] = {
8238 (char *) "self", NULL
8239 };
8240
8241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToUserString",kwnames,&obj0)) goto fail;
8242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8243 if (SWIG_arg_fail(1)) SWIG_fail;
8244 {
8245 PyThreadState* __tstate = wxPyBeginAllowThreads();
8246 result = ((wxNativeFontInfo const *)arg1)->ToUserString();
8247
8248 wxPyEndAllowThreads(__tstate);
8249 if (PyErr_Occurred()) SWIG_fail;
8250 }
8251 {
8252 #if wxUSE_UNICODE
8253 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8254 #else
8255 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8256 #endif
8257 }
8258 return resultobj;
8259 fail:
8260 return NULL;
8261 }
8262
8263
8264 static PyObject * NativeFontInfo_swigregister(PyObject *, PyObject *args) {
8265 PyObject *obj;
8266 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8267 SWIG_TypeClientData(SWIGTYPE_p_wxNativeFontInfo, obj);
8268 Py_INCREF(obj);
8269 return Py_BuildValue((char *)"");
8270 }
8271 static PyObject *_wrap_NativeEncodingInfo_facename_set(PyObject *, PyObject *args, PyObject *kwargs) {
8272 PyObject *resultobj;
8273 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8274 wxString *arg2 = (wxString *) 0 ;
8275 bool temp2 = false ;
8276 PyObject * obj0 = 0 ;
8277 PyObject * obj1 = 0 ;
8278 char *kwnames[] = {
8279 (char *) "self",(char *) "facename", NULL
8280 };
8281
8282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_facename_set",kwnames,&obj0,&obj1)) goto fail;
8283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8284 if (SWIG_arg_fail(1)) SWIG_fail;
8285 {
8286 arg2 = wxString_in_helper(obj1);
8287 if (arg2 == NULL) SWIG_fail;
8288 temp2 = true;
8289 }
8290 if (arg1) (arg1)->facename = *arg2;
8291
8292 Py_INCREF(Py_None); resultobj = Py_None;
8293 {
8294 if (temp2)
8295 delete arg2;
8296 }
8297 return resultobj;
8298 fail:
8299 {
8300 if (temp2)
8301 delete arg2;
8302 }
8303 return NULL;
8304 }
8305
8306
8307 static PyObject *_wrap_NativeEncodingInfo_facename_get(PyObject *, PyObject *args, PyObject *kwargs) {
8308 PyObject *resultobj;
8309 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8310 wxString *result;
8311 PyObject * obj0 = 0 ;
8312 char *kwnames[] = {
8313 (char *) "self", NULL
8314 };
8315
8316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_facename_get",kwnames,&obj0)) goto fail;
8317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8318 if (SWIG_arg_fail(1)) SWIG_fail;
8319 result = (wxString *)& ((arg1)->facename);
8320
8321 {
8322 #if wxUSE_UNICODE
8323 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8324 #else
8325 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8326 #endif
8327 }
8328 return resultobj;
8329 fail:
8330 return NULL;
8331 }
8332
8333
8334 static PyObject *_wrap_NativeEncodingInfo_encoding_set(PyObject *, PyObject *args, PyObject *kwargs) {
8335 PyObject *resultobj;
8336 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8337 wxFontEncoding arg2 ;
8338 PyObject * obj0 = 0 ;
8339 PyObject * obj1 = 0 ;
8340 char *kwnames[] = {
8341 (char *) "self",(char *) "encoding", NULL
8342 };
8343
8344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_encoding_set",kwnames,&obj0,&obj1)) goto fail;
8345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8346 if (SWIG_arg_fail(1)) SWIG_fail;
8347 {
8348 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8349 if (SWIG_arg_fail(2)) SWIG_fail;
8350 }
8351 if (arg1) (arg1)->encoding = (wxFontEncoding )arg2;
8352
8353 Py_INCREF(Py_None); resultobj = Py_None;
8354 return resultobj;
8355 fail:
8356 return NULL;
8357 }
8358
8359
8360 static PyObject *_wrap_NativeEncodingInfo_encoding_get(PyObject *, PyObject *args, PyObject *kwargs) {
8361 PyObject *resultobj;
8362 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8363 wxFontEncoding result;
8364 PyObject * obj0 = 0 ;
8365 char *kwnames[] = {
8366 (char *) "self", NULL
8367 };
8368
8369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_encoding_get",kwnames,&obj0)) goto fail;
8370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8371 if (SWIG_arg_fail(1)) SWIG_fail;
8372 result = (wxFontEncoding) ((arg1)->encoding);
8373
8374 resultobj = SWIG_From_int((result));
8375 return resultobj;
8376 fail:
8377 return NULL;
8378 }
8379
8380
8381 static PyObject *_wrap_new_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8382 PyObject *resultobj;
8383 wxNativeEncodingInfo *result;
8384 char *kwnames[] = {
8385 NULL
8386 };
8387
8388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeEncodingInfo",kwnames)) goto fail;
8389 {
8390 PyThreadState* __tstate = wxPyBeginAllowThreads();
8391 result = (wxNativeEncodingInfo *)new wxNativeEncodingInfo();
8392
8393 wxPyEndAllowThreads(__tstate);
8394 if (PyErr_Occurred()) SWIG_fail;
8395 }
8396 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 1);
8397 return resultobj;
8398 fail:
8399 return NULL;
8400 }
8401
8402
8403 static PyObject *_wrap_delete_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8404 PyObject *resultobj;
8405 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8406 PyObject * obj0 = 0 ;
8407 char *kwnames[] = {
8408 (char *) "self", NULL
8409 };
8410
8411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeEncodingInfo",kwnames,&obj0)) goto fail;
8412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8413 if (SWIG_arg_fail(1)) SWIG_fail;
8414 {
8415 PyThreadState* __tstate = wxPyBeginAllowThreads();
8416 delete arg1;
8417
8418 wxPyEndAllowThreads(__tstate);
8419 if (PyErr_Occurred()) SWIG_fail;
8420 }
8421 Py_INCREF(Py_None); resultobj = Py_None;
8422 return resultobj;
8423 fail:
8424 return NULL;
8425 }
8426
8427
8428 static PyObject *_wrap_NativeEncodingInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
8429 PyObject *resultobj;
8430 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8431 wxString *arg2 = 0 ;
8432 bool result;
8433 bool temp2 = false ;
8434 PyObject * obj0 = 0 ;
8435 PyObject * obj1 = 0 ;
8436 char *kwnames[] = {
8437 (char *) "self",(char *) "s", NULL
8438 };
8439
8440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
8441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8442 if (SWIG_arg_fail(1)) SWIG_fail;
8443 {
8444 arg2 = wxString_in_helper(obj1);
8445 if (arg2 == NULL) SWIG_fail;
8446 temp2 = true;
8447 }
8448 {
8449 PyThreadState* __tstate = wxPyBeginAllowThreads();
8450 result = (bool)(arg1)->FromString((wxString const &)*arg2);
8451
8452 wxPyEndAllowThreads(__tstate);
8453 if (PyErr_Occurred()) SWIG_fail;
8454 }
8455 {
8456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8457 }
8458 {
8459 if (temp2)
8460 delete arg2;
8461 }
8462 return resultobj;
8463 fail:
8464 {
8465 if (temp2)
8466 delete arg2;
8467 }
8468 return NULL;
8469 }
8470
8471
8472 static PyObject *_wrap_NativeEncodingInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
8473 PyObject *resultobj;
8474 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8475 wxString result;
8476 PyObject * obj0 = 0 ;
8477 char *kwnames[] = {
8478 (char *) "self", NULL
8479 };
8480
8481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_ToString",kwnames,&obj0)) goto fail;
8482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8483 if (SWIG_arg_fail(1)) SWIG_fail;
8484 {
8485 PyThreadState* __tstate = wxPyBeginAllowThreads();
8486 result = ((wxNativeEncodingInfo const *)arg1)->ToString();
8487
8488 wxPyEndAllowThreads(__tstate);
8489 if (PyErr_Occurred()) SWIG_fail;
8490 }
8491 {
8492 #if wxUSE_UNICODE
8493 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8494 #else
8495 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8496 #endif
8497 }
8498 return resultobj;
8499 fail:
8500 return NULL;
8501 }
8502
8503
8504 static PyObject * NativeEncodingInfo_swigregister(PyObject *, PyObject *args) {
8505 PyObject *obj;
8506 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8507 SWIG_TypeClientData(SWIGTYPE_p_wxNativeEncodingInfo, obj);
8508 Py_INCREF(obj);
8509 return Py_BuildValue((char *)"");
8510 }
8511 static PyObject *_wrap_GetNativeFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8512 PyObject *resultobj;
8513 wxFontEncoding arg1 ;
8514 wxNativeEncodingInfo *result;
8515 PyObject * obj0 = 0 ;
8516 char *kwnames[] = {
8517 (char *) "encoding", NULL
8518 };
8519
8520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetNativeFontEncoding",kwnames,&obj0)) goto fail;
8521 {
8522 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8523 if (SWIG_arg_fail(1)) SWIG_fail;
8524 }
8525 {
8526 PyThreadState* __tstate = wxPyBeginAllowThreads();
8527 result = (wxNativeEncodingInfo *)wxGetNativeFontEncoding((wxFontEncoding )arg1);
8528
8529 wxPyEndAllowThreads(__tstate);
8530 if (PyErr_Occurred()) SWIG_fail;
8531 }
8532 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 0);
8533 return resultobj;
8534 fail:
8535 return NULL;
8536 }
8537
8538
8539 static PyObject *_wrap_TestFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8540 PyObject *resultobj;
8541 wxNativeEncodingInfo *arg1 = 0 ;
8542 bool result;
8543 PyObject * obj0 = 0 ;
8544 char *kwnames[] = {
8545 (char *) "info", NULL
8546 };
8547
8548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TestFontEncoding",kwnames,&obj0)) goto fail;
8549 {
8550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8551 if (SWIG_arg_fail(1)) SWIG_fail;
8552 if (arg1 == NULL) {
8553 SWIG_null_ref("wxNativeEncodingInfo");
8554 }
8555 if (SWIG_arg_fail(1)) SWIG_fail;
8556 }
8557 {
8558 PyThreadState* __tstate = wxPyBeginAllowThreads();
8559 result = (bool)wxTestFontEncoding((wxNativeEncodingInfo const &)*arg1);
8560
8561 wxPyEndAllowThreads(__tstate);
8562 if (PyErr_Occurred()) SWIG_fail;
8563 }
8564 {
8565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8566 }
8567 return resultobj;
8568 fail:
8569 return NULL;
8570 }
8571
8572
8573 static PyObject *_wrap_new_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
8574 PyObject *resultobj;
8575 wxFontMapper *result;
8576 char *kwnames[] = {
8577 NULL
8578 };
8579
8580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontMapper",kwnames)) goto fail;
8581 {
8582 PyThreadState* __tstate = wxPyBeginAllowThreads();
8583 result = (wxFontMapper *)new wxFontMapper();
8584
8585 wxPyEndAllowThreads(__tstate);
8586 if (PyErr_Occurred()) SWIG_fail;
8587 }
8588 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 1);
8589 return resultobj;
8590 fail:
8591 return NULL;
8592 }
8593
8594
8595 static PyObject *_wrap_delete_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
8596 PyObject *resultobj;
8597 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8598 PyObject * obj0 = 0 ;
8599 char *kwnames[] = {
8600 (char *) "self", NULL
8601 };
8602
8603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontMapper",kwnames,&obj0)) goto fail;
8604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8605 if (SWIG_arg_fail(1)) SWIG_fail;
8606 {
8607 PyThreadState* __tstate = wxPyBeginAllowThreads();
8608 delete arg1;
8609
8610 wxPyEndAllowThreads(__tstate);
8611 if (PyErr_Occurred()) SWIG_fail;
8612 }
8613 Py_INCREF(Py_None); resultobj = Py_None;
8614 return resultobj;
8615 fail:
8616 return NULL;
8617 }
8618
8619
8620 static PyObject *_wrap_FontMapper_Get(PyObject *, PyObject *args, PyObject *kwargs) {
8621 PyObject *resultobj;
8622 wxFontMapper *result;
8623 char *kwnames[] = {
8624 NULL
8625 };
8626
8627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_Get",kwnames)) goto fail;
8628 {
8629 PyThreadState* __tstate = wxPyBeginAllowThreads();
8630 result = (wxFontMapper *)wxFontMapper::Get();
8631
8632 wxPyEndAllowThreads(__tstate);
8633 if (PyErr_Occurred()) SWIG_fail;
8634 }
8635 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
8636 return resultobj;
8637 fail:
8638 return NULL;
8639 }
8640
8641
8642 static PyObject *_wrap_FontMapper_Set(PyObject *, PyObject *args, PyObject *kwargs) {
8643 PyObject *resultobj;
8644 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8645 wxFontMapper *result;
8646 PyObject * obj0 = 0 ;
8647 char *kwnames[] = {
8648 (char *) "mapper", NULL
8649 };
8650
8651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_Set",kwnames,&obj0)) goto fail;
8652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8653 if (SWIG_arg_fail(1)) SWIG_fail;
8654 {
8655 PyThreadState* __tstate = wxPyBeginAllowThreads();
8656 result = (wxFontMapper *)wxFontMapper::Set(arg1);
8657
8658 wxPyEndAllowThreads(__tstate);
8659 if (PyErr_Occurred()) SWIG_fail;
8660 }
8661 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
8662 return resultobj;
8663 fail:
8664 return NULL;
8665 }
8666
8667
8668 static PyObject *_wrap_FontMapper_CharsetToEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8669 PyObject *resultobj;
8670 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8671 wxString *arg2 = 0 ;
8672 bool arg3 = (bool) true ;
8673 wxFontEncoding result;
8674 bool temp2 = false ;
8675 PyObject * obj0 = 0 ;
8676 PyObject * obj1 = 0 ;
8677 PyObject * obj2 = 0 ;
8678 char *kwnames[] = {
8679 (char *) "self",(char *) "charset",(char *) "interactive", NULL
8680 };
8681
8682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_CharsetToEncoding",kwnames,&obj0,&obj1,&obj2)) goto fail;
8683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8684 if (SWIG_arg_fail(1)) SWIG_fail;
8685 {
8686 arg2 = wxString_in_helper(obj1);
8687 if (arg2 == NULL) SWIG_fail;
8688 temp2 = true;
8689 }
8690 if (obj2) {
8691 {
8692 arg3 = (bool)(SWIG_As_bool(obj2));
8693 if (SWIG_arg_fail(3)) SWIG_fail;
8694 }
8695 }
8696 {
8697 PyThreadState* __tstate = wxPyBeginAllowThreads();
8698 result = (wxFontEncoding)(arg1)->CharsetToEncoding((wxString const &)*arg2,arg3);
8699
8700 wxPyEndAllowThreads(__tstate);
8701 if (PyErr_Occurred()) SWIG_fail;
8702 }
8703 resultobj = SWIG_From_int((result));
8704 {
8705 if (temp2)
8706 delete arg2;
8707 }
8708 return resultobj;
8709 fail:
8710 {
8711 if (temp2)
8712 delete arg2;
8713 }
8714 return NULL;
8715 }
8716
8717
8718 static PyObject *_wrap_FontMapper_GetSupportedEncodingsCount(PyObject *, PyObject *args, PyObject *kwargs) {
8719 PyObject *resultobj;
8720 size_t result;
8721 char *kwnames[] = {
8722 NULL
8723 };
8724
8725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetSupportedEncodingsCount",kwnames)) goto fail;
8726 {
8727 PyThreadState* __tstate = wxPyBeginAllowThreads();
8728 result = (size_t)wxFontMapper::GetSupportedEncodingsCount();
8729
8730 wxPyEndAllowThreads(__tstate);
8731 if (PyErr_Occurred()) SWIG_fail;
8732 }
8733 {
8734 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
8735 }
8736 return resultobj;
8737 fail:
8738 return NULL;
8739 }
8740
8741
8742 static PyObject *_wrap_FontMapper_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8743 PyObject *resultobj;
8744 size_t arg1 ;
8745 wxFontEncoding result;
8746 PyObject * obj0 = 0 ;
8747 char *kwnames[] = {
8748 (char *) "n", NULL
8749 };
8750
8751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncoding",kwnames,&obj0)) goto fail;
8752 {
8753 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8754 if (SWIG_arg_fail(1)) SWIG_fail;
8755 }
8756 {
8757 PyThreadState* __tstate = wxPyBeginAllowThreads();
8758 result = (wxFontEncoding)wxFontMapper::GetEncoding(arg1);
8759
8760 wxPyEndAllowThreads(__tstate);
8761 if (PyErr_Occurred()) SWIG_fail;
8762 }
8763 resultobj = SWIG_From_int((result));
8764 return resultobj;
8765 fail:
8766 return NULL;
8767 }
8768
8769
8770 static PyObject *_wrap_FontMapper_GetEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
8771 PyObject *resultobj;
8772 wxFontEncoding arg1 ;
8773 wxString result;
8774 PyObject * obj0 = 0 ;
8775 char *kwnames[] = {
8776 (char *) "encoding", NULL
8777 };
8778
8779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingName",kwnames,&obj0)) goto fail;
8780 {
8781 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8782 if (SWIG_arg_fail(1)) SWIG_fail;
8783 }
8784 {
8785 PyThreadState* __tstate = wxPyBeginAllowThreads();
8786 result = wxFontMapper::GetEncodingName((wxFontEncoding )arg1);
8787
8788 wxPyEndAllowThreads(__tstate);
8789 if (PyErr_Occurred()) SWIG_fail;
8790 }
8791 {
8792 #if wxUSE_UNICODE
8793 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8794 #else
8795 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8796 #endif
8797 }
8798 return resultobj;
8799 fail:
8800 return NULL;
8801 }
8802
8803
8804 static PyObject *_wrap_FontMapper_GetEncodingDescription(PyObject *, PyObject *args, PyObject *kwargs) {
8805 PyObject *resultobj;
8806 wxFontEncoding arg1 ;
8807 wxString result;
8808 PyObject * obj0 = 0 ;
8809 char *kwnames[] = {
8810 (char *) "encoding", NULL
8811 };
8812
8813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingDescription",kwnames,&obj0)) goto fail;
8814 {
8815 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8816 if (SWIG_arg_fail(1)) SWIG_fail;
8817 }
8818 {
8819 PyThreadState* __tstate = wxPyBeginAllowThreads();
8820 result = wxFontMapper::GetEncodingDescription((wxFontEncoding )arg1);
8821
8822 wxPyEndAllowThreads(__tstate);
8823 if (PyErr_Occurred()) SWIG_fail;
8824 }
8825 {
8826 #if wxUSE_UNICODE
8827 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8828 #else
8829 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8830 #endif
8831 }
8832 return resultobj;
8833 fail:
8834 return NULL;
8835 }
8836
8837
8838 static PyObject *_wrap_FontMapper_GetEncodingFromName(PyObject *, PyObject *args, PyObject *kwargs) {
8839 PyObject *resultobj;
8840 wxString *arg1 = 0 ;
8841 wxFontEncoding result;
8842 bool temp1 = false ;
8843 PyObject * obj0 = 0 ;
8844 char *kwnames[] = {
8845 (char *) "name", NULL
8846 };
8847
8848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingFromName",kwnames,&obj0)) goto fail;
8849 {
8850 arg1 = wxString_in_helper(obj0);
8851 if (arg1 == NULL) SWIG_fail;
8852 temp1 = true;
8853 }
8854 {
8855 PyThreadState* __tstate = wxPyBeginAllowThreads();
8856 result = (wxFontEncoding)wxFontMapper::GetEncodingFromName((wxString const &)*arg1);
8857
8858 wxPyEndAllowThreads(__tstate);
8859 if (PyErr_Occurred()) SWIG_fail;
8860 }
8861 resultobj = SWIG_From_int((result));
8862 {
8863 if (temp1)
8864 delete arg1;
8865 }
8866 return resultobj;
8867 fail:
8868 {
8869 if (temp1)
8870 delete arg1;
8871 }
8872 return NULL;
8873 }
8874
8875
8876 static PyObject *_wrap_FontMapper_SetConfig(PyObject *, PyObject *args, PyObject *kwargs) {
8877 PyObject *resultobj;
8878 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8879 wxConfigBase *arg2 = (wxConfigBase *) 0 ;
8880 PyObject * obj0 = 0 ;
8881 PyObject * obj1 = 0 ;
8882 char *kwnames[] = {
8883 (char *) "self",(char *) "config", NULL
8884 };
8885
8886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfig",kwnames,&obj0,&obj1)) goto fail;
8887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8888 if (SWIG_arg_fail(1)) SWIG_fail;
8889 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
8890 if (SWIG_arg_fail(2)) SWIG_fail;
8891 {
8892 PyThreadState* __tstate = wxPyBeginAllowThreads();
8893 (arg1)->SetConfig(arg2);
8894
8895 wxPyEndAllowThreads(__tstate);
8896 if (PyErr_Occurred()) SWIG_fail;
8897 }
8898 Py_INCREF(Py_None); resultobj = Py_None;
8899 return resultobj;
8900 fail:
8901 return NULL;
8902 }
8903
8904
8905 static PyObject *_wrap_FontMapper_SetConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
8906 PyObject *resultobj;
8907 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8908 wxString *arg2 = 0 ;
8909 bool temp2 = false ;
8910 PyObject * obj0 = 0 ;
8911 PyObject * obj1 = 0 ;
8912 char *kwnames[] = {
8913 (char *) "self",(char *) "prefix", NULL
8914 };
8915
8916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfigPath",kwnames,&obj0,&obj1)) goto fail;
8917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8918 if (SWIG_arg_fail(1)) SWIG_fail;
8919 {
8920 arg2 = wxString_in_helper(obj1);
8921 if (arg2 == NULL) SWIG_fail;
8922 temp2 = true;
8923 }
8924 {
8925 PyThreadState* __tstate = wxPyBeginAllowThreads();
8926 (arg1)->SetConfigPath((wxString const &)*arg2);
8927
8928 wxPyEndAllowThreads(__tstate);
8929 if (PyErr_Occurred()) SWIG_fail;
8930 }
8931 Py_INCREF(Py_None); resultobj = Py_None;
8932 {
8933 if (temp2)
8934 delete arg2;
8935 }
8936 return resultobj;
8937 fail:
8938 {
8939 if (temp2)
8940 delete arg2;
8941 }
8942 return NULL;
8943 }
8944
8945
8946 static PyObject *_wrap_FontMapper_GetDefaultConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
8947 PyObject *resultobj;
8948 wxString result;
8949 char *kwnames[] = {
8950 NULL
8951 };
8952
8953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetDefaultConfigPath",kwnames)) goto fail;
8954 {
8955 PyThreadState* __tstate = wxPyBeginAllowThreads();
8956 result = wxFontMapper::GetDefaultConfigPath();
8957
8958 wxPyEndAllowThreads(__tstate);
8959 if (PyErr_Occurred()) SWIG_fail;
8960 }
8961 {
8962 #if wxUSE_UNICODE
8963 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8964 #else
8965 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8966 #endif
8967 }
8968 return resultobj;
8969 fail:
8970 return NULL;
8971 }
8972
8973
8974 static PyObject *_wrap_FontMapper_GetAltForEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8975 PyObject *resultobj;
8976 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8977 wxFontEncoding arg2 ;
8978 wxString const &arg3_defvalue = wxPyEmptyString ;
8979 wxString *arg3 = (wxString *) &arg3_defvalue ;
8980 bool arg4 = (bool) true ;
8981 PyObject *result;
8982 bool temp3 = false ;
8983 PyObject * obj0 = 0 ;
8984 PyObject * obj1 = 0 ;
8985 PyObject * obj2 = 0 ;
8986 PyObject * obj3 = 0 ;
8987 char *kwnames[] = {
8988 (char *) "self",(char *) "encoding",(char *) "facename",(char *) "interactive", NULL
8989 };
8990
8991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:FontMapper_GetAltForEncoding",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8993 if (SWIG_arg_fail(1)) SWIG_fail;
8994 {
8995 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8996 if (SWIG_arg_fail(2)) SWIG_fail;
8997 }
8998 if (obj2) {
8999 {
9000 arg3 = wxString_in_helper(obj2);
9001 if (arg3 == NULL) SWIG_fail;
9002 temp3 = true;
9003 }
9004 }
9005 if (obj3) {
9006 {
9007 arg4 = (bool)(SWIG_As_bool(obj3));
9008 if (SWIG_arg_fail(4)) SWIG_fail;
9009 }
9010 }
9011 {
9012 PyThreadState* __tstate = wxPyBeginAllowThreads();
9013 result = (PyObject *)wxFontMapper_GetAltForEncoding(arg1,(wxFontEncoding )arg2,(wxString const &)*arg3,arg4);
9014
9015 wxPyEndAllowThreads(__tstate);
9016 if (PyErr_Occurred()) SWIG_fail;
9017 }
9018 resultobj = result;
9019 {
9020 if (temp3)
9021 delete arg3;
9022 }
9023 return resultobj;
9024 fail:
9025 {
9026 if (temp3)
9027 delete arg3;
9028 }
9029 return NULL;
9030 }
9031
9032
9033 static PyObject *_wrap_FontMapper_IsEncodingAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
9034 PyObject *resultobj;
9035 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9036 wxFontEncoding arg2 ;
9037 wxString const &arg3_defvalue = wxPyEmptyString ;
9038 wxString *arg3 = (wxString *) &arg3_defvalue ;
9039 bool result;
9040 bool temp3 = false ;
9041 PyObject * obj0 = 0 ;
9042 PyObject * obj1 = 0 ;
9043 PyObject * obj2 = 0 ;
9044 char *kwnames[] = {
9045 (char *) "self",(char *) "encoding",(char *) "facename", NULL
9046 };
9047
9048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_IsEncodingAvailable",kwnames,&obj0,&obj1,&obj2)) goto fail;
9049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9050 if (SWIG_arg_fail(1)) SWIG_fail;
9051 {
9052 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9053 if (SWIG_arg_fail(2)) SWIG_fail;
9054 }
9055 if (obj2) {
9056 {
9057 arg3 = wxString_in_helper(obj2);
9058 if (arg3 == NULL) SWIG_fail;
9059 temp3 = true;
9060 }
9061 }
9062 {
9063 PyThreadState* __tstate = wxPyBeginAllowThreads();
9064 result = (bool)(arg1)->IsEncodingAvailable((wxFontEncoding )arg2,(wxString const &)*arg3);
9065
9066 wxPyEndAllowThreads(__tstate);
9067 if (PyErr_Occurred()) SWIG_fail;
9068 }
9069 {
9070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9071 }
9072 {
9073 if (temp3)
9074 delete arg3;
9075 }
9076 return resultobj;
9077 fail:
9078 {
9079 if (temp3)
9080 delete arg3;
9081 }
9082 return NULL;
9083 }
9084
9085
9086 static PyObject *_wrap_FontMapper_SetDialogParent(PyObject *, PyObject *args, PyObject *kwargs) {
9087 PyObject *resultobj;
9088 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9089 wxWindow *arg2 = (wxWindow *) 0 ;
9090 PyObject * obj0 = 0 ;
9091 PyObject * obj1 = 0 ;
9092 char *kwnames[] = {
9093 (char *) "self",(char *) "parent", NULL
9094 };
9095
9096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogParent",kwnames,&obj0,&obj1)) goto fail;
9097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9098 if (SWIG_arg_fail(1)) SWIG_fail;
9099 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
9100 if (SWIG_arg_fail(2)) SWIG_fail;
9101 {
9102 PyThreadState* __tstate = wxPyBeginAllowThreads();
9103 (arg1)->SetDialogParent(arg2);
9104
9105 wxPyEndAllowThreads(__tstate);
9106 if (PyErr_Occurred()) SWIG_fail;
9107 }
9108 Py_INCREF(Py_None); resultobj = Py_None;
9109 return resultobj;
9110 fail:
9111 return NULL;
9112 }
9113
9114
9115 static PyObject *_wrap_FontMapper_SetDialogTitle(PyObject *, PyObject *args, PyObject *kwargs) {
9116 PyObject *resultobj;
9117 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9118 wxString *arg2 = 0 ;
9119 bool temp2 = false ;
9120 PyObject * obj0 = 0 ;
9121 PyObject * obj1 = 0 ;
9122 char *kwnames[] = {
9123 (char *) "self",(char *) "title", NULL
9124 };
9125
9126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogTitle",kwnames,&obj0,&obj1)) goto fail;
9127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9128 if (SWIG_arg_fail(1)) SWIG_fail;
9129 {
9130 arg2 = wxString_in_helper(obj1);
9131 if (arg2 == NULL) SWIG_fail;
9132 temp2 = true;
9133 }
9134 {
9135 PyThreadState* __tstate = wxPyBeginAllowThreads();
9136 (arg1)->SetDialogTitle((wxString const &)*arg2);
9137
9138 wxPyEndAllowThreads(__tstate);
9139 if (PyErr_Occurred()) SWIG_fail;
9140 }
9141 Py_INCREF(Py_None); resultobj = Py_None;
9142 {
9143 if (temp2)
9144 delete arg2;
9145 }
9146 return resultobj;
9147 fail:
9148 {
9149 if (temp2)
9150 delete arg2;
9151 }
9152 return NULL;
9153 }
9154
9155
9156 static PyObject * FontMapper_swigregister(PyObject *, PyObject *args) {
9157 PyObject *obj;
9158 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9159 SWIG_TypeClientData(SWIGTYPE_p_wxFontMapper, obj);
9160 Py_INCREF(obj);
9161 return Py_BuildValue((char *)"");
9162 }
9163 static PyObject *_wrap_new_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9164 PyObject *resultobj;
9165 int arg1 ;
9166 int arg2 ;
9167 int arg3 ;
9168 int arg4 ;
9169 bool arg5 = (bool) false ;
9170 wxString const &arg6_defvalue = wxPyEmptyString ;
9171 wxString *arg6 = (wxString *) &arg6_defvalue ;
9172 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9173 wxFont *result;
9174 bool temp6 = false ;
9175 PyObject * obj0 = 0 ;
9176 PyObject * obj1 = 0 ;
9177 PyObject * obj2 = 0 ;
9178 PyObject * obj3 = 0 ;
9179 PyObject * obj4 = 0 ;
9180 PyObject * obj5 = 0 ;
9181 PyObject * obj6 = 0 ;
9182 char *kwnames[] = {
9183 (char *) "pointSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "face",(char *) "encoding", NULL
9184 };
9185
9186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_Font",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9187 {
9188 arg1 = (int)(SWIG_As_int(obj0));
9189 if (SWIG_arg_fail(1)) SWIG_fail;
9190 }
9191 {
9192 arg2 = (int)(SWIG_As_int(obj1));
9193 if (SWIG_arg_fail(2)) SWIG_fail;
9194 }
9195 {
9196 arg3 = (int)(SWIG_As_int(obj2));
9197 if (SWIG_arg_fail(3)) SWIG_fail;
9198 }
9199 {
9200 arg4 = (int)(SWIG_As_int(obj3));
9201 if (SWIG_arg_fail(4)) SWIG_fail;
9202 }
9203 if (obj4) {
9204 {
9205 arg5 = (bool)(SWIG_As_bool(obj4));
9206 if (SWIG_arg_fail(5)) SWIG_fail;
9207 }
9208 }
9209 if (obj5) {
9210 {
9211 arg6 = wxString_in_helper(obj5);
9212 if (arg6 == NULL) SWIG_fail;
9213 temp6 = true;
9214 }
9215 }
9216 if (obj6) {
9217 {
9218 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
9219 if (SWIG_arg_fail(7)) SWIG_fail;
9220 }
9221 }
9222 {
9223 if (!wxPyCheckForApp()) SWIG_fail;
9224 PyThreadState* __tstate = wxPyBeginAllowThreads();
9225 result = (wxFont *)new wxFont(arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
9226
9227 wxPyEndAllowThreads(__tstate);
9228 if (PyErr_Occurred()) SWIG_fail;
9229 }
9230 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9231 {
9232 if (temp6)
9233 delete arg6;
9234 }
9235 return resultobj;
9236 fail:
9237 {
9238 if (temp6)
9239 delete arg6;
9240 }
9241 return NULL;
9242 }
9243
9244
9245 static PyObject *_wrap_delete_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9246 PyObject *resultobj;
9247 wxFont *arg1 = (wxFont *) 0 ;
9248 PyObject * obj0 = 0 ;
9249 char *kwnames[] = {
9250 (char *) "self", NULL
9251 };
9252
9253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Font",kwnames,&obj0)) goto fail;
9254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9255 if (SWIG_arg_fail(1)) SWIG_fail;
9256 {
9257 PyThreadState* __tstate = wxPyBeginAllowThreads();
9258 delete arg1;
9259
9260 wxPyEndAllowThreads(__tstate);
9261 if (PyErr_Occurred()) SWIG_fail;
9262 }
9263 Py_INCREF(Py_None); resultobj = Py_None;
9264 return resultobj;
9265 fail:
9266 return NULL;
9267 }
9268
9269
9270 static PyObject *_wrap_new_FontFromNativeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9271 PyObject *resultobj;
9272 wxNativeFontInfo *arg1 = 0 ;
9273 wxFont *result;
9274 PyObject * obj0 = 0 ;
9275 char *kwnames[] = {
9276 (char *) "info", NULL
9277 };
9278
9279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfo",kwnames,&obj0)) goto fail;
9280 {
9281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
9282 if (SWIG_arg_fail(1)) SWIG_fail;
9283 if (arg1 == NULL) {
9284 SWIG_null_ref("wxNativeFontInfo");
9285 }
9286 if (SWIG_arg_fail(1)) SWIG_fail;
9287 }
9288 {
9289 if (!wxPyCheckForApp()) SWIG_fail;
9290 PyThreadState* __tstate = wxPyBeginAllowThreads();
9291 result = (wxFont *)new wxFont((wxNativeFontInfo const &)*arg1);
9292
9293 wxPyEndAllowThreads(__tstate);
9294 if (PyErr_Occurred()) SWIG_fail;
9295 }
9296 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9297 return resultobj;
9298 fail:
9299 return NULL;
9300 }
9301
9302
9303 static PyObject *_wrap_new_FontFromNativeInfoString(PyObject *, PyObject *args, PyObject *kwargs) {
9304 PyObject *resultobj;
9305 wxString *arg1 = 0 ;
9306 wxFont *result;
9307 bool temp1 = false ;
9308 PyObject * obj0 = 0 ;
9309 char *kwnames[] = {
9310 (char *) "info", NULL
9311 };
9312
9313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfoString",kwnames,&obj0)) goto fail;
9314 {
9315 arg1 = wxString_in_helper(obj0);
9316 if (arg1 == NULL) SWIG_fail;
9317 temp1 = true;
9318 }
9319 {
9320 if (!wxPyCheckForApp()) SWIG_fail;
9321 PyThreadState* __tstate = wxPyBeginAllowThreads();
9322 result = (wxFont *)new_wxFont((wxString const &)*arg1);
9323
9324 wxPyEndAllowThreads(__tstate);
9325 if (PyErr_Occurred()) SWIG_fail;
9326 }
9327 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9328 {
9329 if (temp1)
9330 delete arg1;
9331 }
9332 return resultobj;
9333 fail:
9334 {
9335 if (temp1)
9336 delete arg1;
9337 }
9338 return NULL;
9339 }
9340
9341
9342 static PyObject *_wrap_new_Font2(PyObject *, PyObject *args, PyObject *kwargs) {
9343 PyObject *resultobj;
9344 int arg1 ;
9345 wxFontFamily arg2 ;
9346 int arg3 = (int) wxFONTFLAG_DEFAULT ;
9347 wxString const &arg4_defvalue = wxPyEmptyString ;
9348 wxString *arg4 = (wxString *) &arg4_defvalue ;
9349 wxFontEncoding arg5 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9350 wxFont *result;
9351 bool temp4 = false ;
9352 PyObject * obj0 = 0 ;
9353 PyObject * obj1 = 0 ;
9354 PyObject * obj2 = 0 ;
9355 PyObject * obj3 = 0 ;
9356 PyObject * obj4 = 0 ;
9357 char *kwnames[] = {
9358 (char *) "pointSize",(char *) "family",(char *) "flags",(char *) "face",(char *) "encoding", NULL
9359 };
9360
9361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_Font2",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
9362 {
9363 arg1 = (int)(SWIG_As_int(obj0));
9364 if (SWIG_arg_fail(1)) SWIG_fail;
9365 }
9366 {
9367 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
9368 if (SWIG_arg_fail(2)) SWIG_fail;
9369 }
9370 if (obj2) {
9371 {
9372 arg3 = (int)(SWIG_As_int(obj2));
9373 if (SWIG_arg_fail(3)) SWIG_fail;
9374 }
9375 }
9376 if (obj3) {
9377 {
9378 arg4 = wxString_in_helper(obj3);
9379 if (arg4 == NULL) SWIG_fail;
9380 temp4 = true;
9381 }
9382 }
9383 if (obj4) {
9384 {
9385 arg5 = (wxFontEncoding)(SWIG_As_int(obj4));
9386 if (SWIG_arg_fail(5)) SWIG_fail;
9387 }
9388 }
9389 {
9390 if (!wxPyCheckForApp()) SWIG_fail;
9391 PyThreadState* __tstate = wxPyBeginAllowThreads();
9392 result = (wxFont *)new_wxFont(arg1,(wxFontFamily )arg2,arg3,(wxString const &)*arg4,(wxFontEncoding )arg5);
9393
9394 wxPyEndAllowThreads(__tstate);
9395 if (PyErr_Occurred()) SWIG_fail;
9396 }
9397 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9398 {
9399 if (temp4)
9400 delete arg4;
9401 }
9402 return resultobj;
9403 fail:
9404 {
9405 if (temp4)
9406 delete arg4;
9407 }
9408 return NULL;
9409 }
9410
9411
9412 static PyObject *_wrap_new_FontFromPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
9413 PyObject *resultobj;
9414 wxSize *arg1 = 0 ;
9415 int arg2 ;
9416 int arg3 ;
9417 int arg4 ;
9418 bool arg5 = (bool) false ;
9419 wxString const &arg6_defvalue = wxEmptyString ;
9420 wxString *arg6 = (wxString *) &arg6_defvalue ;
9421 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9422 wxFont *result;
9423 wxSize temp1 ;
9424 bool temp6 = false ;
9425 PyObject * obj0 = 0 ;
9426 PyObject * obj1 = 0 ;
9427 PyObject * obj2 = 0 ;
9428 PyObject * obj3 = 0 ;
9429 PyObject * obj4 = 0 ;
9430 PyObject * obj5 = 0 ;
9431 PyObject * obj6 = 0 ;
9432 char *kwnames[] = {
9433 (char *) "pixelSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underlined",(char *) "face",(char *) "encoding", NULL
9434 };
9435
9436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_FontFromPixelSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9437 {
9438 arg1 = &temp1;
9439 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
9440 }
9441 {
9442 arg2 = (int)(SWIG_As_int(obj1));
9443 if (SWIG_arg_fail(2)) SWIG_fail;
9444 }
9445 {
9446 arg3 = (int)(SWIG_As_int(obj2));
9447 if (SWIG_arg_fail(3)) SWIG_fail;
9448 }
9449 {
9450 arg4 = (int)(SWIG_As_int(obj3));
9451 if (SWIG_arg_fail(4)) SWIG_fail;
9452 }
9453 if (obj4) {
9454 {
9455 arg5 = (bool)(SWIG_As_bool(obj4));
9456 if (SWIG_arg_fail(5)) SWIG_fail;
9457 }
9458 }
9459 if (obj5) {
9460 {
9461 arg6 = wxString_in_helper(obj5);
9462 if (arg6 == NULL) SWIG_fail;
9463 temp6 = true;
9464 }
9465 }
9466 if (obj6) {
9467 {
9468 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
9469 if (SWIG_arg_fail(7)) SWIG_fail;
9470 }
9471 }
9472 {
9473 if (!wxPyCheckForApp()) SWIG_fail;
9474 PyThreadState* __tstate = wxPyBeginAllowThreads();
9475 result = (wxFont *)new_wxFont((wxSize const &)*arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
9476
9477 wxPyEndAllowThreads(__tstate);
9478 if (PyErr_Occurred()) SWIG_fail;
9479 }
9480 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9481 {
9482 if (temp6)
9483 delete arg6;
9484 }
9485 return resultobj;
9486 fail:
9487 {
9488 if (temp6)
9489 delete arg6;
9490 }
9491 return NULL;
9492 }
9493
9494
9495 static PyObject *_wrap_Font_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
9496 PyObject *resultobj;
9497 wxFont *arg1 = (wxFont *) 0 ;
9498 bool result;
9499 PyObject * obj0 = 0 ;
9500 char *kwnames[] = {
9501 (char *) "self", NULL
9502 };
9503
9504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_Ok",kwnames,&obj0)) goto fail;
9505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9506 if (SWIG_arg_fail(1)) SWIG_fail;
9507 {
9508 PyThreadState* __tstate = wxPyBeginAllowThreads();
9509 result = (bool)((wxFont const *)arg1)->Ok();
9510
9511 wxPyEndAllowThreads(__tstate);
9512 if (PyErr_Occurred()) SWIG_fail;
9513 }
9514 {
9515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9516 }
9517 return resultobj;
9518 fail:
9519 return NULL;
9520 }
9521
9522
9523 static PyObject *_wrap_Font___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
9524 PyObject *resultobj;
9525 wxFont *arg1 = (wxFont *) 0 ;
9526 wxFont *arg2 = (wxFont *) 0 ;
9527 bool result;
9528 PyObject * obj0 = 0 ;
9529 PyObject * obj1 = 0 ;
9530 char *kwnames[] = {
9531 (char *) "self",(char *) "other", NULL
9532 };
9533
9534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___eq__",kwnames,&obj0,&obj1)) goto fail;
9535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9536 if (SWIG_arg_fail(1)) SWIG_fail;
9537 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9538 if (SWIG_arg_fail(2)) SWIG_fail;
9539 {
9540 PyThreadState* __tstate = wxPyBeginAllowThreads();
9541 result = (bool)wxFont___eq__(arg1,(wxFont const *)arg2);
9542
9543 wxPyEndAllowThreads(__tstate);
9544 if (PyErr_Occurred()) SWIG_fail;
9545 }
9546 {
9547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9548 }
9549 return resultobj;
9550 fail:
9551 return NULL;
9552 }
9553
9554
9555 static PyObject *_wrap_Font___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
9556 PyObject *resultobj;
9557 wxFont *arg1 = (wxFont *) 0 ;
9558 wxFont *arg2 = (wxFont *) 0 ;
9559 bool result;
9560 PyObject * obj0 = 0 ;
9561 PyObject * obj1 = 0 ;
9562 char *kwnames[] = {
9563 (char *) "self",(char *) "other", NULL
9564 };
9565
9566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___ne__",kwnames,&obj0,&obj1)) goto fail;
9567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9568 if (SWIG_arg_fail(1)) SWIG_fail;
9569 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9570 if (SWIG_arg_fail(2)) SWIG_fail;
9571 {
9572 PyThreadState* __tstate = wxPyBeginAllowThreads();
9573 result = (bool)wxFont___ne__(arg1,(wxFont const *)arg2);
9574
9575 wxPyEndAllowThreads(__tstate);
9576 if (PyErr_Occurred()) SWIG_fail;
9577 }
9578 {
9579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9580 }
9581 return resultobj;
9582 fail:
9583 return NULL;
9584 }
9585
9586
9587 static PyObject *_wrap_Font_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
9588 PyObject *resultobj;
9589 wxFont *arg1 = (wxFont *) 0 ;
9590 int result;
9591 PyObject * obj0 = 0 ;
9592 char *kwnames[] = {
9593 (char *) "self", NULL
9594 };
9595
9596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPointSize",kwnames,&obj0)) goto fail;
9597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9598 if (SWIG_arg_fail(1)) SWIG_fail;
9599 {
9600 PyThreadState* __tstate = wxPyBeginAllowThreads();
9601 result = (int)((wxFont const *)arg1)->GetPointSize();
9602
9603 wxPyEndAllowThreads(__tstate);
9604 if (PyErr_Occurred()) SWIG_fail;
9605 }
9606 {
9607 resultobj = SWIG_From_int((int)(result));
9608 }
9609 return resultobj;
9610 fail:
9611 return NULL;
9612 }
9613
9614
9615 static PyObject *_wrap_Font_GetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
9616 PyObject *resultobj;
9617 wxFont *arg1 = (wxFont *) 0 ;
9618 wxSize result;
9619 PyObject * obj0 = 0 ;
9620 char *kwnames[] = {
9621 (char *) "self", NULL
9622 };
9623
9624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPixelSize",kwnames,&obj0)) goto fail;
9625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9626 if (SWIG_arg_fail(1)) SWIG_fail;
9627 {
9628 PyThreadState* __tstate = wxPyBeginAllowThreads();
9629 result = ((wxFont const *)arg1)->GetPixelSize();
9630
9631 wxPyEndAllowThreads(__tstate);
9632 if (PyErr_Occurred()) SWIG_fail;
9633 }
9634 {
9635 wxSize * resultptr;
9636 resultptr = new wxSize((wxSize &)(result));
9637 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
9638 }
9639 return resultobj;
9640 fail:
9641 return NULL;
9642 }
9643
9644
9645 static PyObject *_wrap_Font_IsUsingSizeInPixels(PyObject *, PyObject *args, PyObject *kwargs) {
9646 PyObject *resultobj;
9647 wxFont *arg1 = (wxFont *) 0 ;
9648 bool result;
9649 PyObject * obj0 = 0 ;
9650 char *kwnames[] = {
9651 (char *) "self", NULL
9652 };
9653
9654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsUsingSizeInPixels",kwnames,&obj0)) goto fail;
9655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9656 if (SWIG_arg_fail(1)) SWIG_fail;
9657 {
9658 PyThreadState* __tstate = wxPyBeginAllowThreads();
9659 result = (bool)((wxFont const *)arg1)->IsUsingSizeInPixels();
9660
9661 wxPyEndAllowThreads(__tstate);
9662 if (PyErr_Occurred()) SWIG_fail;
9663 }
9664 {
9665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9666 }
9667 return resultobj;
9668 fail:
9669 return NULL;
9670 }
9671
9672
9673 static PyObject *_wrap_Font_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
9674 PyObject *resultobj;
9675 wxFont *arg1 = (wxFont *) 0 ;
9676 int result;
9677 PyObject * obj0 = 0 ;
9678 char *kwnames[] = {
9679 (char *) "self", NULL
9680 };
9681
9682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamily",kwnames,&obj0)) goto fail;
9683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9684 if (SWIG_arg_fail(1)) SWIG_fail;
9685 {
9686 PyThreadState* __tstate = wxPyBeginAllowThreads();
9687 result = (int)((wxFont const *)arg1)->GetFamily();
9688
9689 wxPyEndAllowThreads(__tstate);
9690 if (PyErr_Occurred()) SWIG_fail;
9691 }
9692 {
9693 resultobj = SWIG_From_int((int)(result));
9694 }
9695 return resultobj;
9696 fail:
9697 return NULL;
9698 }
9699
9700
9701 static PyObject *_wrap_Font_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
9702 PyObject *resultobj;
9703 wxFont *arg1 = (wxFont *) 0 ;
9704 int result;
9705 PyObject * obj0 = 0 ;
9706 char *kwnames[] = {
9707 (char *) "self", NULL
9708 };
9709
9710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyle",kwnames,&obj0)) goto fail;
9711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9712 if (SWIG_arg_fail(1)) SWIG_fail;
9713 {
9714 PyThreadState* __tstate = wxPyBeginAllowThreads();
9715 result = (int)((wxFont const *)arg1)->GetStyle();
9716
9717 wxPyEndAllowThreads(__tstate);
9718 if (PyErr_Occurred()) SWIG_fail;
9719 }
9720 {
9721 resultobj = SWIG_From_int((int)(result));
9722 }
9723 return resultobj;
9724 fail:
9725 return NULL;
9726 }
9727
9728
9729 static PyObject *_wrap_Font_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
9730 PyObject *resultobj;
9731 wxFont *arg1 = (wxFont *) 0 ;
9732 int result;
9733 PyObject * obj0 = 0 ;
9734 char *kwnames[] = {
9735 (char *) "self", NULL
9736 };
9737
9738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeight",kwnames,&obj0)) goto fail;
9739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9740 if (SWIG_arg_fail(1)) SWIG_fail;
9741 {
9742 PyThreadState* __tstate = wxPyBeginAllowThreads();
9743 result = (int)((wxFont const *)arg1)->GetWeight();
9744
9745 wxPyEndAllowThreads(__tstate);
9746 if (PyErr_Occurred()) SWIG_fail;
9747 }
9748 {
9749 resultobj = SWIG_From_int((int)(result));
9750 }
9751 return resultobj;
9752 fail:
9753 return NULL;
9754 }
9755
9756
9757 static PyObject *_wrap_Font_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
9758 PyObject *resultobj;
9759 wxFont *arg1 = (wxFont *) 0 ;
9760 bool result;
9761 PyObject * obj0 = 0 ;
9762 char *kwnames[] = {
9763 (char *) "self", NULL
9764 };
9765
9766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetUnderlined",kwnames,&obj0)) goto fail;
9767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9768 if (SWIG_arg_fail(1)) SWIG_fail;
9769 {
9770 PyThreadState* __tstate = wxPyBeginAllowThreads();
9771 result = (bool)((wxFont const *)arg1)->GetUnderlined();
9772
9773 wxPyEndAllowThreads(__tstate);
9774 if (PyErr_Occurred()) SWIG_fail;
9775 }
9776 {
9777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9778 }
9779 return resultobj;
9780 fail:
9781 return NULL;
9782 }
9783
9784
9785 static PyObject *_wrap_Font_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
9786 PyObject *resultobj;
9787 wxFont *arg1 = (wxFont *) 0 ;
9788 wxString result;
9789 PyObject * obj0 = 0 ;
9790 char *kwnames[] = {
9791 (char *) "self", NULL
9792 };
9793
9794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFaceName",kwnames,&obj0)) goto fail;
9795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9796 if (SWIG_arg_fail(1)) SWIG_fail;
9797 {
9798 PyThreadState* __tstate = wxPyBeginAllowThreads();
9799 result = ((wxFont const *)arg1)->GetFaceName();
9800
9801 wxPyEndAllowThreads(__tstate);
9802 if (PyErr_Occurred()) SWIG_fail;
9803 }
9804 {
9805 #if wxUSE_UNICODE
9806 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9807 #else
9808 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9809 #endif
9810 }
9811 return resultobj;
9812 fail:
9813 return NULL;
9814 }
9815
9816
9817 static PyObject *_wrap_Font_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9818 PyObject *resultobj;
9819 wxFont *arg1 = (wxFont *) 0 ;
9820 wxFontEncoding result;
9821 PyObject * obj0 = 0 ;
9822 char *kwnames[] = {
9823 (char *) "self", NULL
9824 };
9825
9826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetEncoding",kwnames,&obj0)) goto fail;
9827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9828 if (SWIG_arg_fail(1)) SWIG_fail;
9829 {
9830 PyThreadState* __tstate = wxPyBeginAllowThreads();
9831 result = (wxFontEncoding)((wxFont const *)arg1)->GetEncoding();
9832
9833 wxPyEndAllowThreads(__tstate);
9834 if (PyErr_Occurred()) SWIG_fail;
9835 }
9836 resultobj = SWIG_From_int((result));
9837 return resultobj;
9838 fail:
9839 return NULL;
9840 }
9841
9842
9843 static PyObject *_wrap_Font_GetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9844 PyObject *resultobj;
9845 wxFont *arg1 = (wxFont *) 0 ;
9846 wxNativeFontInfo *result;
9847 PyObject * obj0 = 0 ;
9848 char *kwnames[] = {
9849 (char *) "self", NULL
9850 };
9851
9852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfo",kwnames,&obj0)) goto fail;
9853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9854 if (SWIG_arg_fail(1)) SWIG_fail;
9855 {
9856 PyThreadState* __tstate = wxPyBeginAllowThreads();
9857 result = (wxNativeFontInfo *)((wxFont const *)arg1)->GetNativeFontInfo();
9858
9859 wxPyEndAllowThreads(__tstate);
9860 if (PyErr_Occurred()) SWIG_fail;
9861 }
9862 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 0);
9863 return resultobj;
9864 fail:
9865 return NULL;
9866 }
9867
9868
9869 static PyObject *_wrap_Font_IsFixedWidth(PyObject *, PyObject *args, PyObject *kwargs) {
9870 PyObject *resultobj;
9871 wxFont *arg1 = (wxFont *) 0 ;
9872 bool result;
9873 PyObject * obj0 = 0 ;
9874 char *kwnames[] = {
9875 (char *) "self", NULL
9876 };
9877
9878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsFixedWidth",kwnames,&obj0)) goto fail;
9879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9880 if (SWIG_arg_fail(1)) SWIG_fail;
9881 {
9882 PyThreadState* __tstate = wxPyBeginAllowThreads();
9883 result = (bool)((wxFont const *)arg1)->IsFixedWidth();
9884
9885 wxPyEndAllowThreads(__tstate);
9886 if (PyErr_Occurred()) SWIG_fail;
9887 }
9888 {
9889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9890 }
9891 return resultobj;
9892 fail:
9893 return NULL;
9894 }
9895
9896
9897 static PyObject *_wrap_Font_GetNativeFontInfoDesc(PyObject *, PyObject *args, PyObject *kwargs) {
9898 PyObject *resultobj;
9899 wxFont *arg1 = (wxFont *) 0 ;
9900 wxString result;
9901 PyObject * obj0 = 0 ;
9902 char *kwnames[] = {
9903 (char *) "self", NULL
9904 };
9905
9906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoDesc",kwnames,&obj0)) goto fail;
9907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9908 if (SWIG_arg_fail(1)) SWIG_fail;
9909 {
9910 PyThreadState* __tstate = wxPyBeginAllowThreads();
9911 result = ((wxFont const *)arg1)->GetNativeFontInfoDesc();
9912
9913 wxPyEndAllowThreads(__tstate);
9914 if (PyErr_Occurred()) SWIG_fail;
9915 }
9916 {
9917 #if wxUSE_UNICODE
9918 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9919 #else
9920 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9921 #endif
9922 }
9923 return resultobj;
9924 fail:
9925 return NULL;
9926 }
9927
9928
9929 static PyObject *_wrap_Font_GetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
9930 PyObject *resultobj;
9931 wxFont *arg1 = (wxFont *) 0 ;
9932 wxString result;
9933 PyObject * obj0 = 0 ;
9934 char *kwnames[] = {
9935 (char *) "self", NULL
9936 };
9937
9938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoUserDesc",kwnames,&obj0)) goto fail;
9939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9940 if (SWIG_arg_fail(1)) SWIG_fail;
9941 {
9942 PyThreadState* __tstate = wxPyBeginAllowThreads();
9943 result = ((wxFont const *)arg1)->GetNativeFontInfoUserDesc();
9944
9945 wxPyEndAllowThreads(__tstate);
9946 if (PyErr_Occurred()) SWIG_fail;
9947 }
9948 {
9949 #if wxUSE_UNICODE
9950 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9951 #else
9952 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9953 #endif
9954 }
9955 return resultobj;
9956 fail:
9957 return NULL;
9958 }
9959
9960
9961 static PyObject *_wrap_Font_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
9962 PyObject *resultobj;
9963 wxFont *arg1 = (wxFont *) 0 ;
9964 int arg2 ;
9965 PyObject * obj0 = 0 ;
9966 PyObject * obj1 = 0 ;
9967 char *kwnames[] = {
9968 (char *) "self",(char *) "pointSize", NULL
9969 };
9970
9971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
9972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9973 if (SWIG_arg_fail(1)) SWIG_fail;
9974 {
9975 arg2 = (int)(SWIG_As_int(obj1));
9976 if (SWIG_arg_fail(2)) SWIG_fail;
9977 }
9978 {
9979 PyThreadState* __tstate = wxPyBeginAllowThreads();
9980 (arg1)->SetPointSize(arg2);
9981
9982 wxPyEndAllowThreads(__tstate);
9983 if (PyErr_Occurred()) SWIG_fail;
9984 }
9985 Py_INCREF(Py_None); resultobj = Py_None;
9986 return resultobj;
9987 fail:
9988 return NULL;
9989 }
9990
9991
9992 static PyObject *_wrap_Font_SetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
9993 PyObject *resultobj;
9994 wxFont *arg1 = (wxFont *) 0 ;
9995 wxSize *arg2 = 0 ;
9996 wxSize temp2 ;
9997 PyObject * obj0 = 0 ;
9998 PyObject * obj1 = 0 ;
9999 char *kwnames[] = {
10000 (char *) "self",(char *) "pixelSize", NULL
10001 };
10002
10003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPixelSize",kwnames,&obj0,&obj1)) goto fail;
10004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10005 if (SWIG_arg_fail(1)) SWIG_fail;
10006 {
10007 arg2 = &temp2;
10008 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
10009 }
10010 {
10011 PyThreadState* __tstate = wxPyBeginAllowThreads();
10012 (arg1)->SetPixelSize((wxSize const &)*arg2);
10013
10014 wxPyEndAllowThreads(__tstate);
10015 if (PyErr_Occurred()) SWIG_fail;
10016 }
10017 Py_INCREF(Py_None); resultobj = Py_None;
10018 return resultobj;
10019 fail:
10020 return NULL;
10021 }
10022
10023
10024 static PyObject *_wrap_Font_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
10025 PyObject *resultobj;
10026 wxFont *arg1 = (wxFont *) 0 ;
10027 int arg2 ;
10028 PyObject * obj0 = 0 ;
10029 PyObject * obj1 = 0 ;
10030 char *kwnames[] = {
10031 (char *) "self",(char *) "family", NULL
10032 };
10033
10034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFamily",kwnames,&obj0,&obj1)) goto fail;
10035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10036 if (SWIG_arg_fail(1)) SWIG_fail;
10037 {
10038 arg2 = (int)(SWIG_As_int(obj1));
10039 if (SWIG_arg_fail(2)) SWIG_fail;
10040 }
10041 {
10042 PyThreadState* __tstate = wxPyBeginAllowThreads();
10043 (arg1)->SetFamily(arg2);
10044
10045 wxPyEndAllowThreads(__tstate);
10046 if (PyErr_Occurred()) SWIG_fail;
10047 }
10048 Py_INCREF(Py_None); resultobj = Py_None;
10049 return resultobj;
10050 fail:
10051 return NULL;
10052 }
10053
10054
10055 static PyObject *_wrap_Font_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
10056 PyObject *resultobj;
10057 wxFont *arg1 = (wxFont *) 0 ;
10058 int arg2 ;
10059 PyObject * obj0 = 0 ;
10060 PyObject * obj1 = 0 ;
10061 char *kwnames[] = {
10062 (char *) "self",(char *) "style", NULL
10063 };
10064
10065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetStyle",kwnames,&obj0,&obj1)) goto fail;
10066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10067 if (SWIG_arg_fail(1)) SWIG_fail;
10068 {
10069 arg2 = (int)(SWIG_As_int(obj1));
10070 if (SWIG_arg_fail(2)) SWIG_fail;
10071 }
10072 {
10073 PyThreadState* __tstate = wxPyBeginAllowThreads();
10074 (arg1)->SetStyle(arg2);
10075
10076 wxPyEndAllowThreads(__tstate);
10077 if (PyErr_Occurred()) SWIG_fail;
10078 }
10079 Py_INCREF(Py_None); resultobj = Py_None;
10080 return resultobj;
10081 fail:
10082 return NULL;
10083 }
10084
10085
10086 static PyObject *_wrap_Font_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
10087 PyObject *resultobj;
10088 wxFont *arg1 = (wxFont *) 0 ;
10089 int arg2 ;
10090 PyObject * obj0 = 0 ;
10091 PyObject * obj1 = 0 ;
10092 char *kwnames[] = {
10093 (char *) "self",(char *) "weight", NULL
10094 };
10095
10096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetWeight",kwnames,&obj0,&obj1)) goto fail;
10097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10098 if (SWIG_arg_fail(1)) SWIG_fail;
10099 {
10100 arg2 = (int)(SWIG_As_int(obj1));
10101 if (SWIG_arg_fail(2)) SWIG_fail;
10102 }
10103 {
10104 PyThreadState* __tstate = wxPyBeginAllowThreads();
10105 (arg1)->SetWeight(arg2);
10106
10107 wxPyEndAllowThreads(__tstate);
10108 if (PyErr_Occurred()) SWIG_fail;
10109 }
10110 Py_INCREF(Py_None); resultobj = Py_None;
10111 return resultobj;
10112 fail:
10113 return NULL;
10114 }
10115
10116
10117 static PyObject *_wrap_Font_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
10118 PyObject *resultobj;
10119 wxFont *arg1 = (wxFont *) 0 ;
10120 wxString *arg2 = 0 ;
10121 bool temp2 = false ;
10122 PyObject * obj0 = 0 ;
10123 PyObject * obj1 = 0 ;
10124 char *kwnames[] = {
10125 (char *) "self",(char *) "faceName", NULL
10126 };
10127
10128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
10129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10130 if (SWIG_arg_fail(1)) SWIG_fail;
10131 {
10132 arg2 = wxString_in_helper(obj1);
10133 if (arg2 == NULL) SWIG_fail;
10134 temp2 = true;
10135 }
10136 {
10137 PyThreadState* __tstate = wxPyBeginAllowThreads();
10138 (arg1)->SetFaceName((wxString const &)*arg2);
10139
10140 wxPyEndAllowThreads(__tstate);
10141 if (PyErr_Occurred()) SWIG_fail;
10142 }
10143 Py_INCREF(Py_None); resultobj = Py_None;
10144 {
10145 if (temp2)
10146 delete arg2;
10147 }
10148 return resultobj;
10149 fail:
10150 {
10151 if (temp2)
10152 delete arg2;
10153 }
10154 return NULL;
10155 }
10156
10157
10158 static PyObject *_wrap_Font_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
10159 PyObject *resultobj;
10160 wxFont *arg1 = (wxFont *) 0 ;
10161 bool arg2 ;
10162 PyObject * obj0 = 0 ;
10163 PyObject * obj1 = 0 ;
10164 char *kwnames[] = {
10165 (char *) "self",(char *) "underlined", NULL
10166 };
10167
10168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
10169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10170 if (SWIG_arg_fail(1)) SWIG_fail;
10171 {
10172 arg2 = (bool)(SWIG_As_bool(obj1));
10173 if (SWIG_arg_fail(2)) SWIG_fail;
10174 }
10175 {
10176 PyThreadState* __tstate = wxPyBeginAllowThreads();
10177 (arg1)->SetUnderlined(arg2);
10178
10179 wxPyEndAllowThreads(__tstate);
10180 if (PyErr_Occurred()) SWIG_fail;
10181 }
10182 Py_INCREF(Py_None); resultobj = Py_None;
10183 return resultobj;
10184 fail:
10185 return NULL;
10186 }
10187
10188
10189 static PyObject *_wrap_Font_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10190 PyObject *resultobj;
10191 wxFont *arg1 = (wxFont *) 0 ;
10192 wxFontEncoding arg2 ;
10193 PyObject * obj0 = 0 ;
10194 PyObject * obj1 = 0 ;
10195 char *kwnames[] = {
10196 (char *) "self",(char *) "encoding", NULL
10197 };
10198
10199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
10200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10201 if (SWIG_arg_fail(1)) SWIG_fail;
10202 {
10203 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
10204 if (SWIG_arg_fail(2)) SWIG_fail;
10205 }
10206 {
10207 PyThreadState* __tstate = wxPyBeginAllowThreads();
10208 (arg1)->SetEncoding((wxFontEncoding )arg2);
10209
10210 wxPyEndAllowThreads(__tstate);
10211 if (PyErr_Occurred()) SWIG_fail;
10212 }
10213 Py_INCREF(Py_None); resultobj = Py_None;
10214 return resultobj;
10215 fail:
10216 return NULL;
10217 }
10218
10219
10220 static PyObject *_wrap_Font_SetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10221 PyObject *resultobj;
10222 wxFont *arg1 = (wxFont *) 0 ;
10223 wxNativeFontInfo *arg2 = 0 ;
10224 PyObject * obj0 = 0 ;
10225 PyObject * obj1 = 0 ;
10226 char *kwnames[] = {
10227 (char *) "self",(char *) "info", NULL
10228 };
10229
10230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfo",kwnames,&obj0,&obj1)) goto fail;
10231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10232 if (SWIG_arg_fail(1)) SWIG_fail;
10233 {
10234 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
10235 if (SWIG_arg_fail(2)) SWIG_fail;
10236 if (arg2 == NULL) {
10237 SWIG_null_ref("wxNativeFontInfo");
10238 }
10239 if (SWIG_arg_fail(2)) SWIG_fail;
10240 }
10241 {
10242 PyThreadState* __tstate = wxPyBeginAllowThreads();
10243 (arg1)->SetNativeFontInfo((wxNativeFontInfo const &)*arg2);
10244
10245 wxPyEndAllowThreads(__tstate);
10246 if (PyErr_Occurred()) SWIG_fail;
10247 }
10248 Py_INCREF(Py_None); resultobj = Py_None;
10249 return resultobj;
10250 fail:
10251 return NULL;
10252 }
10253
10254
10255 static PyObject *_wrap_Font_SetNativeFontInfoFromString(PyObject *, PyObject *args, PyObject *kwargs) {
10256 PyObject *resultobj;
10257 wxFont *arg1 = (wxFont *) 0 ;
10258 wxString *arg2 = 0 ;
10259 bool temp2 = false ;
10260 PyObject * obj0 = 0 ;
10261 PyObject * obj1 = 0 ;
10262 char *kwnames[] = {
10263 (char *) "self",(char *) "info", NULL
10264 };
10265
10266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoFromString",kwnames,&obj0,&obj1)) goto fail;
10267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10268 if (SWIG_arg_fail(1)) SWIG_fail;
10269 {
10270 arg2 = wxString_in_helper(obj1);
10271 if (arg2 == NULL) SWIG_fail;
10272 temp2 = true;
10273 }
10274 {
10275 PyThreadState* __tstate = wxPyBeginAllowThreads();
10276 (arg1)->SetNativeFontInfo((wxString const &)*arg2);
10277
10278 wxPyEndAllowThreads(__tstate);
10279 if (PyErr_Occurred()) SWIG_fail;
10280 }
10281 Py_INCREF(Py_None); resultobj = Py_None;
10282 {
10283 if (temp2)
10284 delete arg2;
10285 }
10286 return resultobj;
10287 fail:
10288 {
10289 if (temp2)
10290 delete arg2;
10291 }
10292 return NULL;
10293 }
10294
10295
10296 static PyObject *_wrap_Font_SetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10297 PyObject *resultobj;
10298 wxFont *arg1 = (wxFont *) 0 ;
10299 wxString *arg2 = 0 ;
10300 bool temp2 = false ;
10301 PyObject * obj0 = 0 ;
10302 PyObject * obj1 = 0 ;
10303 char *kwnames[] = {
10304 (char *) "self",(char *) "info", NULL
10305 };
10306
10307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoUserDesc",kwnames,&obj0,&obj1)) goto fail;
10308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10309 if (SWIG_arg_fail(1)) SWIG_fail;
10310 {
10311 arg2 = wxString_in_helper(obj1);
10312 if (arg2 == NULL) SWIG_fail;
10313 temp2 = true;
10314 }
10315 {
10316 PyThreadState* __tstate = wxPyBeginAllowThreads();
10317 (arg1)->SetNativeFontInfoUserDesc((wxString const &)*arg2);
10318
10319 wxPyEndAllowThreads(__tstate);
10320 if (PyErr_Occurred()) SWIG_fail;
10321 }
10322 Py_INCREF(Py_None); resultobj = Py_None;
10323 {
10324 if (temp2)
10325 delete arg2;
10326 }
10327 return resultobj;
10328 fail:
10329 {
10330 if (temp2)
10331 delete arg2;
10332 }
10333 return NULL;
10334 }
10335
10336
10337 static PyObject *_wrap_Font_GetFamilyString(PyObject *, PyObject *args, PyObject *kwargs) {
10338 PyObject *resultobj;
10339 wxFont *arg1 = (wxFont *) 0 ;
10340 wxString result;
10341 PyObject * obj0 = 0 ;
10342 char *kwnames[] = {
10343 (char *) "self", NULL
10344 };
10345
10346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamilyString",kwnames,&obj0)) goto fail;
10347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10348 if (SWIG_arg_fail(1)) SWIG_fail;
10349 {
10350 PyThreadState* __tstate = wxPyBeginAllowThreads();
10351 result = ((wxFont const *)arg1)->GetFamilyString();
10352
10353 wxPyEndAllowThreads(__tstate);
10354 if (PyErr_Occurred()) SWIG_fail;
10355 }
10356 {
10357 #if wxUSE_UNICODE
10358 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10359 #else
10360 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10361 #endif
10362 }
10363 return resultobj;
10364 fail:
10365 return NULL;
10366 }
10367
10368
10369 static PyObject *_wrap_Font_GetStyleString(PyObject *, PyObject *args, PyObject *kwargs) {
10370 PyObject *resultobj;
10371 wxFont *arg1 = (wxFont *) 0 ;
10372 wxString result;
10373 PyObject * obj0 = 0 ;
10374 char *kwnames[] = {
10375 (char *) "self", NULL
10376 };
10377
10378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyleString",kwnames,&obj0)) goto fail;
10379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10380 if (SWIG_arg_fail(1)) SWIG_fail;
10381 {
10382 PyThreadState* __tstate = wxPyBeginAllowThreads();
10383 result = ((wxFont const *)arg1)->GetStyleString();
10384
10385 wxPyEndAllowThreads(__tstate);
10386 if (PyErr_Occurred()) SWIG_fail;
10387 }
10388 {
10389 #if wxUSE_UNICODE
10390 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10391 #else
10392 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10393 #endif
10394 }
10395 return resultobj;
10396 fail:
10397 return NULL;
10398 }
10399
10400
10401 static PyObject *_wrap_Font_GetWeightString(PyObject *, PyObject *args, PyObject *kwargs) {
10402 PyObject *resultobj;
10403 wxFont *arg1 = (wxFont *) 0 ;
10404 wxString result;
10405 PyObject * obj0 = 0 ;
10406 char *kwnames[] = {
10407 (char *) "self", NULL
10408 };
10409
10410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeightString",kwnames,&obj0)) goto fail;
10411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10412 if (SWIG_arg_fail(1)) SWIG_fail;
10413 {
10414 PyThreadState* __tstate = wxPyBeginAllowThreads();
10415 result = ((wxFont const *)arg1)->GetWeightString();
10416
10417 wxPyEndAllowThreads(__tstate);
10418 if (PyErr_Occurred()) SWIG_fail;
10419 }
10420 {
10421 #if wxUSE_UNICODE
10422 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10423 #else
10424 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10425 #endif
10426 }
10427 return resultobj;
10428 fail:
10429 return NULL;
10430 }
10431
10432
10433 static PyObject *_wrap_Font_SetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
10434 PyObject *resultobj;
10435 wxFont *arg1 = (wxFont *) 0 ;
10436 bool arg2 = (bool) true ;
10437 PyObject * obj0 = 0 ;
10438 PyObject * obj1 = 0 ;
10439 char *kwnames[] = {
10440 (char *) "self",(char *) "no", NULL
10441 };
10442
10443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Font_SetNoAntiAliasing",kwnames,&obj0,&obj1)) goto fail;
10444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10445 if (SWIG_arg_fail(1)) SWIG_fail;
10446 if (obj1) {
10447 {
10448 arg2 = (bool)(SWIG_As_bool(obj1));
10449 if (SWIG_arg_fail(2)) SWIG_fail;
10450 }
10451 }
10452 {
10453 PyThreadState* __tstate = wxPyBeginAllowThreads();
10454 (arg1)->SetNoAntiAliasing(arg2);
10455
10456 wxPyEndAllowThreads(__tstate);
10457 if (PyErr_Occurred()) SWIG_fail;
10458 }
10459 Py_INCREF(Py_None); resultobj = Py_None;
10460 return resultobj;
10461 fail:
10462 return NULL;
10463 }
10464
10465
10466 static PyObject *_wrap_Font_GetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
10467 PyObject *resultobj;
10468 wxFont *arg1 = (wxFont *) 0 ;
10469 bool result;
10470 PyObject * obj0 = 0 ;
10471 char *kwnames[] = {
10472 (char *) "self", NULL
10473 };
10474
10475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNoAntiAliasing",kwnames,&obj0)) goto fail;
10476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10477 if (SWIG_arg_fail(1)) SWIG_fail;
10478 {
10479 PyThreadState* __tstate = wxPyBeginAllowThreads();
10480 result = (bool)((wxFont const *)arg1)->GetNoAntiAliasing();
10481
10482 wxPyEndAllowThreads(__tstate);
10483 if (PyErr_Occurred()) SWIG_fail;
10484 }
10485 {
10486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10487 }
10488 return resultobj;
10489 fail:
10490 return NULL;
10491 }
10492
10493
10494 static PyObject *_wrap_Font_GetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10495 PyObject *resultobj;
10496 wxFontEncoding result;
10497 char *kwnames[] = {
10498 NULL
10499 };
10500
10501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Font_GetDefaultEncoding",kwnames)) goto fail;
10502 {
10503 if (!wxPyCheckForApp()) SWIG_fail;
10504 PyThreadState* __tstate = wxPyBeginAllowThreads();
10505 result = (wxFontEncoding)wxFont::GetDefaultEncoding();
10506
10507 wxPyEndAllowThreads(__tstate);
10508 if (PyErr_Occurred()) SWIG_fail;
10509 }
10510 resultobj = SWIG_From_int((result));
10511 return resultobj;
10512 fail:
10513 return NULL;
10514 }
10515
10516
10517 static PyObject *_wrap_Font_SetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10518 PyObject *resultobj;
10519 wxFontEncoding arg1 ;
10520 PyObject * obj0 = 0 ;
10521 char *kwnames[] = {
10522 (char *) "encoding", NULL
10523 };
10524
10525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_SetDefaultEncoding",kwnames,&obj0)) goto fail;
10526 {
10527 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
10528 if (SWIG_arg_fail(1)) SWIG_fail;
10529 }
10530 {
10531 if (!wxPyCheckForApp()) SWIG_fail;
10532 PyThreadState* __tstate = wxPyBeginAllowThreads();
10533 wxFont::SetDefaultEncoding((wxFontEncoding )arg1);
10534
10535 wxPyEndAllowThreads(__tstate);
10536 if (PyErr_Occurred()) SWIG_fail;
10537 }
10538 Py_INCREF(Py_None); resultobj = Py_None;
10539 return resultobj;
10540 fail:
10541 return NULL;
10542 }
10543
10544
10545 static PyObject * Font_swigregister(PyObject *, PyObject *args) {
10546 PyObject *obj;
10547 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10548 SWIG_TypeClientData(SWIGTYPE_p_wxFont, obj);
10549 Py_INCREF(obj);
10550 return Py_BuildValue((char *)"");
10551 }
10552 static PyObject *_wrap_new_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
10553 PyObject *resultobj;
10554 wxPyFontEnumerator *result;
10555 char *kwnames[] = {
10556 NULL
10557 };
10558
10559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontEnumerator",kwnames)) goto fail;
10560 {
10561 if (!wxPyCheckForApp()) SWIG_fail;
10562 PyThreadState* __tstate = wxPyBeginAllowThreads();
10563 result = (wxPyFontEnumerator *)new wxPyFontEnumerator();
10564
10565 wxPyEndAllowThreads(__tstate);
10566 if (PyErr_Occurred()) SWIG_fail;
10567 }
10568 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFontEnumerator, 1);
10569 return resultobj;
10570 fail:
10571 return NULL;
10572 }
10573
10574
10575 static PyObject *_wrap_delete_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
10576 PyObject *resultobj;
10577 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10578 PyObject * obj0 = 0 ;
10579 char *kwnames[] = {
10580 (char *) "self", NULL
10581 };
10582
10583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontEnumerator",kwnames,&obj0)) goto fail;
10584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10585 if (SWIG_arg_fail(1)) SWIG_fail;
10586 {
10587 PyThreadState* __tstate = wxPyBeginAllowThreads();
10588 delete arg1;
10589
10590 wxPyEndAllowThreads(__tstate);
10591 if (PyErr_Occurred()) SWIG_fail;
10592 }
10593 Py_INCREF(Py_None); resultobj = Py_None;
10594 return resultobj;
10595 fail:
10596 return NULL;
10597 }
10598
10599
10600 static PyObject *_wrap_FontEnumerator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10601 PyObject *resultobj;
10602 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10603 PyObject *arg2 = (PyObject *) 0 ;
10604 PyObject *arg3 = (PyObject *) 0 ;
10605 bool arg4 ;
10606 PyObject * obj0 = 0 ;
10607 PyObject * obj1 = 0 ;
10608 PyObject * obj2 = 0 ;
10609 PyObject * obj3 = 0 ;
10610 char *kwnames[] = {
10611 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
10612 };
10613
10614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FontEnumerator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10616 if (SWIG_arg_fail(1)) SWIG_fail;
10617 arg2 = obj1;
10618 arg3 = obj2;
10619 {
10620 arg4 = (bool)(SWIG_As_bool(obj3));
10621 if (SWIG_arg_fail(4)) SWIG_fail;
10622 }
10623 {
10624 PyThreadState* __tstate = wxPyBeginAllowThreads();
10625 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
10626
10627 wxPyEndAllowThreads(__tstate);
10628 if (PyErr_Occurred()) SWIG_fail;
10629 }
10630 Py_INCREF(Py_None); resultobj = Py_None;
10631 return resultobj;
10632 fail:
10633 return NULL;
10634 }
10635
10636
10637 static PyObject *_wrap_FontEnumerator_EnumerateFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
10638 PyObject *resultobj;
10639 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10640 wxFontEncoding arg2 = (wxFontEncoding) wxFONTENCODING_SYSTEM ;
10641 bool arg3 = (bool) false ;
10642 bool result;
10643 PyObject * obj0 = 0 ;
10644 PyObject * obj1 = 0 ;
10645 PyObject * obj2 = 0 ;
10646 char *kwnames[] = {
10647 (char *) "self",(char *) "encoding",(char *) "fixedWidthOnly", NULL
10648 };
10649
10650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FontEnumerator_EnumerateFacenames",kwnames,&obj0,&obj1,&obj2)) goto fail;
10651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10652 if (SWIG_arg_fail(1)) SWIG_fail;
10653 if (obj1) {
10654 {
10655 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
10656 if (SWIG_arg_fail(2)) SWIG_fail;
10657 }
10658 }
10659 if (obj2) {
10660 {
10661 arg3 = (bool)(SWIG_As_bool(obj2));
10662 if (SWIG_arg_fail(3)) SWIG_fail;
10663 }
10664 }
10665 {
10666 PyThreadState* __tstate = wxPyBeginAllowThreads();
10667 result = (bool)(arg1)->EnumerateFacenames((wxFontEncoding )arg2,arg3);
10668
10669 wxPyEndAllowThreads(__tstate);
10670 if (PyErr_Occurred()) SWIG_fail;
10671 }
10672 {
10673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10674 }
10675 return resultobj;
10676 fail:
10677 return NULL;
10678 }
10679
10680
10681 static PyObject *_wrap_FontEnumerator_EnumerateEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
10682 PyObject *resultobj;
10683 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10684 wxString const &arg2_defvalue = wxPyEmptyString ;
10685 wxString *arg2 = (wxString *) &arg2_defvalue ;
10686 bool result;
10687 bool temp2 = false ;
10688 PyObject * obj0 = 0 ;
10689 PyObject * obj1 = 0 ;
10690 char *kwnames[] = {
10691 (char *) "self",(char *) "facename", NULL
10692 };
10693
10694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FontEnumerator_EnumerateEncodings",kwnames,&obj0,&obj1)) goto fail;
10695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10696 if (SWIG_arg_fail(1)) SWIG_fail;
10697 if (obj1) {
10698 {
10699 arg2 = wxString_in_helper(obj1);
10700 if (arg2 == NULL) SWIG_fail;
10701 temp2 = true;
10702 }
10703 }
10704 {
10705 PyThreadState* __tstate = wxPyBeginAllowThreads();
10706 result = (bool)(arg1)->EnumerateEncodings((wxString const &)*arg2);
10707
10708 wxPyEndAllowThreads(__tstate);
10709 if (PyErr_Occurred()) SWIG_fail;
10710 }
10711 {
10712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10713 }
10714 {
10715 if (temp2)
10716 delete arg2;
10717 }
10718 return resultobj;
10719 fail:
10720 {
10721 if (temp2)
10722 delete arg2;
10723 }
10724 return NULL;
10725 }
10726
10727
10728 static PyObject *_wrap_FontEnumerator_GetEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
10729 PyObject *resultobj;
10730 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10731 PyObject *result;
10732 PyObject * obj0 = 0 ;
10733 char *kwnames[] = {
10734 (char *) "self", NULL
10735 };
10736
10737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetEncodings",kwnames,&obj0)) goto fail;
10738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10739 if (SWIG_arg_fail(1)) SWIG_fail;
10740 {
10741 PyThreadState* __tstate = wxPyBeginAllowThreads();
10742 result = (PyObject *)wxPyFontEnumerator_GetEncodings(arg1);
10743
10744 wxPyEndAllowThreads(__tstate);
10745 if (PyErr_Occurred()) SWIG_fail;
10746 }
10747 resultobj = result;
10748 return resultobj;
10749 fail:
10750 return NULL;
10751 }
10752
10753
10754 static PyObject *_wrap_FontEnumerator_GetFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
10755 PyObject *resultobj;
10756 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10757 PyObject *result;
10758 PyObject * obj0 = 0 ;
10759 char *kwnames[] = {
10760 (char *) "self", NULL
10761 };
10762
10763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetFacenames",kwnames,&obj0)) goto fail;
10764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10765 if (SWIG_arg_fail(1)) SWIG_fail;
10766 {
10767 PyThreadState* __tstate = wxPyBeginAllowThreads();
10768 result = (PyObject *)wxPyFontEnumerator_GetFacenames(arg1);
10769
10770 wxPyEndAllowThreads(__tstate);
10771 if (PyErr_Occurred()) SWIG_fail;
10772 }
10773 resultobj = result;
10774 return resultobj;
10775 fail:
10776 return NULL;
10777 }
10778
10779
10780 static PyObject * FontEnumerator_swigregister(PyObject *, PyObject *args) {
10781 PyObject *obj;
10782 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10783 SWIG_TypeClientData(SWIGTYPE_p_wxPyFontEnumerator, obj);
10784 Py_INCREF(obj);
10785 return Py_BuildValue((char *)"");
10786 }
10787 static PyObject *_wrap_LanguageInfo_Language_set(PyObject *, PyObject *args, PyObject *kwargs) {
10788 PyObject *resultobj;
10789 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10790 int arg2 ;
10791 PyObject * obj0 = 0 ;
10792 PyObject * obj1 = 0 ;
10793 char *kwnames[] = {
10794 (char *) "self",(char *) "Language", NULL
10795 };
10796
10797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Language_set",kwnames,&obj0,&obj1)) goto fail;
10798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10799 if (SWIG_arg_fail(1)) SWIG_fail;
10800 {
10801 arg2 = (int)(SWIG_As_int(obj1));
10802 if (SWIG_arg_fail(2)) SWIG_fail;
10803 }
10804 if (arg1) (arg1)->Language = arg2;
10805
10806 Py_INCREF(Py_None); resultobj = Py_None;
10807 return resultobj;
10808 fail:
10809 return NULL;
10810 }
10811
10812
10813 static PyObject *_wrap_LanguageInfo_Language_get(PyObject *, PyObject *args, PyObject *kwargs) {
10814 PyObject *resultobj;
10815 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10816 int result;
10817 PyObject * obj0 = 0 ;
10818 char *kwnames[] = {
10819 (char *) "self", NULL
10820 };
10821
10822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Language_get",kwnames,&obj0)) goto fail;
10823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10824 if (SWIG_arg_fail(1)) SWIG_fail;
10825 result = (int) ((arg1)->Language);
10826
10827 {
10828 resultobj = SWIG_From_int((int)(result));
10829 }
10830 return resultobj;
10831 fail:
10832 return NULL;
10833 }
10834
10835
10836 static PyObject *_wrap_LanguageInfo_CanonicalName_set(PyObject *, PyObject *args, PyObject *kwargs) {
10837 PyObject *resultobj;
10838 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10839 wxString *arg2 = (wxString *) 0 ;
10840 bool temp2 = false ;
10841 PyObject * obj0 = 0 ;
10842 PyObject * obj1 = 0 ;
10843 char *kwnames[] = {
10844 (char *) "self",(char *) "CanonicalName", NULL
10845 };
10846
10847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_CanonicalName_set",kwnames,&obj0,&obj1)) goto fail;
10848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10849 if (SWIG_arg_fail(1)) SWIG_fail;
10850 {
10851 arg2 = wxString_in_helper(obj1);
10852 if (arg2 == NULL) SWIG_fail;
10853 temp2 = true;
10854 }
10855 if (arg1) (arg1)->CanonicalName = *arg2;
10856
10857 Py_INCREF(Py_None); resultobj = Py_None;
10858 {
10859 if (temp2)
10860 delete arg2;
10861 }
10862 return resultobj;
10863 fail:
10864 {
10865 if (temp2)
10866 delete arg2;
10867 }
10868 return NULL;
10869 }
10870
10871
10872 static PyObject *_wrap_LanguageInfo_CanonicalName_get(PyObject *, PyObject *args, PyObject *kwargs) {
10873 PyObject *resultobj;
10874 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10875 wxString *result;
10876 PyObject * obj0 = 0 ;
10877 char *kwnames[] = {
10878 (char *) "self", NULL
10879 };
10880
10881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_CanonicalName_get",kwnames,&obj0)) goto fail;
10882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10883 if (SWIG_arg_fail(1)) SWIG_fail;
10884 result = (wxString *)& ((arg1)->CanonicalName);
10885
10886 {
10887 #if wxUSE_UNICODE
10888 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10889 #else
10890 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10891 #endif
10892 }
10893 return resultobj;
10894 fail:
10895 return NULL;
10896 }
10897
10898
10899 static PyObject *_wrap_LanguageInfo_Description_set(PyObject *, PyObject *args, PyObject *kwargs) {
10900 PyObject *resultobj;
10901 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10902 wxString *arg2 = (wxString *) 0 ;
10903 bool temp2 = false ;
10904 PyObject * obj0 = 0 ;
10905 PyObject * obj1 = 0 ;
10906 char *kwnames[] = {
10907 (char *) "self",(char *) "Description", NULL
10908 };
10909
10910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Description_set",kwnames,&obj0,&obj1)) goto fail;
10911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10912 if (SWIG_arg_fail(1)) SWIG_fail;
10913 {
10914 arg2 = wxString_in_helper(obj1);
10915 if (arg2 == NULL) SWIG_fail;
10916 temp2 = true;
10917 }
10918 if (arg1) (arg1)->Description = *arg2;
10919
10920 Py_INCREF(Py_None); resultobj = Py_None;
10921 {
10922 if (temp2)
10923 delete arg2;
10924 }
10925 return resultobj;
10926 fail:
10927 {
10928 if (temp2)
10929 delete arg2;
10930 }
10931 return NULL;
10932 }
10933
10934
10935 static PyObject *_wrap_LanguageInfo_Description_get(PyObject *, PyObject *args, PyObject *kwargs) {
10936 PyObject *resultobj;
10937 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10938 wxString *result;
10939 PyObject * obj0 = 0 ;
10940 char *kwnames[] = {
10941 (char *) "self", NULL
10942 };
10943
10944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Description_get",kwnames,&obj0)) goto fail;
10945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10946 if (SWIG_arg_fail(1)) SWIG_fail;
10947 result = (wxString *)& ((arg1)->Description);
10948
10949 {
10950 #if wxUSE_UNICODE
10951 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10952 #else
10953 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10954 #endif
10955 }
10956 return resultobj;
10957 fail:
10958 return NULL;
10959 }
10960
10961
10962 static PyObject * LanguageInfo_swigregister(PyObject *, PyObject *args) {
10963 PyObject *obj;
10964 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10965 SWIG_TypeClientData(SWIGTYPE_p_wxLanguageInfo, obj);
10966 Py_INCREF(obj);
10967 return Py_BuildValue((char *)"");
10968 }
10969 static PyObject *_wrap_new_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
10970 PyObject *resultobj;
10971 int arg1 = (int) -1 ;
10972 int arg2 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
10973 wxLocale *result;
10974 PyObject * obj0 = 0 ;
10975 PyObject * obj1 = 0 ;
10976 char *kwnames[] = {
10977 (char *) "language",(char *) "flags", NULL
10978 };
10979
10980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Locale",kwnames,&obj0,&obj1)) goto fail;
10981 if (obj0) {
10982 {
10983 arg1 = (int)(SWIG_As_int(obj0));
10984 if (SWIG_arg_fail(1)) SWIG_fail;
10985 }
10986 }
10987 if (obj1) {
10988 {
10989 arg2 = (int)(SWIG_As_int(obj1));
10990 if (SWIG_arg_fail(2)) SWIG_fail;
10991 }
10992 }
10993 {
10994 PyThreadState* __tstate = wxPyBeginAllowThreads();
10995 result = (wxLocale *)new_wxLocale(arg1,arg2);
10996
10997 wxPyEndAllowThreads(__tstate);
10998 if (PyErr_Occurred()) SWIG_fail;
10999 }
11000 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 1);
11001 return resultobj;
11002 fail:
11003 return NULL;
11004 }
11005
11006
11007 static PyObject *_wrap_delete_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
11008 PyObject *resultobj;
11009 wxLocale *arg1 = (wxLocale *) 0 ;
11010 PyObject * obj0 = 0 ;
11011 char *kwnames[] = {
11012 (char *) "self", NULL
11013 };
11014
11015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Locale",kwnames,&obj0)) goto fail;
11016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11017 if (SWIG_arg_fail(1)) SWIG_fail;
11018 {
11019 PyThreadState* __tstate = wxPyBeginAllowThreads();
11020 delete arg1;
11021
11022 wxPyEndAllowThreads(__tstate);
11023 if (PyErr_Occurred()) SWIG_fail;
11024 }
11025 Py_INCREF(Py_None); resultobj = Py_None;
11026 return resultobj;
11027 fail:
11028 return NULL;
11029 }
11030
11031
11032 static PyObject *_wrap_Locale_Init1(PyObject *, PyObject *args, PyObject *kwargs) {
11033 PyObject *resultobj;
11034 wxLocale *arg1 = (wxLocale *) 0 ;
11035 wxString *arg2 = 0 ;
11036 wxString const &arg3_defvalue = wxPyEmptyString ;
11037 wxString *arg3 = (wxString *) &arg3_defvalue ;
11038 wxString const &arg4_defvalue = wxPyEmptyString ;
11039 wxString *arg4 = (wxString *) &arg4_defvalue ;
11040 bool arg5 = (bool) true ;
11041 bool arg6 = (bool) false ;
11042 bool result;
11043 bool temp2 = false ;
11044 bool temp3 = false ;
11045 bool temp4 = false ;
11046 PyObject * obj0 = 0 ;
11047 PyObject * obj1 = 0 ;
11048 PyObject * obj2 = 0 ;
11049 PyObject * obj3 = 0 ;
11050 PyObject * obj4 = 0 ;
11051 PyObject * obj5 = 0 ;
11052 char *kwnames[] = {
11053 (char *) "self",(char *) "szName",(char *) "szShort",(char *) "szLocale",(char *) "bLoadDefault",(char *) "bConvertEncoding", NULL
11054 };
11055
11056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Locale_Init1",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11058 if (SWIG_arg_fail(1)) SWIG_fail;
11059 {
11060 arg2 = wxString_in_helper(obj1);
11061 if (arg2 == NULL) SWIG_fail;
11062 temp2 = true;
11063 }
11064 if (obj2) {
11065 {
11066 arg3 = wxString_in_helper(obj2);
11067 if (arg3 == NULL) SWIG_fail;
11068 temp3 = true;
11069 }
11070 }
11071 if (obj3) {
11072 {
11073 arg4 = wxString_in_helper(obj3);
11074 if (arg4 == NULL) SWIG_fail;
11075 temp4 = true;
11076 }
11077 }
11078 if (obj4) {
11079 {
11080 arg5 = (bool)(SWIG_As_bool(obj4));
11081 if (SWIG_arg_fail(5)) SWIG_fail;
11082 }
11083 }
11084 if (obj5) {
11085 {
11086 arg6 = (bool)(SWIG_As_bool(obj5));
11087 if (SWIG_arg_fail(6)) SWIG_fail;
11088 }
11089 }
11090 {
11091 PyThreadState* __tstate = wxPyBeginAllowThreads();
11092 result = (bool)wxLocale_Init1(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
11093
11094 wxPyEndAllowThreads(__tstate);
11095 if (PyErr_Occurred()) SWIG_fail;
11096 }
11097 {
11098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11099 }
11100 {
11101 if (temp2)
11102 delete arg2;
11103 }
11104 {
11105 if (temp3)
11106 delete arg3;
11107 }
11108 {
11109 if (temp4)
11110 delete arg4;
11111 }
11112 return resultobj;
11113 fail:
11114 {
11115 if (temp2)
11116 delete arg2;
11117 }
11118 {
11119 if (temp3)
11120 delete arg3;
11121 }
11122 {
11123 if (temp4)
11124 delete arg4;
11125 }
11126 return NULL;
11127 }
11128
11129
11130 static PyObject *_wrap_Locale_Init2(PyObject *, PyObject *args, PyObject *kwargs) {
11131 PyObject *resultobj;
11132 wxLocale *arg1 = (wxLocale *) 0 ;
11133 int arg2 = (int) wxLANGUAGE_DEFAULT ;
11134 int arg3 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
11135 bool result;
11136 PyObject * obj0 = 0 ;
11137 PyObject * obj1 = 0 ;
11138 PyObject * obj2 = 0 ;
11139 char *kwnames[] = {
11140 (char *) "self",(char *) "language",(char *) "flags", NULL
11141 };
11142
11143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Locale_Init2",kwnames,&obj0,&obj1,&obj2)) goto fail;
11144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11145 if (SWIG_arg_fail(1)) SWIG_fail;
11146 if (obj1) {
11147 {
11148 arg2 = (int)(SWIG_As_int(obj1));
11149 if (SWIG_arg_fail(2)) SWIG_fail;
11150 }
11151 }
11152 if (obj2) {
11153 {
11154 arg3 = (int)(SWIG_As_int(obj2));
11155 if (SWIG_arg_fail(3)) SWIG_fail;
11156 }
11157 }
11158 {
11159 PyThreadState* __tstate = wxPyBeginAllowThreads();
11160 result = (bool)wxLocale_Init2(arg1,arg2,arg3);
11161
11162 wxPyEndAllowThreads(__tstate);
11163 if (PyErr_Occurred()) SWIG_fail;
11164 }
11165 {
11166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11167 }
11168 return resultobj;
11169 fail:
11170 return NULL;
11171 }
11172
11173
11174 static PyObject *_wrap_Locale_GetSystemLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11175 PyObject *resultobj;
11176 int result;
11177 char *kwnames[] = {
11178 NULL
11179 };
11180
11181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemLanguage",kwnames)) goto fail;
11182 {
11183 PyThreadState* __tstate = wxPyBeginAllowThreads();
11184 result = (int)wxLocale::GetSystemLanguage();
11185
11186 wxPyEndAllowThreads(__tstate);
11187 if (PyErr_Occurred()) SWIG_fail;
11188 }
11189 {
11190 resultobj = SWIG_From_int((int)(result));
11191 }
11192 return resultobj;
11193 fail:
11194 return NULL;
11195 }
11196
11197
11198 static PyObject *_wrap_Locale_GetSystemEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
11199 PyObject *resultobj;
11200 wxFontEncoding result;
11201 char *kwnames[] = {
11202 NULL
11203 };
11204
11205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncoding",kwnames)) goto fail;
11206 {
11207 PyThreadState* __tstate = wxPyBeginAllowThreads();
11208 result = (wxFontEncoding)wxLocale::GetSystemEncoding();
11209
11210 wxPyEndAllowThreads(__tstate);
11211 if (PyErr_Occurred()) SWIG_fail;
11212 }
11213 resultobj = SWIG_From_int((result));
11214 return resultobj;
11215 fail:
11216 return NULL;
11217 }
11218
11219
11220 static PyObject *_wrap_Locale_GetSystemEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
11221 PyObject *resultobj;
11222 wxString result;
11223 char *kwnames[] = {
11224 NULL
11225 };
11226
11227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncodingName",kwnames)) goto fail;
11228 {
11229 PyThreadState* __tstate = wxPyBeginAllowThreads();
11230 result = wxLocale::GetSystemEncodingName();
11231
11232 wxPyEndAllowThreads(__tstate);
11233 if (PyErr_Occurred()) SWIG_fail;
11234 }
11235 {
11236 #if wxUSE_UNICODE
11237 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11238 #else
11239 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11240 #endif
11241 }
11242 return resultobj;
11243 fail:
11244 return NULL;
11245 }
11246
11247
11248 static PyObject *_wrap_Locale_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11249 PyObject *resultobj;
11250 wxLocale *arg1 = (wxLocale *) 0 ;
11251 bool result;
11252 PyObject * obj0 = 0 ;
11253 char *kwnames[] = {
11254 (char *) "self", NULL
11255 };
11256
11257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_IsOk",kwnames,&obj0)) goto fail;
11258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11259 if (SWIG_arg_fail(1)) SWIG_fail;
11260 {
11261 PyThreadState* __tstate = wxPyBeginAllowThreads();
11262 result = (bool)((wxLocale const *)arg1)->IsOk();
11263
11264 wxPyEndAllowThreads(__tstate);
11265 if (PyErr_Occurred()) SWIG_fail;
11266 }
11267 {
11268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11269 }
11270 return resultobj;
11271 fail:
11272 return NULL;
11273 }
11274
11275
11276 static PyObject *_wrap_Locale_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
11277 PyObject *resultobj;
11278 wxLocale *arg1 = (wxLocale *) 0 ;
11279 wxString result;
11280 PyObject * obj0 = 0 ;
11281 char *kwnames[] = {
11282 (char *) "self", NULL
11283 };
11284
11285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLocale",kwnames,&obj0)) goto fail;
11286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11287 if (SWIG_arg_fail(1)) SWIG_fail;
11288 {
11289 PyThreadState* __tstate = wxPyBeginAllowThreads();
11290 result = ((wxLocale const *)arg1)->GetLocale();
11291
11292 wxPyEndAllowThreads(__tstate);
11293 if (PyErr_Occurred()) SWIG_fail;
11294 }
11295 {
11296 #if wxUSE_UNICODE
11297 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11298 #else
11299 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11300 #endif
11301 }
11302 return resultobj;
11303 fail:
11304 return NULL;
11305 }
11306
11307
11308 static PyObject *_wrap_Locale_GetLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11309 PyObject *resultobj;
11310 wxLocale *arg1 = (wxLocale *) 0 ;
11311 int result;
11312 PyObject * obj0 = 0 ;
11313 char *kwnames[] = {
11314 (char *) "self", NULL
11315 };
11316
11317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguage",kwnames,&obj0)) goto fail;
11318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11319 if (SWIG_arg_fail(1)) SWIG_fail;
11320 {
11321 PyThreadState* __tstate = wxPyBeginAllowThreads();
11322 result = (int)((wxLocale const *)arg1)->GetLanguage();
11323
11324 wxPyEndAllowThreads(__tstate);
11325 if (PyErr_Occurred()) SWIG_fail;
11326 }
11327 {
11328 resultobj = SWIG_From_int((int)(result));
11329 }
11330 return resultobj;
11331 fail:
11332 return NULL;
11333 }
11334
11335
11336 static PyObject *_wrap_Locale_GetSysName(PyObject *, PyObject *args, PyObject *kwargs) {
11337 PyObject *resultobj;
11338 wxLocale *arg1 = (wxLocale *) 0 ;
11339 wxString result;
11340 PyObject * obj0 = 0 ;
11341 char *kwnames[] = {
11342 (char *) "self", NULL
11343 };
11344
11345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetSysName",kwnames,&obj0)) goto fail;
11346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11347 if (SWIG_arg_fail(1)) SWIG_fail;
11348 {
11349 PyThreadState* __tstate = wxPyBeginAllowThreads();
11350 result = ((wxLocale const *)arg1)->GetSysName();
11351
11352 wxPyEndAllowThreads(__tstate);
11353 if (PyErr_Occurred()) SWIG_fail;
11354 }
11355 {
11356 #if wxUSE_UNICODE
11357 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11358 #else
11359 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11360 #endif
11361 }
11362 return resultobj;
11363 fail:
11364 return NULL;
11365 }
11366
11367
11368 static PyObject *_wrap_Locale_GetCanonicalName(PyObject *, PyObject *args, PyObject *kwargs) {
11369 PyObject *resultobj;
11370 wxLocale *arg1 = (wxLocale *) 0 ;
11371 wxString result;
11372 PyObject * obj0 = 0 ;
11373 char *kwnames[] = {
11374 (char *) "self", NULL
11375 };
11376
11377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetCanonicalName",kwnames,&obj0)) goto fail;
11378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11379 if (SWIG_arg_fail(1)) SWIG_fail;
11380 {
11381 PyThreadState* __tstate = wxPyBeginAllowThreads();
11382 result = ((wxLocale const *)arg1)->GetCanonicalName();
11383
11384 wxPyEndAllowThreads(__tstate);
11385 if (PyErr_Occurred()) SWIG_fail;
11386 }
11387 {
11388 #if wxUSE_UNICODE
11389 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11390 #else
11391 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11392 #endif
11393 }
11394 return resultobj;
11395 fail:
11396 return NULL;
11397 }
11398
11399
11400 static PyObject *_wrap_Locale_AddCatalogLookupPathPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
11401 PyObject *resultobj;
11402 wxString *arg1 = 0 ;
11403 bool temp1 = false ;
11404 PyObject * obj0 = 0 ;
11405 char *kwnames[] = {
11406 (char *) "prefix", NULL
11407 };
11408
11409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddCatalogLookupPathPrefix",kwnames,&obj0)) goto fail;
11410 {
11411 arg1 = wxString_in_helper(obj0);
11412 if (arg1 == NULL) SWIG_fail;
11413 temp1 = true;
11414 }
11415 {
11416 PyThreadState* __tstate = wxPyBeginAllowThreads();
11417 wxLocale::AddCatalogLookupPathPrefix((wxString const &)*arg1);
11418
11419 wxPyEndAllowThreads(__tstate);
11420 if (PyErr_Occurred()) SWIG_fail;
11421 }
11422 Py_INCREF(Py_None); resultobj = Py_None;
11423 {
11424 if (temp1)
11425 delete arg1;
11426 }
11427 return resultobj;
11428 fail:
11429 {
11430 if (temp1)
11431 delete arg1;
11432 }
11433 return NULL;
11434 }
11435
11436
11437 static PyObject *_wrap_Locale_AddCatalog(PyObject *, PyObject *args, PyObject *kwargs) {
11438 PyObject *resultobj;
11439 wxLocale *arg1 = (wxLocale *) 0 ;
11440 wxString *arg2 = 0 ;
11441 bool result;
11442 bool temp2 = false ;
11443 PyObject * obj0 = 0 ;
11444 PyObject * obj1 = 0 ;
11445 char *kwnames[] = {
11446 (char *) "self",(char *) "szDomain", NULL
11447 };
11448
11449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_AddCatalog",kwnames,&obj0,&obj1)) goto fail;
11450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11451 if (SWIG_arg_fail(1)) SWIG_fail;
11452 {
11453 arg2 = wxString_in_helper(obj1);
11454 if (arg2 == NULL) SWIG_fail;
11455 temp2 = true;
11456 }
11457 {
11458 PyThreadState* __tstate = wxPyBeginAllowThreads();
11459 result = (bool)(arg1)->AddCatalog((wxString const &)*arg2);
11460
11461 wxPyEndAllowThreads(__tstate);
11462 if (PyErr_Occurred()) SWIG_fail;
11463 }
11464 {
11465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11466 }
11467 {
11468 if (temp2)
11469 delete arg2;
11470 }
11471 return resultobj;
11472 fail:
11473 {
11474 if (temp2)
11475 delete arg2;
11476 }
11477 return NULL;
11478 }
11479
11480
11481 static PyObject *_wrap_Locale_IsLoaded(PyObject *, PyObject *args, PyObject *kwargs) {
11482 PyObject *resultobj;
11483 wxLocale *arg1 = (wxLocale *) 0 ;
11484 wxString *arg2 = 0 ;
11485 bool result;
11486 bool temp2 = false ;
11487 PyObject * obj0 = 0 ;
11488 PyObject * obj1 = 0 ;
11489 char *kwnames[] = {
11490 (char *) "self",(char *) "szDomain", NULL
11491 };
11492
11493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_IsLoaded",kwnames,&obj0,&obj1)) goto fail;
11494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11495 if (SWIG_arg_fail(1)) SWIG_fail;
11496 {
11497 arg2 = wxString_in_helper(obj1);
11498 if (arg2 == NULL) SWIG_fail;
11499 temp2 = true;
11500 }
11501 {
11502 PyThreadState* __tstate = wxPyBeginAllowThreads();
11503 result = (bool)((wxLocale const *)arg1)->IsLoaded((wxString const &)*arg2);
11504
11505 wxPyEndAllowThreads(__tstate);
11506 if (PyErr_Occurred()) SWIG_fail;
11507 }
11508 {
11509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11510 }
11511 {
11512 if (temp2)
11513 delete arg2;
11514 }
11515 return resultobj;
11516 fail:
11517 {
11518 if (temp2)
11519 delete arg2;
11520 }
11521 return NULL;
11522 }
11523
11524
11525 static PyObject *_wrap_Locale_GetLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11526 PyObject *resultobj;
11527 int arg1 ;
11528 wxLanguageInfo *result;
11529 PyObject * obj0 = 0 ;
11530 char *kwnames[] = {
11531 (char *) "lang", NULL
11532 };
11533
11534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageInfo",kwnames,&obj0)) goto fail;
11535 {
11536 arg1 = (int)(SWIG_As_int(obj0));
11537 if (SWIG_arg_fail(1)) SWIG_fail;
11538 }
11539 {
11540 PyThreadState* __tstate = wxPyBeginAllowThreads();
11541 result = (wxLanguageInfo *)wxLocale::GetLanguageInfo(arg1);
11542
11543 wxPyEndAllowThreads(__tstate);
11544 if (PyErr_Occurred()) SWIG_fail;
11545 }
11546 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
11547 return resultobj;
11548 fail:
11549 return NULL;
11550 }
11551
11552
11553 static PyObject *_wrap_Locale_GetLanguageName(PyObject *, PyObject *args, PyObject *kwargs) {
11554 PyObject *resultobj;
11555 int arg1 ;
11556 wxString result;
11557 PyObject * obj0 = 0 ;
11558 char *kwnames[] = {
11559 (char *) "lang", NULL
11560 };
11561
11562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageName",kwnames,&obj0)) goto fail;
11563 {
11564 arg1 = (int)(SWIG_As_int(obj0));
11565 if (SWIG_arg_fail(1)) SWIG_fail;
11566 }
11567 {
11568 PyThreadState* __tstate = wxPyBeginAllowThreads();
11569 result = wxLocale::GetLanguageName(arg1);
11570
11571 wxPyEndAllowThreads(__tstate);
11572 if (PyErr_Occurred()) SWIG_fail;
11573 }
11574 {
11575 #if wxUSE_UNICODE
11576 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11577 #else
11578 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11579 #endif
11580 }
11581 return resultobj;
11582 fail:
11583 return NULL;
11584 }
11585
11586
11587 static PyObject *_wrap_Locale_FindLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11588 PyObject *resultobj;
11589 wxString *arg1 = 0 ;
11590 wxLanguageInfo *result;
11591 bool temp1 = false ;
11592 PyObject * obj0 = 0 ;
11593 char *kwnames[] = {
11594 (char *) "locale", NULL
11595 };
11596
11597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_FindLanguageInfo",kwnames,&obj0)) goto fail;
11598 {
11599 arg1 = wxString_in_helper(obj0);
11600 if (arg1 == NULL) SWIG_fail;
11601 temp1 = true;
11602 }
11603 {
11604 PyThreadState* __tstate = wxPyBeginAllowThreads();
11605 result = (wxLanguageInfo *)wxLocale::FindLanguageInfo((wxString const &)*arg1);
11606
11607 wxPyEndAllowThreads(__tstate);
11608 if (PyErr_Occurred()) SWIG_fail;
11609 }
11610 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
11611 {
11612 if (temp1)
11613 delete arg1;
11614 }
11615 return resultobj;
11616 fail:
11617 {
11618 if (temp1)
11619 delete arg1;
11620 }
11621 return NULL;
11622 }
11623
11624
11625 static PyObject *_wrap_Locale_AddLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11626 PyObject *resultobj;
11627 wxLanguageInfo *arg1 = 0 ;
11628 PyObject * obj0 = 0 ;
11629 char *kwnames[] = {
11630 (char *) "info", NULL
11631 };
11632
11633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddLanguage",kwnames,&obj0)) goto fail;
11634 {
11635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11636 if (SWIG_arg_fail(1)) SWIG_fail;
11637 if (arg1 == NULL) {
11638 SWIG_null_ref("wxLanguageInfo");
11639 }
11640 if (SWIG_arg_fail(1)) SWIG_fail;
11641 }
11642 {
11643 PyThreadState* __tstate = wxPyBeginAllowThreads();
11644 wxLocale::AddLanguage((wxLanguageInfo const &)*arg1);
11645
11646 wxPyEndAllowThreads(__tstate);
11647 if (PyErr_Occurred()) SWIG_fail;
11648 }
11649 Py_INCREF(Py_None); resultobj = Py_None;
11650 return resultobj;
11651 fail:
11652 return NULL;
11653 }
11654
11655
11656 static PyObject *_wrap_Locale_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
11657 PyObject *resultobj;
11658 wxLocale *arg1 = (wxLocale *) 0 ;
11659 wxString *arg2 = 0 ;
11660 wxString const &arg3_defvalue = wxPyEmptyString ;
11661 wxString *arg3 = (wxString *) &arg3_defvalue ;
11662 wxString result;
11663 bool temp2 = false ;
11664 bool temp3 = false ;
11665 PyObject * obj0 = 0 ;
11666 PyObject * obj1 = 0 ;
11667 PyObject * obj2 = 0 ;
11668 char *kwnames[] = {
11669 (char *) "self",(char *) "szOrigString",(char *) "szDomain", NULL
11670 };
11671
11672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Locale_GetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
11673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11674 if (SWIG_arg_fail(1)) SWIG_fail;
11675 {
11676 arg2 = wxString_in_helper(obj1);
11677 if (arg2 == NULL) SWIG_fail;
11678 temp2 = true;
11679 }
11680 if (obj2) {
11681 {
11682 arg3 = wxString_in_helper(obj2);
11683 if (arg3 == NULL) SWIG_fail;
11684 temp3 = true;
11685 }
11686 }
11687 {
11688 PyThreadState* __tstate = wxPyBeginAllowThreads();
11689 result = ((wxLocale const *)arg1)->GetString((wxString const &)*arg2,(wxString const &)*arg3);
11690
11691 wxPyEndAllowThreads(__tstate);
11692 if (PyErr_Occurred()) SWIG_fail;
11693 }
11694 {
11695 #if wxUSE_UNICODE
11696 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11697 #else
11698 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11699 #endif
11700 }
11701 {
11702 if (temp2)
11703 delete arg2;
11704 }
11705 {
11706 if (temp3)
11707 delete arg3;
11708 }
11709 return resultobj;
11710 fail:
11711 {
11712 if (temp2)
11713 delete arg2;
11714 }
11715 {
11716 if (temp3)
11717 delete arg3;
11718 }
11719 return NULL;
11720 }
11721
11722
11723 static PyObject *_wrap_Locale_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
11724 PyObject *resultobj;
11725 wxLocale *arg1 = (wxLocale *) 0 ;
11726 wxString *result;
11727 PyObject * obj0 = 0 ;
11728 char *kwnames[] = {
11729 (char *) "self", NULL
11730 };
11731
11732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetName",kwnames,&obj0)) goto fail;
11733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11734 if (SWIG_arg_fail(1)) SWIG_fail;
11735 {
11736 PyThreadState* __tstate = wxPyBeginAllowThreads();
11737 {
11738 wxString const &_result_ref = ((wxLocale const *)arg1)->GetName();
11739 result = (wxString *) &_result_ref;
11740 }
11741
11742 wxPyEndAllowThreads(__tstate);
11743 if (PyErr_Occurred()) SWIG_fail;
11744 }
11745 {
11746 #if wxUSE_UNICODE
11747 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
11748 #else
11749 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
11750 #endif
11751 }
11752 return resultobj;
11753 fail:
11754 return NULL;
11755 }
11756
11757
11758 static PyObject * Locale_swigregister(PyObject *, PyObject *args) {
11759 PyObject *obj;
11760 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11761 SWIG_TypeClientData(SWIGTYPE_p_wxLocale, obj);
11762 Py_INCREF(obj);
11763 return Py_BuildValue((char *)"");
11764 }
11765 static PyObject *_wrap_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
11766 PyObject *resultobj;
11767 wxLocale *result;
11768 char *kwnames[] = {
11769 NULL
11770 };
11771
11772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocale",kwnames)) goto fail;
11773 {
11774 PyThreadState* __tstate = wxPyBeginAllowThreads();
11775 result = (wxLocale *)wxGetLocale();
11776
11777 wxPyEndAllowThreads(__tstate);
11778 if (PyErr_Occurred()) SWIG_fail;
11779 }
11780 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 0);
11781 return resultobj;
11782 fail:
11783 return NULL;
11784 }
11785
11786
11787 static PyObject *_wrap_GetTranslation__SWIG_0(PyObject *, PyObject *args) {
11788 PyObject *resultobj;
11789 wxString *arg1 = 0 ;
11790 wxString result;
11791 bool temp1 = false ;
11792 PyObject * obj0 = 0 ;
11793
11794 if(!PyArg_ParseTuple(args,(char *)"O:GetTranslation",&obj0)) goto fail;
11795 {
11796 arg1 = wxString_in_helper(obj0);
11797 if (arg1 == NULL) SWIG_fail;
11798 temp1 = true;
11799 }
11800 {
11801 PyThreadState* __tstate = wxPyBeginAllowThreads();
11802 result = wxGetTranslation((wxString const &)*arg1);
11803
11804 wxPyEndAllowThreads(__tstate);
11805 if (PyErr_Occurred()) SWIG_fail;
11806 }
11807 {
11808 #if wxUSE_UNICODE
11809 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11810 #else
11811 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11812 #endif
11813 }
11814 {
11815 if (temp1)
11816 delete arg1;
11817 }
11818 return resultobj;
11819 fail:
11820 {
11821 if (temp1)
11822 delete arg1;
11823 }
11824 return NULL;
11825 }
11826
11827
11828 static PyObject *_wrap_GetTranslation__SWIG_1(PyObject *, PyObject *args) {
11829 PyObject *resultobj;
11830 wxString *arg1 = 0 ;
11831 wxString *arg2 = 0 ;
11832 size_t arg3 ;
11833 wxString result;
11834 bool temp1 = false ;
11835 bool temp2 = false ;
11836 PyObject * obj0 = 0 ;
11837 PyObject * obj1 = 0 ;
11838 PyObject * obj2 = 0 ;
11839
11840 if(!PyArg_ParseTuple(args,(char *)"OOO:GetTranslation",&obj0,&obj1,&obj2)) goto fail;
11841 {
11842 arg1 = wxString_in_helper(obj0);
11843 if (arg1 == NULL) SWIG_fail;
11844 temp1 = true;
11845 }
11846 {
11847 arg2 = wxString_in_helper(obj1);
11848 if (arg2 == NULL) SWIG_fail;
11849 temp2 = true;
11850 }
11851 {
11852 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
11853 if (SWIG_arg_fail(3)) SWIG_fail;
11854 }
11855 {
11856 PyThreadState* __tstate = wxPyBeginAllowThreads();
11857 result = wxGetTranslation((wxString const &)*arg1,(wxString const &)*arg2,arg3);
11858
11859 wxPyEndAllowThreads(__tstate);
11860 if (PyErr_Occurred()) SWIG_fail;
11861 }
11862 {
11863 #if wxUSE_UNICODE
11864 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11865 #else
11866 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11867 #endif
11868 }
11869 {
11870 if (temp1)
11871 delete arg1;
11872 }
11873 {
11874 if (temp2)
11875 delete arg2;
11876 }
11877 return resultobj;
11878 fail:
11879 {
11880 if (temp1)
11881 delete arg1;
11882 }
11883 {
11884 if (temp2)
11885 delete arg2;
11886 }
11887 return NULL;
11888 }
11889
11890
11891 static PyObject *_wrap_GetTranslation(PyObject *self, PyObject *args) {
11892 int argc;
11893 PyObject *argv[4];
11894 int ii;
11895
11896 argc = PyObject_Length(args);
11897 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
11898 argv[ii] = PyTuple_GetItem(args,ii);
11899 }
11900 if (argc == 1) {
11901 int _v;
11902 {
11903 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
11904 }
11905 if (_v) {
11906 return _wrap_GetTranslation__SWIG_0(self,args);
11907 }
11908 }
11909 if (argc == 3) {
11910 int _v;
11911 {
11912 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
11913 }
11914 if (_v) {
11915 {
11916 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
11917 }
11918 if (_v) {
11919 _v = SWIG_Check_unsigned_SS_long(argv[2]);
11920 if (_v) {
11921 return _wrap_GetTranslation__SWIG_1(self,args);
11922 }
11923 }
11924 }
11925 }
11926
11927 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GetTranslation'");
11928 return NULL;
11929 }
11930
11931
11932 static PyObject *_wrap_new_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
11933 PyObject *resultobj;
11934 wxEncodingConverter *result;
11935 char *kwnames[] = {
11936 NULL
11937 };
11938
11939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EncodingConverter",kwnames)) goto fail;
11940 {
11941 PyThreadState* __tstate = wxPyBeginAllowThreads();
11942 result = (wxEncodingConverter *)new wxEncodingConverter();
11943
11944 wxPyEndAllowThreads(__tstate);
11945 if (PyErr_Occurred()) SWIG_fail;
11946 }
11947 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEncodingConverter, 1);
11948 return resultobj;
11949 fail:
11950 return NULL;
11951 }
11952
11953
11954 static PyObject *_wrap_delete_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
11955 PyObject *resultobj;
11956 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
11957 PyObject * obj0 = 0 ;
11958 char *kwnames[] = {
11959 (char *) "self", NULL
11960 };
11961
11962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EncodingConverter",kwnames,&obj0)) goto fail;
11963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
11964 if (SWIG_arg_fail(1)) SWIG_fail;
11965 {
11966 PyThreadState* __tstate = wxPyBeginAllowThreads();
11967 delete arg1;
11968
11969 wxPyEndAllowThreads(__tstate);
11970 if (PyErr_Occurred()) SWIG_fail;
11971 }
11972 Py_INCREF(Py_None); resultobj = Py_None;
11973 return resultobj;
11974 fail:
11975 return NULL;
11976 }
11977
11978
11979 static PyObject *_wrap_EncodingConverter_Init(PyObject *, PyObject *args, PyObject *kwargs) {
11980 PyObject *resultobj;
11981 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
11982 wxFontEncoding arg2 ;
11983 wxFontEncoding arg3 ;
11984 int arg4 = (int) wxCONVERT_STRICT ;
11985 bool result;
11986 PyObject * obj0 = 0 ;
11987 PyObject * obj1 = 0 ;
11988 PyObject * obj2 = 0 ;
11989 PyObject * obj3 = 0 ;
11990 char *kwnames[] = {
11991 (char *) "self",(char *) "input_enc",(char *) "output_enc",(char *) "method", NULL
11992 };
11993
11994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:EncodingConverter_Init",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
11996 if (SWIG_arg_fail(1)) SWIG_fail;
11997 {
11998 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
11999 if (SWIG_arg_fail(2)) SWIG_fail;
12000 }
12001 {
12002 arg3 = (wxFontEncoding)(SWIG_As_int(obj2));
12003 if (SWIG_arg_fail(3)) SWIG_fail;
12004 }
12005 if (obj3) {
12006 {
12007 arg4 = (int)(SWIG_As_int(obj3));
12008 if (SWIG_arg_fail(4)) SWIG_fail;
12009 }
12010 }
12011 {
12012 PyThreadState* __tstate = wxPyBeginAllowThreads();
12013 result = (bool)(arg1)->Init((wxFontEncoding )arg2,(wxFontEncoding )arg3,arg4);
12014
12015 wxPyEndAllowThreads(__tstate);
12016 if (PyErr_Occurred()) SWIG_fail;
12017 }
12018 {
12019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12020 }
12021 return resultobj;
12022 fail:
12023 return NULL;
12024 }
12025
12026
12027 static PyObject *_wrap_EncodingConverter_Convert(PyObject *, PyObject *args, PyObject *kwargs) {
12028 PyObject *resultobj;
12029 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12030 wxString *arg2 = 0 ;
12031 wxString result;
12032 bool temp2 = false ;
12033 PyObject * obj0 = 0 ;
12034 PyObject * obj1 = 0 ;
12035 char *kwnames[] = {
12036 (char *) "self",(char *) "input", NULL
12037 };
12038
12039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_Convert",kwnames,&obj0,&obj1)) goto fail;
12040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12041 if (SWIG_arg_fail(1)) SWIG_fail;
12042 {
12043 arg2 = wxString_in_helper(obj1);
12044 if (arg2 == NULL) SWIG_fail;
12045 temp2 = true;
12046 }
12047 {
12048 PyThreadState* __tstate = wxPyBeginAllowThreads();
12049 result = (arg1)->Convert((wxString const &)*arg2);
12050
12051 wxPyEndAllowThreads(__tstate);
12052 if (PyErr_Occurred()) SWIG_fail;
12053 }
12054 {
12055 #if wxUSE_UNICODE
12056 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12057 #else
12058 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12059 #endif
12060 }
12061 {
12062 if (temp2)
12063 delete arg2;
12064 }
12065 return resultobj;
12066 fail:
12067 {
12068 if (temp2)
12069 delete arg2;
12070 }
12071 return NULL;
12072 }
12073
12074
12075 static PyObject *_wrap_EncodingConverter_GetPlatformEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12076 PyObject *resultobj;
12077 wxFontEncoding arg1 ;
12078 int arg2 = (int) wxPLATFORM_CURRENT ;
12079 wxFontEncodingArray result;
12080 PyObject * obj0 = 0 ;
12081 PyObject * obj1 = 0 ;
12082 char *kwnames[] = {
12083 (char *) "enc",(char *) "platform", NULL
12084 };
12085
12086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EncodingConverter_GetPlatformEquivalents",kwnames,&obj0,&obj1)) goto fail;
12087 {
12088 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12089 if (SWIG_arg_fail(1)) SWIG_fail;
12090 }
12091 if (obj1) {
12092 {
12093 arg2 = (int)(SWIG_As_int(obj1));
12094 if (SWIG_arg_fail(2)) SWIG_fail;
12095 }
12096 }
12097 {
12098 PyThreadState* __tstate = wxPyBeginAllowThreads();
12099 result = wxEncodingConverter::GetPlatformEquivalents((wxFontEncoding )arg1,arg2);
12100
12101 wxPyEndAllowThreads(__tstate);
12102 if (PyErr_Occurred()) SWIG_fail;
12103 }
12104 {
12105 resultobj = PyList_New(0);
12106 for (size_t i=0; i < (&result)->GetCount(); i++) {
12107 PyObject* number = PyInt_FromLong((&result)->Item(i));
12108 PyList_Append(resultobj, number);
12109 Py_DECREF(number);
12110 }
12111 }
12112 return resultobj;
12113 fail:
12114 return NULL;
12115 }
12116
12117
12118 static PyObject *_wrap_EncodingConverter_GetAllEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12119 PyObject *resultobj;
12120 wxFontEncoding arg1 ;
12121 wxFontEncodingArray result;
12122 PyObject * obj0 = 0 ;
12123 char *kwnames[] = {
12124 (char *) "enc", NULL
12125 };
12126
12127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EncodingConverter_GetAllEquivalents",kwnames,&obj0)) goto fail;
12128 {
12129 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12130 if (SWIG_arg_fail(1)) SWIG_fail;
12131 }
12132 {
12133 PyThreadState* __tstate = wxPyBeginAllowThreads();
12134 result = wxEncodingConverter::GetAllEquivalents((wxFontEncoding )arg1);
12135
12136 wxPyEndAllowThreads(__tstate);
12137 if (PyErr_Occurred()) SWIG_fail;
12138 }
12139 {
12140 resultobj = PyList_New(0);
12141 for (size_t i=0; i < (&result)->GetCount(); i++) {
12142 PyObject* number = PyInt_FromLong((&result)->Item(i));
12143 PyList_Append(resultobj, number);
12144 Py_DECREF(number);
12145 }
12146 }
12147 return resultobj;
12148 fail:
12149 return NULL;
12150 }
12151
12152
12153 static PyObject *_wrap_EncodingConverter_CanConvert(PyObject *, PyObject *args, PyObject *kwargs) {
12154 PyObject *resultobj;
12155 wxFontEncoding arg1 ;
12156 wxFontEncoding arg2 ;
12157 bool result;
12158 PyObject * obj0 = 0 ;
12159 PyObject * obj1 = 0 ;
12160 char *kwnames[] = {
12161 (char *) "encIn",(char *) "encOut", NULL
12162 };
12163
12164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_CanConvert",kwnames,&obj0,&obj1)) goto fail;
12165 {
12166 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12167 if (SWIG_arg_fail(1)) SWIG_fail;
12168 }
12169 {
12170 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12171 if (SWIG_arg_fail(2)) SWIG_fail;
12172 }
12173 {
12174 PyThreadState* __tstate = wxPyBeginAllowThreads();
12175 result = (bool)wxEncodingConverter::CanConvert((wxFontEncoding )arg1,(wxFontEncoding )arg2);
12176
12177 wxPyEndAllowThreads(__tstate);
12178 if (PyErr_Occurred()) SWIG_fail;
12179 }
12180 {
12181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12182 }
12183 return resultobj;
12184 fail:
12185 return NULL;
12186 }
12187
12188
12189 static PyObject * EncodingConverter_swigregister(PyObject *, PyObject *args) {
12190 PyObject *obj;
12191 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12192 SWIG_TypeClientData(SWIGTYPE_p_wxEncodingConverter, obj);
12193 Py_INCREF(obj);
12194 return Py_BuildValue((char *)"");
12195 }
12196 static PyObject *_wrap_delete_DC(PyObject *, PyObject *args, PyObject *kwargs) {
12197 PyObject *resultobj;
12198 wxDC *arg1 = (wxDC *) 0 ;
12199 PyObject * obj0 = 0 ;
12200 char *kwnames[] = {
12201 (char *) "self", NULL
12202 };
12203
12204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DC",kwnames,&obj0)) goto fail;
12205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12206 if (SWIG_arg_fail(1)) SWIG_fail;
12207 {
12208 PyThreadState* __tstate = wxPyBeginAllowThreads();
12209 delete arg1;
12210
12211 wxPyEndAllowThreads(__tstate);
12212 if (PyErr_Occurred()) SWIG_fail;
12213 }
12214 Py_INCREF(Py_None); resultobj = Py_None;
12215 return resultobj;
12216 fail:
12217 return NULL;
12218 }
12219
12220
12221 static PyObject *_wrap_DC_BeginDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12222 PyObject *resultobj;
12223 wxDC *arg1 = (wxDC *) 0 ;
12224 PyObject * obj0 = 0 ;
12225 char *kwnames[] = {
12226 (char *) "self", NULL
12227 };
12228
12229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_BeginDrawing",kwnames,&obj0)) goto fail;
12230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12231 if (SWIG_arg_fail(1)) SWIG_fail;
12232 {
12233 PyThreadState* __tstate = wxPyBeginAllowThreads();
12234 (arg1)->BeginDrawing();
12235
12236 wxPyEndAllowThreads(__tstate);
12237 if (PyErr_Occurred()) SWIG_fail;
12238 }
12239 Py_INCREF(Py_None); resultobj = Py_None;
12240 return resultobj;
12241 fail:
12242 return NULL;
12243 }
12244
12245
12246 static PyObject *_wrap_DC_EndDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12247 PyObject *resultobj;
12248 wxDC *arg1 = (wxDC *) 0 ;
12249 PyObject * obj0 = 0 ;
12250 char *kwnames[] = {
12251 (char *) "self", NULL
12252 };
12253
12254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDrawing",kwnames,&obj0)) goto fail;
12255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12256 if (SWIG_arg_fail(1)) SWIG_fail;
12257 {
12258 PyThreadState* __tstate = wxPyBeginAllowThreads();
12259 (arg1)->EndDrawing();
12260
12261 wxPyEndAllowThreads(__tstate);
12262 if (PyErr_Occurred()) SWIG_fail;
12263 }
12264 Py_INCREF(Py_None); resultobj = Py_None;
12265 return resultobj;
12266 fail:
12267 return NULL;
12268 }
12269
12270
12271 static PyObject *_wrap_DC_FloodFill(PyObject *, PyObject *args, PyObject *kwargs) {
12272 PyObject *resultobj;
12273 wxDC *arg1 = (wxDC *) 0 ;
12274 int arg2 ;
12275 int arg3 ;
12276 wxColour *arg4 = 0 ;
12277 int arg5 = (int) wxFLOOD_SURFACE ;
12278 bool result;
12279 wxColour temp4 ;
12280 PyObject * obj0 = 0 ;
12281 PyObject * obj1 = 0 ;
12282 PyObject * obj2 = 0 ;
12283 PyObject * obj3 = 0 ;
12284 PyObject * obj4 = 0 ;
12285 char *kwnames[] = {
12286 (char *) "self",(char *) "x",(char *) "y",(char *) "col",(char *) "style", NULL
12287 };
12288
12289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_FloodFill",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12291 if (SWIG_arg_fail(1)) SWIG_fail;
12292 {
12293 arg2 = (int)(SWIG_As_int(obj1));
12294 if (SWIG_arg_fail(2)) SWIG_fail;
12295 }
12296 {
12297 arg3 = (int)(SWIG_As_int(obj2));
12298 if (SWIG_arg_fail(3)) SWIG_fail;
12299 }
12300 {
12301 arg4 = &temp4;
12302 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
12303 }
12304 if (obj4) {
12305 {
12306 arg5 = (int)(SWIG_As_int(obj4));
12307 if (SWIG_arg_fail(5)) SWIG_fail;
12308 }
12309 }
12310 {
12311 PyThreadState* __tstate = wxPyBeginAllowThreads();
12312 result = (bool)(arg1)->FloodFill(arg2,arg3,(wxColour const &)*arg4,arg5);
12313
12314 wxPyEndAllowThreads(__tstate);
12315 if (PyErr_Occurred()) SWIG_fail;
12316 }
12317 {
12318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12319 }
12320 return resultobj;
12321 fail:
12322 return NULL;
12323 }
12324
12325
12326 static PyObject *_wrap_DC_FloodFillPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12327 PyObject *resultobj;
12328 wxDC *arg1 = (wxDC *) 0 ;
12329 wxPoint *arg2 = 0 ;
12330 wxColour *arg3 = 0 ;
12331 int arg4 = (int) wxFLOOD_SURFACE ;
12332 bool result;
12333 wxPoint temp2 ;
12334 wxColour temp3 ;
12335 PyObject * obj0 = 0 ;
12336 PyObject * obj1 = 0 ;
12337 PyObject * obj2 = 0 ;
12338 PyObject * obj3 = 0 ;
12339 char *kwnames[] = {
12340 (char *) "self",(char *) "pt",(char *) "col",(char *) "style", NULL
12341 };
12342
12343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_FloodFillPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12345 if (SWIG_arg_fail(1)) SWIG_fail;
12346 {
12347 arg2 = &temp2;
12348 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12349 }
12350 {
12351 arg3 = &temp3;
12352 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
12353 }
12354 if (obj3) {
12355 {
12356 arg4 = (int)(SWIG_As_int(obj3));
12357 if (SWIG_arg_fail(4)) SWIG_fail;
12358 }
12359 }
12360 {
12361 PyThreadState* __tstate = wxPyBeginAllowThreads();
12362 result = (bool)(arg1)->FloodFill((wxPoint const &)*arg2,(wxColour const &)*arg3,arg4);
12363
12364 wxPyEndAllowThreads(__tstate);
12365 if (PyErr_Occurred()) SWIG_fail;
12366 }
12367 {
12368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12369 }
12370 return resultobj;
12371 fail:
12372 return NULL;
12373 }
12374
12375
12376 static PyObject *_wrap_DC_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
12377 PyObject *resultobj;
12378 wxDC *arg1 = (wxDC *) 0 ;
12379 int arg2 ;
12380 int arg3 ;
12381 wxColour result;
12382 PyObject * obj0 = 0 ;
12383 PyObject * obj1 = 0 ;
12384 PyObject * obj2 = 0 ;
12385 char *kwnames[] = {
12386 (char *) "self",(char *) "x",(char *) "y", NULL
12387 };
12388
12389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_GetPixel",kwnames,&obj0,&obj1,&obj2)) goto fail;
12390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12391 if (SWIG_arg_fail(1)) SWIG_fail;
12392 {
12393 arg2 = (int)(SWIG_As_int(obj1));
12394 if (SWIG_arg_fail(2)) SWIG_fail;
12395 }
12396 {
12397 arg3 = (int)(SWIG_As_int(obj2));
12398 if (SWIG_arg_fail(3)) SWIG_fail;
12399 }
12400 {
12401 PyThreadState* __tstate = wxPyBeginAllowThreads();
12402 result = wxDC_GetPixel(arg1,arg2,arg3);
12403
12404 wxPyEndAllowThreads(__tstate);
12405 if (PyErr_Occurred()) SWIG_fail;
12406 }
12407 {
12408 wxColour * resultptr;
12409 resultptr = new wxColour((wxColour &)(result));
12410 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12411 }
12412 return resultobj;
12413 fail:
12414 return NULL;
12415 }
12416
12417
12418 static PyObject *_wrap_DC_GetPixelPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12419 PyObject *resultobj;
12420 wxDC *arg1 = (wxDC *) 0 ;
12421 wxPoint *arg2 = 0 ;
12422 wxColour result;
12423 wxPoint temp2 ;
12424 PyObject * obj0 = 0 ;
12425 PyObject * obj1 = 0 ;
12426 char *kwnames[] = {
12427 (char *) "self",(char *) "pt", NULL
12428 };
12429
12430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPixelPoint",kwnames,&obj0,&obj1)) goto fail;
12431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12432 if (SWIG_arg_fail(1)) SWIG_fail;
12433 {
12434 arg2 = &temp2;
12435 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12436 }
12437 {
12438 PyThreadState* __tstate = wxPyBeginAllowThreads();
12439 result = wxDC_GetPixelPoint(arg1,(wxPoint const &)*arg2);
12440
12441 wxPyEndAllowThreads(__tstate);
12442 if (PyErr_Occurred()) SWIG_fail;
12443 }
12444 {
12445 wxColour * resultptr;
12446 resultptr = new wxColour((wxColour &)(result));
12447 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12448 }
12449 return resultobj;
12450 fail:
12451 return NULL;
12452 }
12453
12454
12455 static PyObject *_wrap_DC_DrawLine(PyObject *, PyObject *args, PyObject *kwargs) {
12456 PyObject *resultobj;
12457 wxDC *arg1 = (wxDC *) 0 ;
12458 int arg2 ;
12459 int arg3 ;
12460 int arg4 ;
12461 int arg5 ;
12462 PyObject * obj0 = 0 ;
12463 PyObject * obj1 = 0 ;
12464 PyObject * obj2 = 0 ;
12465 PyObject * obj3 = 0 ;
12466 PyObject * obj4 = 0 ;
12467 char *kwnames[] = {
12468 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2", NULL
12469 };
12470
12471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawLine",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12473 if (SWIG_arg_fail(1)) SWIG_fail;
12474 {
12475 arg2 = (int)(SWIG_As_int(obj1));
12476 if (SWIG_arg_fail(2)) SWIG_fail;
12477 }
12478 {
12479 arg3 = (int)(SWIG_As_int(obj2));
12480 if (SWIG_arg_fail(3)) SWIG_fail;
12481 }
12482 {
12483 arg4 = (int)(SWIG_As_int(obj3));
12484 if (SWIG_arg_fail(4)) SWIG_fail;
12485 }
12486 {
12487 arg5 = (int)(SWIG_As_int(obj4));
12488 if (SWIG_arg_fail(5)) SWIG_fail;
12489 }
12490 {
12491 PyThreadState* __tstate = wxPyBeginAllowThreads();
12492 (arg1)->DrawLine(arg2,arg3,arg4,arg5);
12493
12494 wxPyEndAllowThreads(__tstate);
12495 if (PyErr_Occurred()) SWIG_fail;
12496 }
12497 Py_INCREF(Py_None); resultobj = Py_None;
12498 return resultobj;
12499 fail:
12500 return NULL;
12501 }
12502
12503
12504 static PyObject *_wrap_DC_DrawLinePoint(PyObject *, PyObject *args, PyObject *kwargs) {
12505 PyObject *resultobj;
12506 wxDC *arg1 = (wxDC *) 0 ;
12507 wxPoint *arg2 = 0 ;
12508 wxPoint *arg3 = 0 ;
12509 wxPoint temp2 ;
12510 wxPoint temp3 ;
12511 PyObject * obj0 = 0 ;
12512 PyObject * obj1 = 0 ;
12513 PyObject * obj2 = 0 ;
12514 char *kwnames[] = {
12515 (char *) "self",(char *) "pt1",(char *) "pt2", NULL
12516 };
12517
12518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawLinePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
12519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12520 if (SWIG_arg_fail(1)) SWIG_fail;
12521 {
12522 arg2 = &temp2;
12523 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12524 }
12525 {
12526 arg3 = &temp3;
12527 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12528 }
12529 {
12530 PyThreadState* __tstate = wxPyBeginAllowThreads();
12531 (arg1)->DrawLine((wxPoint const &)*arg2,(wxPoint const &)*arg3);
12532
12533 wxPyEndAllowThreads(__tstate);
12534 if (PyErr_Occurred()) SWIG_fail;
12535 }
12536 Py_INCREF(Py_None); resultobj = Py_None;
12537 return resultobj;
12538 fail:
12539 return NULL;
12540 }
12541
12542
12543 static PyObject *_wrap_DC_CrossHair(PyObject *, PyObject *args, PyObject *kwargs) {
12544 PyObject *resultobj;
12545 wxDC *arg1 = (wxDC *) 0 ;
12546 int arg2 ;
12547 int arg3 ;
12548 PyObject * obj0 = 0 ;
12549 PyObject * obj1 = 0 ;
12550 PyObject * obj2 = 0 ;
12551 char *kwnames[] = {
12552 (char *) "self",(char *) "x",(char *) "y", NULL
12553 };
12554
12555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CrossHair",kwnames,&obj0,&obj1,&obj2)) goto fail;
12556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12557 if (SWIG_arg_fail(1)) SWIG_fail;
12558 {
12559 arg2 = (int)(SWIG_As_int(obj1));
12560 if (SWIG_arg_fail(2)) SWIG_fail;
12561 }
12562 {
12563 arg3 = (int)(SWIG_As_int(obj2));
12564 if (SWIG_arg_fail(3)) SWIG_fail;
12565 }
12566 {
12567 PyThreadState* __tstate = wxPyBeginAllowThreads();
12568 (arg1)->CrossHair(arg2,arg3);
12569
12570 wxPyEndAllowThreads(__tstate);
12571 if (PyErr_Occurred()) SWIG_fail;
12572 }
12573 Py_INCREF(Py_None); resultobj = Py_None;
12574 return resultobj;
12575 fail:
12576 return NULL;
12577 }
12578
12579
12580 static PyObject *_wrap_DC_CrossHairPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12581 PyObject *resultobj;
12582 wxDC *arg1 = (wxDC *) 0 ;
12583 wxPoint *arg2 = 0 ;
12584 wxPoint temp2 ;
12585 PyObject * obj0 = 0 ;
12586 PyObject * obj1 = 0 ;
12587 char *kwnames[] = {
12588 (char *) "self",(char *) "pt", NULL
12589 };
12590
12591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CrossHairPoint",kwnames,&obj0,&obj1)) goto fail;
12592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12593 if (SWIG_arg_fail(1)) SWIG_fail;
12594 {
12595 arg2 = &temp2;
12596 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12597 }
12598 {
12599 PyThreadState* __tstate = wxPyBeginAllowThreads();
12600 (arg1)->CrossHair((wxPoint const &)*arg2);
12601
12602 wxPyEndAllowThreads(__tstate);
12603 if (PyErr_Occurred()) SWIG_fail;
12604 }
12605 Py_INCREF(Py_None); resultobj = Py_None;
12606 return resultobj;
12607 fail:
12608 return NULL;
12609 }
12610
12611
12612 static PyObject *_wrap_DC_DrawArc(PyObject *, PyObject *args, PyObject *kwargs) {
12613 PyObject *resultobj;
12614 wxDC *arg1 = (wxDC *) 0 ;
12615 int arg2 ;
12616 int arg3 ;
12617 int arg4 ;
12618 int arg5 ;
12619 int arg6 ;
12620 int arg7 ;
12621 PyObject * obj0 = 0 ;
12622 PyObject * obj1 = 0 ;
12623 PyObject * obj2 = 0 ;
12624 PyObject * obj3 = 0 ;
12625 PyObject * obj4 = 0 ;
12626 PyObject * obj5 = 0 ;
12627 PyObject * obj6 = 0 ;
12628 char *kwnames[] = {
12629 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2",(char *) "xc",(char *) "yc", NULL
12630 };
12631
12632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12634 if (SWIG_arg_fail(1)) SWIG_fail;
12635 {
12636 arg2 = (int)(SWIG_As_int(obj1));
12637 if (SWIG_arg_fail(2)) SWIG_fail;
12638 }
12639 {
12640 arg3 = (int)(SWIG_As_int(obj2));
12641 if (SWIG_arg_fail(3)) SWIG_fail;
12642 }
12643 {
12644 arg4 = (int)(SWIG_As_int(obj3));
12645 if (SWIG_arg_fail(4)) SWIG_fail;
12646 }
12647 {
12648 arg5 = (int)(SWIG_As_int(obj4));
12649 if (SWIG_arg_fail(5)) SWIG_fail;
12650 }
12651 {
12652 arg6 = (int)(SWIG_As_int(obj5));
12653 if (SWIG_arg_fail(6)) SWIG_fail;
12654 }
12655 {
12656 arg7 = (int)(SWIG_As_int(obj6));
12657 if (SWIG_arg_fail(7)) SWIG_fail;
12658 }
12659 {
12660 PyThreadState* __tstate = wxPyBeginAllowThreads();
12661 (arg1)->DrawArc(arg2,arg3,arg4,arg5,arg6,arg7);
12662
12663 wxPyEndAllowThreads(__tstate);
12664 if (PyErr_Occurred()) SWIG_fail;
12665 }
12666 Py_INCREF(Py_None); resultobj = Py_None;
12667 return resultobj;
12668 fail:
12669 return NULL;
12670 }
12671
12672
12673 static PyObject *_wrap_DC_DrawArcPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12674 PyObject *resultobj;
12675 wxDC *arg1 = (wxDC *) 0 ;
12676 wxPoint *arg2 = 0 ;
12677 wxPoint *arg3 = 0 ;
12678 wxPoint *arg4 = 0 ;
12679 wxPoint temp2 ;
12680 wxPoint temp3 ;
12681 wxPoint temp4 ;
12682 PyObject * obj0 = 0 ;
12683 PyObject * obj1 = 0 ;
12684 PyObject * obj2 = 0 ;
12685 PyObject * obj3 = 0 ;
12686 char *kwnames[] = {
12687 (char *) "self",(char *) "pt1",(char *) "pt2",(char *) "center", NULL
12688 };
12689
12690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawArcPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12692 if (SWIG_arg_fail(1)) SWIG_fail;
12693 {
12694 arg2 = &temp2;
12695 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12696 }
12697 {
12698 arg3 = &temp3;
12699 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12700 }
12701 {
12702 arg4 = &temp4;
12703 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
12704 }
12705 {
12706 PyThreadState* __tstate = wxPyBeginAllowThreads();
12707 (arg1)->DrawArc((wxPoint const &)*arg2,(wxPoint const &)*arg3,(wxPoint const &)*arg4);
12708
12709 wxPyEndAllowThreads(__tstate);
12710 if (PyErr_Occurred()) SWIG_fail;
12711 }
12712 Py_INCREF(Py_None); resultobj = Py_None;
12713 return resultobj;
12714 fail:
12715 return NULL;
12716 }
12717
12718
12719 static PyObject *_wrap_DC_DrawCheckMark(PyObject *, PyObject *args, PyObject *kwargs) {
12720 PyObject *resultobj;
12721 wxDC *arg1 = (wxDC *) 0 ;
12722 int arg2 ;
12723 int arg3 ;
12724 int arg4 ;
12725 int arg5 ;
12726 PyObject * obj0 = 0 ;
12727 PyObject * obj1 = 0 ;
12728 PyObject * obj2 = 0 ;
12729 PyObject * obj3 = 0 ;
12730 PyObject * obj4 = 0 ;
12731 char *kwnames[] = {
12732 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
12733 };
12734
12735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawCheckMark",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12737 if (SWIG_arg_fail(1)) SWIG_fail;
12738 {
12739 arg2 = (int)(SWIG_As_int(obj1));
12740 if (SWIG_arg_fail(2)) SWIG_fail;
12741 }
12742 {
12743 arg3 = (int)(SWIG_As_int(obj2));
12744 if (SWIG_arg_fail(3)) SWIG_fail;
12745 }
12746 {
12747 arg4 = (int)(SWIG_As_int(obj3));
12748 if (SWIG_arg_fail(4)) SWIG_fail;
12749 }
12750 {
12751 arg5 = (int)(SWIG_As_int(obj4));
12752 if (SWIG_arg_fail(5)) SWIG_fail;
12753 }
12754 {
12755 PyThreadState* __tstate = wxPyBeginAllowThreads();
12756 (arg1)->DrawCheckMark(arg2,arg3,arg4,arg5);
12757
12758 wxPyEndAllowThreads(__tstate);
12759 if (PyErr_Occurred()) SWIG_fail;
12760 }
12761 Py_INCREF(Py_None); resultobj = Py_None;
12762 return resultobj;
12763 fail:
12764 return NULL;
12765 }
12766
12767
12768 static PyObject *_wrap_DC_DrawCheckMarkRect(PyObject *, PyObject *args, PyObject *kwargs) {
12769 PyObject *resultobj;
12770 wxDC *arg1 = (wxDC *) 0 ;
12771 wxRect *arg2 = 0 ;
12772 wxRect temp2 ;
12773 PyObject * obj0 = 0 ;
12774 PyObject * obj1 = 0 ;
12775 char *kwnames[] = {
12776 (char *) "self",(char *) "rect", NULL
12777 };
12778
12779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawCheckMarkRect",kwnames,&obj0,&obj1)) goto fail;
12780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12781 if (SWIG_arg_fail(1)) SWIG_fail;
12782 {
12783 arg2 = &temp2;
12784 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12785 }
12786 {
12787 PyThreadState* __tstate = wxPyBeginAllowThreads();
12788 (arg1)->DrawCheckMark((wxRect const &)*arg2);
12789
12790 wxPyEndAllowThreads(__tstate);
12791 if (PyErr_Occurred()) SWIG_fail;
12792 }
12793 Py_INCREF(Py_None); resultobj = Py_None;
12794 return resultobj;
12795 fail:
12796 return NULL;
12797 }
12798
12799
12800 static PyObject *_wrap_DC_DrawEllipticArc(PyObject *, PyObject *args, PyObject *kwargs) {
12801 PyObject *resultobj;
12802 wxDC *arg1 = (wxDC *) 0 ;
12803 int arg2 ;
12804 int arg3 ;
12805 int arg4 ;
12806 int arg5 ;
12807 double arg6 ;
12808 double arg7 ;
12809 PyObject * obj0 = 0 ;
12810 PyObject * obj1 = 0 ;
12811 PyObject * obj2 = 0 ;
12812 PyObject * obj3 = 0 ;
12813 PyObject * obj4 = 0 ;
12814 PyObject * obj5 = 0 ;
12815 PyObject * obj6 = 0 ;
12816 char *kwnames[] = {
12817 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h",(char *) "start",(char *) "end", NULL
12818 };
12819
12820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawEllipticArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12822 if (SWIG_arg_fail(1)) SWIG_fail;
12823 {
12824 arg2 = (int)(SWIG_As_int(obj1));
12825 if (SWIG_arg_fail(2)) SWIG_fail;
12826 }
12827 {
12828 arg3 = (int)(SWIG_As_int(obj2));
12829 if (SWIG_arg_fail(3)) SWIG_fail;
12830 }
12831 {
12832 arg4 = (int)(SWIG_As_int(obj3));
12833 if (SWIG_arg_fail(4)) SWIG_fail;
12834 }
12835 {
12836 arg5 = (int)(SWIG_As_int(obj4));
12837 if (SWIG_arg_fail(5)) SWIG_fail;
12838 }
12839 {
12840 arg6 = (double)(SWIG_As_double(obj5));
12841 if (SWIG_arg_fail(6)) SWIG_fail;
12842 }
12843 {
12844 arg7 = (double)(SWIG_As_double(obj6));
12845 if (SWIG_arg_fail(7)) SWIG_fail;
12846 }
12847 {
12848 PyThreadState* __tstate = wxPyBeginAllowThreads();
12849 (arg1)->DrawEllipticArc(arg2,arg3,arg4,arg5,arg6,arg7);
12850
12851 wxPyEndAllowThreads(__tstate);
12852 if (PyErr_Occurred()) SWIG_fail;
12853 }
12854 Py_INCREF(Py_None); resultobj = Py_None;
12855 return resultobj;
12856 fail:
12857 return NULL;
12858 }
12859
12860
12861 static PyObject *_wrap_DC_DrawEllipticArcPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
12862 PyObject *resultobj;
12863 wxDC *arg1 = (wxDC *) 0 ;
12864 wxPoint *arg2 = 0 ;
12865 wxSize *arg3 = 0 ;
12866 double arg4 ;
12867 double arg5 ;
12868 wxPoint temp2 ;
12869 wxSize temp3 ;
12870 PyObject * obj0 = 0 ;
12871 PyObject * obj1 = 0 ;
12872 PyObject * obj2 = 0 ;
12873 PyObject * obj3 = 0 ;
12874 PyObject * obj4 = 0 ;
12875 char *kwnames[] = {
12876 (char *) "self",(char *) "pt",(char *) "sz",(char *) "start",(char *) "end", NULL
12877 };
12878
12879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipticArcPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12881 if (SWIG_arg_fail(1)) SWIG_fail;
12882 {
12883 arg2 = &temp2;
12884 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12885 }
12886 {
12887 arg3 = &temp3;
12888 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
12889 }
12890 {
12891 arg4 = (double)(SWIG_As_double(obj3));
12892 if (SWIG_arg_fail(4)) SWIG_fail;
12893 }
12894 {
12895 arg5 = (double)(SWIG_As_double(obj4));
12896 if (SWIG_arg_fail(5)) SWIG_fail;
12897 }
12898 {
12899 PyThreadState* __tstate = wxPyBeginAllowThreads();
12900 (arg1)->DrawEllipticArc((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,arg5);
12901
12902 wxPyEndAllowThreads(__tstate);
12903 if (PyErr_Occurred()) SWIG_fail;
12904 }
12905 Py_INCREF(Py_None); resultobj = Py_None;
12906 return resultobj;
12907 fail:
12908 return NULL;
12909 }
12910
12911
12912 static PyObject *_wrap_DC_DrawPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12913 PyObject *resultobj;
12914 wxDC *arg1 = (wxDC *) 0 ;
12915 int arg2 ;
12916 int arg3 ;
12917 PyObject * obj0 = 0 ;
12918 PyObject * obj1 = 0 ;
12919 PyObject * obj2 = 0 ;
12920 char *kwnames[] = {
12921 (char *) "self",(char *) "x",(char *) "y", NULL
12922 };
12923
12924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
12925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12926 if (SWIG_arg_fail(1)) SWIG_fail;
12927 {
12928 arg2 = (int)(SWIG_As_int(obj1));
12929 if (SWIG_arg_fail(2)) SWIG_fail;
12930 }
12931 {
12932 arg3 = (int)(SWIG_As_int(obj2));
12933 if (SWIG_arg_fail(3)) SWIG_fail;
12934 }
12935 {
12936 PyThreadState* __tstate = wxPyBeginAllowThreads();
12937 (arg1)->DrawPoint(arg2,arg3);
12938
12939 wxPyEndAllowThreads(__tstate);
12940 if (PyErr_Occurred()) SWIG_fail;
12941 }
12942 Py_INCREF(Py_None); resultobj = Py_None;
12943 return resultobj;
12944 fail:
12945 return NULL;
12946 }
12947
12948
12949 static PyObject *_wrap_DC_DrawPointPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12950 PyObject *resultobj;
12951 wxDC *arg1 = (wxDC *) 0 ;
12952 wxPoint *arg2 = 0 ;
12953 wxPoint temp2 ;
12954 PyObject * obj0 = 0 ;
12955 PyObject * obj1 = 0 ;
12956 char *kwnames[] = {
12957 (char *) "self",(char *) "pt", NULL
12958 };
12959
12960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawPointPoint",kwnames,&obj0,&obj1)) goto fail;
12961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12962 if (SWIG_arg_fail(1)) SWIG_fail;
12963 {
12964 arg2 = &temp2;
12965 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12966 }
12967 {
12968 PyThreadState* __tstate = wxPyBeginAllowThreads();
12969 (arg1)->DrawPoint((wxPoint const &)*arg2);
12970
12971 wxPyEndAllowThreads(__tstate);
12972 if (PyErr_Occurred()) SWIG_fail;
12973 }
12974 Py_INCREF(Py_None); resultobj = Py_None;
12975 return resultobj;
12976 fail:
12977 return NULL;
12978 }
12979
12980
12981 static PyObject *_wrap_DC_DrawRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
12982 PyObject *resultobj;
12983 wxDC *arg1 = (wxDC *) 0 ;
12984 int arg2 ;
12985 int arg3 ;
12986 int arg4 ;
12987 int arg5 ;
12988 PyObject * obj0 = 0 ;
12989 PyObject * obj1 = 0 ;
12990 PyObject * obj2 = 0 ;
12991 PyObject * obj3 = 0 ;
12992 PyObject * obj4 = 0 ;
12993 char *kwnames[] = {
12994 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
12995 };
12996
12997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12999 if (SWIG_arg_fail(1)) SWIG_fail;
13000 {
13001 arg2 = (int)(SWIG_As_int(obj1));
13002 if (SWIG_arg_fail(2)) SWIG_fail;
13003 }
13004 {
13005 arg3 = (int)(SWIG_As_int(obj2));
13006 if (SWIG_arg_fail(3)) SWIG_fail;
13007 }
13008 {
13009 arg4 = (int)(SWIG_As_int(obj3));
13010 if (SWIG_arg_fail(4)) SWIG_fail;
13011 }
13012 {
13013 arg5 = (int)(SWIG_As_int(obj4));
13014 if (SWIG_arg_fail(5)) SWIG_fail;
13015 }
13016 {
13017 PyThreadState* __tstate = wxPyBeginAllowThreads();
13018 (arg1)->DrawRectangle(arg2,arg3,arg4,arg5);
13019
13020 wxPyEndAllowThreads(__tstate);
13021 if (PyErr_Occurred()) SWIG_fail;
13022 }
13023 Py_INCREF(Py_None); resultobj = Py_None;
13024 return resultobj;
13025 fail:
13026 return NULL;
13027 }
13028
13029
13030 static PyObject *_wrap_DC_DrawRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13031 PyObject *resultobj;
13032 wxDC *arg1 = (wxDC *) 0 ;
13033 wxRect *arg2 = 0 ;
13034 wxRect temp2 ;
13035 PyObject * obj0 = 0 ;
13036 PyObject * obj1 = 0 ;
13037 char *kwnames[] = {
13038 (char *) "self",(char *) "rect", NULL
13039 };
13040
13041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawRectangleRect",kwnames,&obj0,&obj1)) goto fail;
13042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13043 if (SWIG_arg_fail(1)) SWIG_fail;
13044 {
13045 arg2 = &temp2;
13046 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13047 }
13048 {
13049 PyThreadState* __tstate = wxPyBeginAllowThreads();
13050 (arg1)->DrawRectangle((wxRect const &)*arg2);
13051
13052 wxPyEndAllowThreads(__tstate);
13053 if (PyErr_Occurred()) SWIG_fail;
13054 }
13055 Py_INCREF(Py_None); resultobj = Py_None;
13056 return resultobj;
13057 fail:
13058 return NULL;
13059 }
13060
13061
13062 static PyObject *_wrap_DC_DrawRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13063 PyObject *resultobj;
13064 wxDC *arg1 = (wxDC *) 0 ;
13065 wxPoint *arg2 = 0 ;
13066 wxSize *arg3 = 0 ;
13067 wxPoint temp2 ;
13068 wxSize temp3 ;
13069 PyObject * obj0 = 0 ;
13070 PyObject * obj1 = 0 ;
13071 PyObject * obj2 = 0 ;
13072 char *kwnames[] = {
13073 (char *) "self",(char *) "pt",(char *) "sz", NULL
13074 };
13075
13076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRectanglePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13078 if (SWIG_arg_fail(1)) SWIG_fail;
13079 {
13080 arg2 = &temp2;
13081 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13082 }
13083 {
13084 arg3 = &temp3;
13085 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13086 }
13087 {
13088 PyThreadState* __tstate = wxPyBeginAllowThreads();
13089 (arg1)->DrawRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3);
13090
13091 wxPyEndAllowThreads(__tstate);
13092 if (PyErr_Occurred()) SWIG_fail;
13093 }
13094 Py_INCREF(Py_None); resultobj = Py_None;
13095 return resultobj;
13096 fail:
13097 return NULL;
13098 }
13099
13100
13101 static PyObject *_wrap_DC_DrawRoundedRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
13102 PyObject *resultobj;
13103 wxDC *arg1 = (wxDC *) 0 ;
13104 int arg2 ;
13105 int arg3 ;
13106 int arg4 ;
13107 int arg5 ;
13108 double arg6 ;
13109 PyObject * obj0 = 0 ;
13110 PyObject * obj1 = 0 ;
13111 PyObject * obj2 = 0 ;
13112 PyObject * obj3 = 0 ;
13113 PyObject * obj4 = 0 ;
13114 PyObject * obj5 = 0 ;
13115 char *kwnames[] = {
13116 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "radius", NULL
13117 };
13118
13119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:DC_DrawRoundedRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
13120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13121 if (SWIG_arg_fail(1)) SWIG_fail;
13122 {
13123 arg2 = (int)(SWIG_As_int(obj1));
13124 if (SWIG_arg_fail(2)) SWIG_fail;
13125 }
13126 {
13127 arg3 = (int)(SWIG_As_int(obj2));
13128 if (SWIG_arg_fail(3)) SWIG_fail;
13129 }
13130 {
13131 arg4 = (int)(SWIG_As_int(obj3));
13132 if (SWIG_arg_fail(4)) SWIG_fail;
13133 }
13134 {
13135 arg5 = (int)(SWIG_As_int(obj4));
13136 if (SWIG_arg_fail(5)) SWIG_fail;
13137 }
13138 {
13139 arg6 = (double)(SWIG_As_double(obj5));
13140 if (SWIG_arg_fail(6)) SWIG_fail;
13141 }
13142 {
13143 PyThreadState* __tstate = wxPyBeginAllowThreads();
13144 (arg1)->DrawRoundedRectangle(arg2,arg3,arg4,arg5,arg6);
13145
13146 wxPyEndAllowThreads(__tstate);
13147 if (PyErr_Occurred()) SWIG_fail;
13148 }
13149 Py_INCREF(Py_None); resultobj = Py_None;
13150 return resultobj;
13151 fail:
13152 return NULL;
13153 }
13154
13155
13156 static PyObject *_wrap_DC_DrawRoundedRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13157 PyObject *resultobj;
13158 wxDC *arg1 = (wxDC *) 0 ;
13159 wxRect *arg2 = 0 ;
13160 double arg3 ;
13161 wxRect temp2 ;
13162 PyObject * obj0 = 0 ;
13163 PyObject * obj1 = 0 ;
13164 PyObject * obj2 = 0 ;
13165 char *kwnames[] = {
13166 (char *) "self",(char *) "r",(char *) "radius", NULL
13167 };
13168
13169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRoundedRectangleRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
13170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13171 if (SWIG_arg_fail(1)) SWIG_fail;
13172 {
13173 arg2 = &temp2;
13174 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13175 }
13176 {
13177 arg3 = (double)(SWIG_As_double(obj2));
13178 if (SWIG_arg_fail(3)) SWIG_fail;
13179 }
13180 {
13181 PyThreadState* __tstate = wxPyBeginAllowThreads();
13182 (arg1)->DrawRoundedRectangle((wxRect const &)*arg2,arg3);
13183
13184 wxPyEndAllowThreads(__tstate);
13185 if (PyErr_Occurred()) SWIG_fail;
13186 }
13187 Py_INCREF(Py_None); resultobj = Py_None;
13188 return resultobj;
13189 fail:
13190 return NULL;
13191 }
13192
13193
13194 static PyObject *_wrap_DC_DrawRoundedRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13195 PyObject *resultobj;
13196 wxDC *arg1 = (wxDC *) 0 ;
13197 wxPoint *arg2 = 0 ;
13198 wxSize *arg3 = 0 ;
13199 double arg4 ;
13200 wxPoint temp2 ;
13201 wxSize temp3 ;
13202 PyObject * obj0 = 0 ;
13203 PyObject * obj1 = 0 ;
13204 PyObject * obj2 = 0 ;
13205 PyObject * obj3 = 0 ;
13206 char *kwnames[] = {
13207 (char *) "self",(char *) "pt",(char *) "sz",(char *) "radius", NULL
13208 };
13209
13210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRoundedRectanglePointSize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13212 if (SWIG_arg_fail(1)) SWIG_fail;
13213 {
13214 arg2 = &temp2;
13215 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13216 }
13217 {
13218 arg3 = &temp3;
13219 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13220 }
13221 {
13222 arg4 = (double)(SWIG_As_double(obj3));
13223 if (SWIG_arg_fail(4)) SWIG_fail;
13224 }
13225 {
13226 PyThreadState* __tstate = wxPyBeginAllowThreads();
13227 (arg1)->DrawRoundedRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4);
13228
13229 wxPyEndAllowThreads(__tstate);
13230 if (PyErr_Occurred()) SWIG_fail;
13231 }
13232 Py_INCREF(Py_None); resultobj = Py_None;
13233 return resultobj;
13234 fail:
13235 return NULL;
13236 }
13237
13238
13239 static PyObject *_wrap_DC_DrawCircle(PyObject *, PyObject *args, PyObject *kwargs) {
13240 PyObject *resultobj;
13241 wxDC *arg1 = (wxDC *) 0 ;
13242 int arg2 ;
13243 int arg3 ;
13244 int arg4 ;
13245 PyObject * obj0 = 0 ;
13246 PyObject * obj1 = 0 ;
13247 PyObject * obj2 = 0 ;
13248 PyObject * obj3 = 0 ;
13249 char *kwnames[] = {
13250 (char *) "self",(char *) "x",(char *) "y",(char *) "radius", NULL
13251 };
13252
13253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawCircle",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13255 if (SWIG_arg_fail(1)) SWIG_fail;
13256 {
13257 arg2 = (int)(SWIG_As_int(obj1));
13258 if (SWIG_arg_fail(2)) SWIG_fail;
13259 }
13260 {
13261 arg3 = (int)(SWIG_As_int(obj2));
13262 if (SWIG_arg_fail(3)) SWIG_fail;
13263 }
13264 {
13265 arg4 = (int)(SWIG_As_int(obj3));
13266 if (SWIG_arg_fail(4)) SWIG_fail;
13267 }
13268 {
13269 PyThreadState* __tstate = wxPyBeginAllowThreads();
13270 (arg1)->DrawCircle(arg2,arg3,arg4);
13271
13272 wxPyEndAllowThreads(__tstate);
13273 if (PyErr_Occurred()) SWIG_fail;
13274 }
13275 Py_INCREF(Py_None); resultobj = Py_None;
13276 return resultobj;
13277 fail:
13278 return NULL;
13279 }
13280
13281
13282 static PyObject *_wrap_DC_DrawCirclePoint(PyObject *, PyObject *args, PyObject *kwargs) {
13283 PyObject *resultobj;
13284 wxDC *arg1 = (wxDC *) 0 ;
13285 wxPoint *arg2 = 0 ;
13286 int arg3 ;
13287 wxPoint temp2 ;
13288 PyObject * obj0 = 0 ;
13289 PyObject * obj1 = 0 ;
13290 PyObject * obj2 = 0 ;
13291 char *kwnames[] = {
13292 (char *) "self",(char *) "pt",(char *) "radius", NULL
13293 };
13294
13295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawCirclePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13297 if (SWIG_arg_fail(1)) SWIG_fail;
13298 {
13299 arg2 = &temp2;
13300 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13301 }
13302 {
13303 arg3 = (int)(SWIG_As_int(obj2));
13304 if (SWIG_arg_fail(3)) SWIG_fail;
13305 }
13306 {
13307 PyThreadState* __tstate = wxPyBeginAllowThreads();
13308 (arg1)->DrawCircle((wxPoint const &)*arg2,arg3);
13309
13310 wxPyEndAllowThreads(__tstate);
13311 if (PyErr_Occurred()) SWIG_fail;
13312 }
13313 Py_INCREF(Py_None); resultobj = Py_None;
13314 return resultobj;
13315 fail:
13316 return NULL;
13317 }
13318
13319
13320 static PyObject *_wrap_DC_DrawEllipse(PyObject *, PyObject *args, PyObject *kwargs) {
13321 PyObject *resultobj;
13322 wxDC *arg1 = (wxDC *) 0 ;
13323 int arg2 ;
13324 int arg3 ;
13325 int arg4 ;
13326 int arg5 ;
13327 PyObject * obj0 = 0 ;
13328 PyObject * obj1 = 0 ;
13329 PyObject * obj2 = 0 ;
13330 PyObject * obj3 = 0 ;
13331 PyObject * obj4 = 0 ;
13332 char *kwnames[] = {
13333 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13334 };
13335
13336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipse",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13338 if (SWIG_arg_fail(1)) SWIG_fail;
13339 {
13340 arg2 = (int)(SWIG_As_int(obj1));
13341 if (SWIG_arg_fail(2)) SWIG_fail;
13342 }
13343 {
13344 arg3 = (int)(SWIG_As_int(obj2));
13345 if (SWIG_arg_fail(3)) SWIG_fail;
13346 }
13347 {
13348 arg4 = (int)(SWIG_As_int(obj3));
13349 if (SWIG_arg_fail(4)) SWIG_fail;
13350 }
13351 {
13352 arg5 = (int)(SWIG_As_int(obj4));
13353 if (SWIG_arg_fail(5)) SWIG_fail;
13354 }
13355 {
13356 PyThreadState* __tstate = wxPyBeginAllowThreads();
13357 (arg1)->DrawEllipse(arg2,arg3,arg4,arg5);
13358
13359 wxPyEndAllowThreads(__tstate);
13360 if (PyErr_Occurred()) SWIG_fail;
13361 }
13362 Py_INCREF(Py_None); resultobj = Py_None;
13363 return resultobj;
13364 fail:
13365 return NULL;
13366 }
13367
13368
13369 static PyObject *_wrap_DC_DrawEllipseRect(PyObject *, PyObject *args, PyObject *kwargs) {
13370 PyObject *resultobj;
13371 wxDC *arg1 = (wxDC *) 0 ;
13372 wxRect *arg2 = 0 ;
13373 wxRect temp2 ;
13374 PyObject * obj0 = 0 ;
13375 PyObject * obj1 = 0 ;
13376 char *kwnames[] = {
13377 (char *) "self",(char *) "rect", NULL
13378 };
13379
13380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawEllipseRect",kwnames,&obj0,&obj1)) goto fail;
13381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13382 if (SWIG_arg_fail(1)) SWIG_fail;
13383 {
13384 arg2 = &temp2;
13385 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13386 }
13387 {
13388 PyThreadState* __tstate = wxPyBeginAllowThreads();
13389 (arg1)->DrawEllipse((wxRect const &)*arg2);
13390
13391 wxPyEndAllowThreads(__tstate);
13392 if (PyErr_Occurred()) SWIG_fail;
13393 }
13394 Py_INCREF(Py_None); resultobj = Py_None;
13395 return resultobj;
13396 fail:
13397 return NULL;
13398 }
13399
13400
13401 static PyObject *_wrap_DC_DrawEllipsePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13402 PyObject *resultobj;
13403 wxDC *arg1 = (wxDC *) 0 ;
13404 wxPoint *arg2 = 0 ;
13405 wxSize *arg3 = 0 ;
13406 wxPoint temp2 ;
13407 wxSize temp3 ;
13408 PyObject * obj0 = 0 ;
13409 PyObject * obj1 = 0 ;
13410 PyObject * obj2 = 0 ;
13411 char *kwnames[] = {
13412 (char *) "self",(char *) "pt",(char *) "sz", NULL
13413 };
13414
13415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawEllipsePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13417 if (SWIG_arg_fail(1)) SWIG_fail;
13418 {
13419 arg2 = &temp2;
13420 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13421 }
13422 {
13423 arg3 = &temp3;
13424 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13425 }
13426 {
13427 PyThreadState* __tstate = wxPyBeginAllowThreads();
13428 (arg1)->DrawEllipse((wxPoint const &)*arg2,(wxSize const &)*arg3);
13429
13430 wxPyEndAllowThreads(__tstate);
13431 if (PyErr_Occurred()) SWIG_fail;
13432 }
13433 Py_INCREF(Py_None); resultobj = Py_None;
13434 return resultobj;
13435 fail:
13436 return NULL;
13437 }
13438
13439
13440 static PyObject *_wrap_DC_DrawIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13441 PyObject *resultobj;
13442 wxDC *arg1 = (wxDC *) 0 ;
13443 wxIcon *arg2 = 0 ;
13444 int arg3 ;
13445 int arg4 ;
13446 PyObject * obj0 = 0 ;
13447 PyObject * obj1 = 0 ;
13448 PyObject * obj2 = 0 ;
13449 PyObject * obj3 = 0 ;
13450 char *kwnames[] = {
13451 (char *) "self",(char *) "icon",(char *) "x",(char *) "y", NULL
13452 };
13453
13454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawIcon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13456 if (SWIG_arg_fail(1)) SWIG_fail;
13457 {
13458 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
13459 if (SWIG_arg_fail(2)) SWIG_fail;
13460 if (arg2 == NULL) {
13461 SWIG_null_ref("wxIcon");
13462 }
13463 if (SWIG_arg_fail(2)) SWIG_fail;
13464 }
13465 {
13466 arg3 = (int)(SWIG_As_int(obj2));
13467 if (SWIG_arg_fail(3)) SWIG_fail;
13468 }
13469 {
13470 arg4 = (int)(SWIG_As_int(obj3));
13471 if (SWIG_arg_fail(4)) SWIG_fail;
13472 }
13473 {
13474 PyThreadState* __tstate = wxPyBeginAllowThreads();
13475 (arg1)->DrawIcon((wxIcon const &)*arg2,arg3,arg4);
13476
13477 wxPyEndAllowThreads(__tstate);
13478 if (PyErr_Occurred()) SWIG_fail;
13479 }
13480 Py_INCREF(Py_None); resultobj = Py_None;
13481 return resultobj;
13482 fail:
13483 return NULL;
13484 }
13485
13486
13487 static PyObject *_wrap_DC_DrawIconPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13488 PyObject *resultobj;
13489 wxDC *arg1 = (wxDC *) 0 ;
13490 wxIcon *arg2 = 0 ;
13491 wxPoint *arg3 = 0 ;
13492 wxPoint temp3 ;
13493 PyObject * obj0 = 0 ;
13494 PyObject * obj1 = 0 ;
13495 PyObject * obj2 = 0 ;
13496 char *kwnames[] = {
13497 (char *) "self",(char *) "icon",(char *) "pt", NULL
13498 };
13499
13500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawIconPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13502 if (SWIG_arg_fail(1)) SWIG_fail;
13503 {
13504 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
13505 if (SWIG_arg_fail(2)) SWIG_fail;
13506 if (arg2 == NULL) {
13507 SWIG_null_ref("wxIcon");
13508 }
13509 if (SWIG_arg_fail(2)) SWIG_fail;
13510 }
13511 {
13512 arg3 = &temp3;
13513 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13514 }
13515 {
13516 PyThreadState* __tstate = wxPyBeginAllowThreads();
13517 (arg1)->DrawIcon((wxIcon const &)*arg2,(wxPoint const &)*arg3);
13518
13519 wxPyEndAllowThreads(__tstate);
13520 if (PyErr_Occurred()) SWIG_fail;
13521 }
13522 Py_INCREF(Py_None); resultobj = Py_None;
13523 return resultobj;
13524 fail:
13525 return NULL;
13526 }
13527
13528
13529 static PyObject *_wrap_DC_DrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13530 PyObject *resultobj;
13531 wxDC *arg1 = (wxDC *) 0 ;
13532 wxBitmap *arg2 = 0 ;
13533 int arg3 ;
13534 int arg4 ;
13535 bool arg5 = (bool) false ;
13536 PyObject * obj0 = 0 ;
13537 PyObject * obj1 = 0 ;
13538 PyObject * obj2 = 0 ;
13539 PyObject * obj3 = 0 ;
13540 PyObject * obj4 = 0 ;
13541 char *kwnames[] = {
13542 (char *) "self",(char *) "bmp",(char *) "x",(char *) "y",(char *) "useMask", NULL
13543 };
13544
13545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_DrawBitmap",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13547 if (SWIG_arg_fail(1)) SWIG_fail;
13548 {
13549 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
13550 if (SWIG_arg_fail(2)) SWIG_fail;
13551 if (arg2 == NULL) {
13552 SWIG_null_ref("wxBitmap");
13553 }
13554 if (SWIG_arg_fail(2)) SWIG_fail;
13555 }
13556 {
13557 arg3 = (int)(SWIG_As_int(obj2));
13558 if (SWIG_arg_fail(3)) SWIG_fail;
13559 }
13560 {
13561 arg4 = (int)(SWIG_As_int(obj3));
13562 if (SWIG_arg_fail(4)) SWIG_fail;
13563 }
13564 if (obj4) {
13565 {
13566 arg5 = (bool)(SWIG_As_bool(obj4));
13567 if (SWIG_arg_fail(5)) SWIG_fail;
13568 }
13569 }
13570 {
13571 PyThreadState* __tstate = wxPyBeginAllowThreads();
13572 (arg1)->DrawBitmap((wxBitmap const &)*arg2,arg3,arg4,arg5);
13573
13574 wxPyEndAllowThreads(__tstate);
13575 if (PyErr_Occurred()) SWIG_fail;
13576 }
13577 Py_INCREF(Py_None); resultobj = Py_None;
13578 return resultobj;
13579 fail:
13580 return NULL;
13581 }
13582
13583
13584 static PyObject *_wrap_DC_DrawBitmapPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13585 PyObject *resultobj;
13586 wxDC *arg1 = (wxDC *) 0 ;
13587 wxBitmap *arg2 = 0 ;
13588 wxPoint *arg3 = 0 ;
13589 bool arg4 = (bool) false ;
13590 wxPoint temp3 ;
13591 PyObject * obj0 = 0 ;
13592 PyObject * obj1 = 0 ;
13593 PyObject * obj2 = 0 ;
13594 PyObject * obj3 = 0 ;
13595 char *kwnames[] = {
13596 (char *) "self",(char *) "bmp",(char *) "pt",(char *) "useMask", NULL
13597 };
13598
13599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_DrawBitmapPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13601 if (SWIG_arg_fail(1)) SWIG_fail;
13602 {
13603 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
13604 if (SWIG_arg_fail(2)) SWIG_fail;
13605 if (arg2 == NULL) {
13606 SWIG_null_ref("wxBitmap");
13607 }
13608 if (SWIG_arg_fail(2)) SWIG_fail;
13609 }
13610 {
13611 arg3 = &temp3;
13612 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13613 }
13614 if (obj3) {
13615 {
13616 arg4 = (bool)(SWIG_As_bool(obj3));
13617 if (SWIG_arg_fail(4)) SWIG_fail;
13618 }
13619 }
13620 {
13621 PyThreadState* __tstate = wxPyBeginAllowThreads();
13622 (arg1)->DrawBitmap((wxBitmap const &)*arg2,(wxPoint const &)*arg3,arg4);
13623
13624 wxPyEndAllowThreads(__tstate);
13625 if (PyErr_Occurred()) SWIG_fail;
13626 }
13627 Py_INCREF(Py_None); resultobj = Py_None;
13628 return resultobj;
13629 fail:
13630 return NULL;
13631 }
13632
13633
13634 static PyObject *_wrap_DC_DrawText(PyObject *, PyObject *args, PyObject *kwargs) {
13635 PyObject *resultobj;
13636 wxDC *arg1 = (wxDC *) 0 ;
13637 wxString *arg2 = 0 ;
13638 int arg3 ;
13639 int arg4 ;
13640 bool temp2 = false ;
13641 PyObject * obj0 = 0 ;
13642 PyObject * obj1 = 0 ;
13643 PyObject * obj2 = 0 ;
13644 PyObject * obj3 = 0 ;
13645 char *kwnames[] = {
13646 (char *) "self",(char *) "text",(char *) "x",(char *) "y", NULL
13647 };
13648
13649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawText",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13651 if (SWIG_arg_fail(1)) SWIG_fail;
13652 {
13653 arg2 = wxString_in_helper(obj1);
13654 if (arg2 == NULL) SWIG_fail;
13655 temp2 = true;
13656 }
13657 {
13658 arg3 = (int)(SWIG_As_int(obj2));
13659 if (SWIG_arg_fail(3)) SWIG_fail;
13660 }
13661 {
13662 arg4 = (int)(SWIG_As_int(obj3));
13663 if (SWIG_arg_fail(4)) SWIG_fail;
13664 }
13665 {
13666 PyThreadState* __tstate = wxPyBeginAllowThreads();
13667 (arg1)->DrawText((wxString const &)*arg2,arg3,arg4);
13668
13669 wxPyEndAllowThreads(__tstate);
13670 if (PyErr_Occurred()) SWIG_fail;
13671 }
13672 Py_INCREF(Py_None); resultobj = Py_None;
13673 {
13674 if (temp2)
13675 delete arg2;
13676 }
13677 return resultobj;
13678 fail:
13679 {
13680 if (temp2)
13681 delete arg2;
13682 }
13683 return NULL;
13684 }
13685
13686
13687 static PyObject *_wrap_DC_DrawTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13688 PyObject *resultobj;
13689 wxDC *arg1 = (wxDC *) 0 ;
13690 wxString *arg2 = 0 ;
13691 wxPoint *arg3 = 0 ;
13692 bool temp2 = false ;
13693 wxPoint temp3 ;
13694 PyObject * obj0 = 0 ;
13695 PyObject * obj1 = 0 ;
13696 PyObject * obj2 = 0 ;
13697 char *kwnames[] = {
13698 (char *) "self",(char *) "text",(char *) "pt", NULL
13699 };
13700
13701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawTextPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13703 if (SWIG_arg_fail(1)) SWIG_fail;
13704 {
13705 arg2 = wxString_in_helper(obj1);
13706 if (arg2 == NULL) SWIG_fail;
13707 temp2 = true;
13708 }
13709 {
13710 arg3 = &temp3;
13711 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13712 }
13713 {
13714 PyThreadState* __tstate = wxPyBeginAllowThreads();
13715 (arg1)->DrawText((wxString const &)*arg2,(wxPoint const &)*arg3);
13716
13717 wxPyEndAllowThreads(__tstate);
13718 if (PyErr_Occurred()) SWIG_fail;
13719 }
13720 Py_INCREF(Py_None); resultobj = Py_None;
13721 {
13722 if (temp2)
13723 delete arg2;
13724 }
13725 return resultobj;
13726 fail:
13727 {
13728 if (temp2)
13729 delete arg2;
13730 }
13731 return NULL;
13732 }
13733
13734
13735 static PyObject *_wrap_DC_DrawRotatedText(PyObject *, PyObject *args, PyObject *kwargs) {
13736 PyObject *resultobj;
13737 wxDC *arg1 = (wxDC *) 0 ;
13738 wxString *arg2 = 0 ;
13739 int arg3 ;
13740 int arg4 ;
13741 double arg5 ;
13742 bool temp2 = false ;
13743 PyObject * obj0 = 0 ;
13744 PyObject * obj1 = 0 ;
13745 PyObject * obj2 = 0 ;
13746 PyObject * obj3 = 0 ;
13747 PyObject * obj4 = 0 ;
13748 char *kwnames[] = {
13749 (char *) "self",(char *) "text",(char *) "x",(char *) "y",(char *) "angle", NULL
13750 };
13751
13752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRotatedText",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13754 if (SWIG_arg_fail(1)) SWIG_fail;
13755 {
13756 arg2 = wxString_in_helper(obj1);
13757 if (arg2 == NULL) SWIG_fail;
13758 temp2 = true;
13759 }
13760 {
13761 arg3 = (int)(SWIG_As_int(obj2));
13762 if (SWIG_arg_fail(3)) SWIG_fail;
13763 }
13764 {
13765 arg4 = (int)(SWIG_As_int(obj3));
13766 if (SWIG_arg_fail(4)) SWIG_fail;
13767 }
13768 {
13769 arg5 = (double)(SWIG_As_double(obj4));
13770 if (SWIG_arg_fail(5)) SWIG_fail;
13771 }
13772 {
13773 PyThreadState* __tstate = wxPyBeginAllowThreads();
13774 (arg1)->DrawRotatedText((wxString const &)*arg2,arg3,arg4,arg5);
13775
13776 wxPyEndAllowThreads(__tstate);
13777 if (PyErr_Occurred()) SWIG_fail;
13778 }
13779 Py_INCREF(Py_None); resultobj = Py_None;
13780 {
13781 if (temp2)
13782 delete arg2;
13783 }
13784 return resultobj;
13785 fail:
13786 {
13787 if (temp2)
13788 delete arg2;
13789 }
13790 return NULL;
13791 }
13792
13793
13794 static PyObject *_wrap_DC_DrawRotatedTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13795 PyObject *resultobj;
13796 wxDC *arg1 = (wxDC *) 0 ;
13797 wxString *arg2 = 0 ;
13798 wxPoint *arg3 = 0 ;
13799 double arg4 ;
13800 bool temp2 = false ;
13801 wxPoint temp3 ;
13802 PyObject * obj0 = 0 ;
13803 PyObject * obj1 = 0 ;
13804 PyObject * obj2 = 0 ;
13805 PyObject * obj3 = 0 ;
13806 char *kwnames[] = {
13807 (char *) "self",(char *) "text",(char *) "pt",(char *) "angle", NULL
13808 };
13809
13810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRotatedTextPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13812 if (SWIG_arg_fail(1)) SWIG_fail;
13813 {
13814 arg2 = wxString_in_helper(obj1);
13815 if (arg2 == NULL) SWIG_fail;
13816 temp2 = true;
13817 }
13818 {
13819 arg3 = &temp3;
13820 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13821 }
13822 {
13823 arg4 = (double)(SWIG_As_double(obj3));
13824 if (SWIG_arg_fail(4)) SWIG_fail;
13825 }
13826 {
13827 PyThreadState* __tstate = wxPyBeginAllowThreads();
13828 (arg1)->DrawRotatedText((wxString const &)*arg2,(wxPoint const &)*arg3,arg4);
13829
13830 wxPyEndAllowThreads(__tstate);
13831 if (PyErr_Occurred()) SWIG_fail;
13832 }
13833 Py_INCREF(Py_None); resultobj = Py_None;
13834 {
13835 if (temp2)
13836 delete arg2;
13837 }
13838 return resultobj;
13839 fail:
13840 {
13841 if (temp2)
13842 delete arg2;
13843 }
13844 return NULL;
13845 }
13846
13847
13848 static PyObject *_wrap_DC_Blit(PyObject *, PyObject *args, PyObject *kwargs) {
13849 PyObject *resultobj;
13850 wxDC *arg1 = (wxDC *) 0 ;
13851 int arg2 ;
13852 int arg3 ;
13853 int arg4 ;
13854 int arg5 ;
13855 wxDC *arg6 = (wxDC *) 0 ;
13856 int arg7 ;
13857 int arg8 ;
13858 int arg9 = (int) wxCOPY ;
13859 bool arg10 = (bool) false ;
13860 int arg11 = (int) -1 ;
13861 int arg12 = (int) -1 ;
13862 bool result;
13863 PyObject * obj0 = 0 ;
13864 PyObject * obj1 = 0 ;
13865 PyObject * obj2 = 0 ;
13866 PyObject * obj3 = 0 ;
13867 PyObject * obj4 = 0 ;
13868 PyObject * obj5 = 0 ;
13869 PyObject * obj6 = 0 ;
13870 PyObject * obj7 = 0 ;
13871 PyObject * obj8 = 0 ;
13872 PyObject * obj9 = 0 ;
13873 PyObject * obj10 = 0 ;
13874 PyObject * obj11 = 0 ;
13875 char *kwnames[] = {
13876 (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
13877 };
13878
13879 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;
13880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13881 if (SWIG_arg_fail(1)) SWIG_fail;
13882 {
13883 arg2 = (int)(SWIG_As_int(obj1));
13884 if (SWIG_arg_fail(2)) SWIG_fail;
13885 }
13886 {
13887 arg3 = (int)(SWIG_As_int(obj2));
13888 if (SWIG_arg_fail(3)) SWIG_fail;
13889 }
13890 {
13891 arg4 = (int)(SWIG_As_int(obj3));
13892 if (SWIG_arg_fail(4)) SWIG_fail;
13893 }
13894 {
13895 arg5 = (int)(SWIG_As_int(obj4));
13896 if (SWIG_arg_fail(5)) SWIG_fail;
13897 }
13898 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13899 if (SWIG_arg_fail(6)) SWIG_fail;
13900 {
13901 arg7 = (int)(SWIG_As_int(obj6));
13902 if (SWIG_arg_fail(7)) SWIG_fail;
13903 }
13904 {
13905 arg8 = (int)(SWIG_As_int(obj7));
13906 if (SWIG_arg_fail(8)) SWIG_fail;
13907 }
13908 if (obj8) {
13909 {
13910 arg9 = (int)(SWIG_As_int(obj8));
13911 if (SWIG_arg_fail(9)) SWIG_fail;
13912 }
13913 }
13914 if (obj9) {
13915 {
13916 arg10 = (bool)(SWIG_As_bool(obj9));
13917 if (SWIG_arg_fail(10)) SWIG_fail;
13918 }
13919 }
13920 if (obj10) {
13921 {
13922 arg11 = (int)(SWIG_As_int(obj10));
13923 if (SWIG_arg_fail(11)) SWIG_fail;
13924 }
13925 }
13926 if (obj11) {
13927 {
13928 arg12 = (int)(SWIG_As_int(obj11));
13929 if (SWIG_arg_fail(12)) SWIG_fail;
13930 }
13931 }
13932 {
13933 PyThreadState* __tstate = wxPyBeginAllowThreads();
13934 result = (bool)(arg1)->Blit(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
13935
13936 wxPyEndAllowThreads(__tstate);
13937 if (PyErr_Occurred()) SWIG_fail;
13938 }
13939 {
13940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13941 }
13942 return resultobj;
13943 fail:
13944 return NULL;
13945 }
13946
13947
13948 static PyObject *_wrap_DC_BlitPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13949 PyObject *resultobj;
13950 wxDC *arg1 = (wxDC *) 0 ;
13951 wxPoint *arg2 = 0 ;
13952 wxSize *arg3 = 0 ;
13953 wxDC *arg4 = (wxDC *) 0 ;
13954 wxPoint *arg5 = 0 ;
13955 int arg6 = (int) wxCOPY ;
13956 bool arg7 = (bool) false ;
13957 wxPoint const &arg8_defvalue = wxDefaultPosition ;
13958 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
13959 bool result;
13960 wxPoint temp2 ;
13961 wxSize temp3 ;
13962 wxPoint temp5 ;
13963 wxPoint temp8 ;
13964 PyObject * obj0 = 0 ;
13965 PyObject * obj1 = 0 ;
13966 PyObject * obj2 = 0 ;
13967 PyObject * obj3 = 0 ;
13968 PyObject * obj4 = 0 ;
13969 PyObject * obj5 = 0 ;
13970 PyObject * obj6 = 0 ;
13971 PyObject * obj7 = 0 ;
13972 char *kwnames[] = {
13973 (char *) "self",(char *) "destPt",(char *) "sz",(char *) "source",(char *) "srcPt",(char *) "rop",(char *) "useMask",(char *) "srcPtMask", NULL
13974 };
13975
13976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:DC_BlitPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
13977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13978 if (SWIG_arg_fail(1)) SWIG_fail;
13979 {
13980 arg2 = &temp2;
13981 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13982 }
13983 {
13984 arg3 = &temp3;
13985 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13986 }
13987 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13988 if (SWIG_arg_fail(4)) SWIG_fail;
13989 {
13990 arg5 = &temp5;
13991 if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
13992 }
13993 if (obj5) {
13994 {
13995 arg6 = (int)(SWIG_As_int(obj5));
13996 if (SWIG_arg_fail(6)) SWIG_fail;
13997 }
13998 }
13999 if (obj6) {
14000 {
14001 arg7 = (bool)(SWIG_As_bool(obj6));
14002 if (SWIG_arg_fail(7)) SWIG_fail;
14003 }
14004 }
14005 if (obj7) {
14006 {
14007 arg8 = &temp8;
14008 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
14009 }
14010 }
14011 {
14012 PyThreadState* __tstate = wxPyBeginAllowThreads();
14013 result = (bool)(arg1)->Blit((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,(wxPoint const &)*arg5,arg6,arg7,(wxPoint const &)*arg8);
14014
14015 wxPyEndAllowThreads(__tstate);
14016 if (PyErr_Occurred()) SWIG_fail;
14017 }
14018 {
14019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14020 }
14021 return resultobj;
14022 fail:
14023 return NULL;
14024 }
14025
14026
14027 static PyObject *_wrap_DC_SetClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14028 PyObject *resultobj;
14029 wxDC *arg1 = (wxDC *) 0 ;
14030 int arg2 ;
14031 int arg3 ;
14032 int arg4 ;
14033 int arg5 ;
14034 PyObject * obj0 = 0 ;
14035 PyObject * obj1 = 0 ;
14036 PyObject * obj2 = 0 ;
14037 PyObject * obj3 = 0 ;
14038 PyObject * obj4 = 0 ;
14039 char *kwnames[] = {
14040 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
14041 };
14042
14043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_SetClippingRegion",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14045 if (SWIG_arg_fail(1)) SWIG_fail;
14046 {
14047 arg2 = (int)(SWIG_As_int(obj1));
14048 if (SWIG_arg_fail(2)) SWIG_fail;
14049 }
14050 {
14051 arg3 = (int)(SWIG_As_int(obj2));
14052 if (SWIG_arg_fail(3)) SWIG_fail;
14053 }
14054 {
14055 arg4 = (int)(SWIG_As_int(obj3));
14056 if (SWIG_arg_fail(4)) SWIG_fail;
14057 }
14058 {
14059 arg5 = (int)(SWIG_As_int(obj4));
14060 if (SWIG_arg_fail(5)) SWIG_fail;
14061 }
14062 {
14063 PyThreadState* __tstate = wxPyBeginAllowThreads();
14064 (arg1)->SetClippingRegion(arg2,arg3,arg4,arg5);
14065
14066 wxPyEndAllowThreads(__tstate);
14067 if (PyErr_Occurred()) SWIG_fail;
14068 }
14069 Py_INCREF(Py_None); resultobj = Py_None;
14070 return resultobj;
14071 fail:
14072 return NULL;
14073 }
14074
14075
14076 static PyObject *_wrap_DC_SetClippingRegionPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14077 PyObject *resultobj;
14078 wxDC *arg1 = (wxDC *) 0 ;
14079 wxPoint *arg2 = 0 ;
14080 wxSize *arg3 = 0 ;
14081 wxPoint temp2 ;
14082 wxSize temp3 ;
14083 PyObject * obj0 = 0 ;
14084 PyObject * obj1 = 0 ;
14085 PyObject * obj2 = 0 ;
14086 char *kwnames[] = {
14087 (char *) "self",(char *) "pt",(char *) "sz", NULL
14088 };
14089
14090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetClippingRegionPointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14092 if (SWIG_arg_fail(1)) SWIG_fail;
14093 {
14094 arg2 = &temp2;
14095 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14096 }
14097 {
14098 arg3 = &temp3;
14099 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14100 }
14101 {
14102 PyThreadState* __tstate = wxPyBeginAllowThreads();
14103 (arg1)->SetClippingRegion((wxPoint const &)*arg2,(wxSize const &)*arg3);
14104
14105 wxPyEndAllowThreads(__tstate);
14106 if (PyErr_Occurred()) SWIG_fail;
14107 }
14108 Py_INCREF(Py_None); resultobj = Py_None;
14109 return resultobj;
14110 fail:
14111 return NULL;
14112 }
14113
14114
14115 static PyObject *_wrap_DC_SetClippingRegionAsRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14116 PyObject *resultobj;
14117 wxDC *arg1 = (wxDC *) 0 ;
14118 wxRegion *arg2 = 0 ;
14119 PyObject * obj0 = 0 ;
14120 PyObject * obj1 = 0 ;
14121 char *kwnames[] = {
14122 (char *) "self",(char *) "region", NULL
14123 };
14124
14125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRegionAsRegion",kwnames,&obj0,&obj1)) goto fail;
14126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14127 if (SWIG_arg_fail(1)) SWIG_fail;
14128 {
14129 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
14130 if (SWIG_arg_fail(2)) SWIG_fail;
14131 if (arg2 == NULL) {
14132 SWIG_null_ref("wxRegion");
14133 }
14134 if (SWIG_arg_fail(2)) SWIG_fail;
14135 }
14136 {
14137 PyThreadState* __tstate = wxPyBeginAllowThreads();
14138 (arg1)->SetClippingRegion((wxRegion const &)*arg2);
14139
14140 wxPyEndAllowThreads(__tstate);
14141 if (PyErr_Occurred()) SWIG_fail;
14142 }
14143 Py_INCREF(Py_None); resultobj = Py_None;
14144 return resultobj;
14145 fail:
14146 return NULL;
14147 }
14148
14149
14150 static PyObject *_wrap_DC_SetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
14151 PyObject *resultobj;
14152 wxDC *arg1 = (wxDC *) 0 ;
14153 wxRect *arg2 = 0 ;
14154 wxRect temp2 ;
14155 PyObject * obj0 = 0 ;
14156 PyObject * obj1 = 0 ;
14157 char *kwnames[] = {
14158 (char *) "self",(char *) "rect", NULL
14159 };
14160
14161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRect",kwnames,&obj0,&obj1)) goto fail;
14162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14163 if (SWIG_arg_fail(1)) SWIG_fail;
14164 {
14165 arg2 = &temp2;
14166 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14167 }
14168 {
14169 PyThreadState* __tstate = wxPyBeginAllowThreads();
14170 (arg1)->SetClippingRegion((wxRect const &)*arg2);
14171
14172 wxPyEndAllowThreads(__tstate);
14173 if (PyErr_Occurred()) SWIG_fail;
14174 }
14175 Py_INCREF(Py_None); resultobj = Py_None;
14176 return resultobj;
14177 fail:
14178 return NULL;
14179 }
14180
14181
14182 static PyObject *_wrap_DC_DrawLines(PyObject *, PyObject *args, PyObject *kwargs) {
14183 PyObject *resultobj;
14184 wxDC *arg1 = (wxDC *) 0 ;
14185 int arg2 ;
14186 wxPoint *arg3 = (wxPoint *) 0 ;
14187 int arg4 = (int) 0 ;
14188 int arg5 = (int) 0 ;
14189 PyObject * obj0 = 0 ;
14190 PyObject * obj1 = 0 ;
14191 PyObject * obj2 = 0 ;
14192 PyObject * obj3 = 0 ;
14193 char *kwnames[] = {
14194 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset", NULL
14195 };
14196
14197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DC_DrawLines",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14199 if (SWIG_arg_fail(1)) SWIG_fail;
14200 {
14201 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14202 if (arg3 == NULL) SWIG_fail;
14203 }
14204 if (obj2) {
14205 {
14206 arg4 = (int)(SWIG_As_int(obj2));
14207 if (SWIG_arg_fail(4)) SWIG_fail;
14208 }
14209 }
14210 if (obj3) {
14211 {
14212 arg5 = (int)(SWIG_As_int(obj3));
14213 if (SWIG_arg_fail(5)) SWIG_fail;
14214 }
14215 }
14216 {
14217 PyThreadState* __tstate = wxPyBeginAllowThreads();
14218 (arg1)->DrawLines(arg2,arg3,arg4,arg5);
14219
14220 wxPyEndAllowThreads(__tstate);
14221 if (PyErr_Occurred()) SWIG_fail;
14222 }
14223 Py_INCREF(Py_None); resultobj = Py_None;
14224 {
14225 if (arg3) delete [] arg3;
14226 }
14227 return resultobj;
14228 fail:
14229 {
14230 if (arg3) delete [] arg3;
14231 }
14232 return NULL;
14233 }
14234
14235
14236 static PyObject *_wrap_DC_DrawPolygon(PyObject *, PyObject *args, PyObject *kwargs) {
14237 PyObject *resultobj;
14238 wxDC *arg1 = (wxDC *) 0 ;
14239 int arg2 ;
14240 wxPoint *arg3 = (wxPoint *) 0 ;
14241 int arg4 = (int) 0 ;
14242 int arg5 = (int) 0 ;
14243 int arg6 = (int) wxODDEVEN_RULE ;
14244 PyObject * obj0 = 0 ;
14245 PyObject * obj1 = 0 ;
14246 PyObject * obj2 = 0 ;
14247 PyObject * obj3 = 0 ;
14248 PyObject * obj4 = 0 ;
14249 char *kwnames[] = {
14250 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset",(char *) "fillStyle", NULL
14251 };
14252
14253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DC_DrawPolygon",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14255 if (SWIG_arg_fail(1)) SWIG_fail;
14256 {
14257 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14258 if (arg3 == NULL) SWIG_fail;
14259 }
14260 if (obj2) {
14261 {
14262 arg4 = (int)(SWIG_As_int(obj2));
14263 if (SWIG_arg_fail(4)) SWIG_fail;
14264 }
14265 }
14266 if (obj3) {
14267 {
14268 arg5 = (int)(SWIG_As_int(obj3));
14269 if (SWIG_arg_fail(5)) SWIG_fail;
14270 }
14271 }
14272 if (obj4) {
14273 {
14274 arg6 = (int)(SWIG_As_int(obj4));
14275 if (SWIG_arg_fail(6)) SWIG_fail;
14276 }
14277 }
14278 {
14279 PyThreadState* __tstate = wxPyBeginAllowThreads();
14280 (arg1)->DrawPolygon(arg2,arg3,arg4,arg5,arg6);
14281
14282 wxPyEndAllowThreads(__tstate);
14283 if (PyErr_Occurred()) SWIG_fail;
14284 }
14285 Py_INCREF(Py_None); resultobj = Py_None;
14286 {
14287 if (arg3) delete [] arg3;
14288 }
14289 return resultobj;
14290 fail:
14291 {
14292 if (arg3) delete [] arg3;
14293 }
14294 return NULL;
14295 }
14296
14297
14298 static PyObject *_wrap_DC_DrawLabel(PyObject *, PyObject *args, PyObject *kwargs) {
14299 PyObject *resultobj;
14300 wxDC *arg1 = (wxDC *) 0 ;
14301 wxString *arg2 = 0 ;
14302 wxRect *arg3 = 0 ;
14303 int arg4 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
14304 int arg5 = (int) -1 ;
14305 bool temp2 = false ;
14306 wxRect temp3 ;
14307 PyObject * obj0 = 0 ;
14308 PyObject * obj1 = 0 ;
14309 PyObject * obj2 = 0 ;
14310 PyObject * obj3 = 0 ;
14311 PyObject * obj4 = 0 ;
14312 char *kwnames[] = {
14313 (char *) "self",(char *) "text",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
14314 };
14315
14316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:DC_DrawLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14318 if (SWIG_arg_fail(1)) SWIG_fail;
14319 {
14320 arg2 = wxString_in_helper(obj1);
14321 if (arg2 == NULL) SWIG_fail;
14322 temp2 = true;
14323 }
14324 {
14325 arg3 = &temp3;
14326 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
14327 }
14328 if (obj3) {
14329 {
14330 arg4 = (int)(SWIG_As_int(obj3));
14331 if (SWIG_arg_fail(4)) SWIG_fail;
14332 }
14333 }
14334 if (obj4) {
14335 {
14336 arg5 = (int)(SWIG_As_int(obj4));
14337 if (SWIG_arg_fail(5)) SWIG_fail;
14338 }
14339 }
14340 {
14341 PyThreadState* __tstate = wxPyBeginAllowThreads();
14342 (arg1)->DrawLabel((wxString const &)*arg2,(wxRect const &)*arg3,arg4,arg5);
14343
14344 wxPyEndAllowThreads(__tstate);
14345 if (PyErr_Occurred()) SWIG_fail;
14346 }
14347 Py_INCREF(Py_None); resultobj = Py_None;
14348 {
14349 if (temp2)
14350 delete arg2;
14351 }
14352 return resultobj;
14353 fail:
14354 {
14355 if (temp2)
14356 delete arg2;
14357 }
14358 return NULL;
14359 }
14360
14361
14362 static PyObject *_wrap_DC_DrawImageLabel(PyObject *, PyObject *args, PyObject *kwargs) {
14363 PyObject *resultobj;
14364 wxDC *arg1 = (wxDC *) 0 ;
14365 wxString *arg2 = 0 ;
14366 wxBitmap *arg3 = 0 ;
14367 wxRect *arg4 = 0 ;
14368 int arg5 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
14369 int arg6 = (int) -1 ;
14370 wxRect result;
14371 bool temp2 = false ;
14372 wxRect temp4 ;
14373 PyObject * obj0 = 0 ;
14374 PyObject * obj1 = 0 ;
14375 PyObject * obj2 = 0 ;
14376 PyObject * obj3 = 0 ;
14377 PyObject * obj4 = 0 ;
14378 PyObject * obj5 = 0 ;
14379 char *kwnames[] = {
14380 (char *) "self",(char *) "text",(char *) "image",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
14381 };
14382
14383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:DC_DrawImageLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
14384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14385 if (SWIG_arg_fail(1)) SWIG_fail;
14386 {
14387 arg2 = wxString_in_helper(obj1);
14388 if (arg2 == NULL) SWIG_fail;
14389 temp2 = true;
14390 }
14391 {
14392 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
14393 if (SWIG_arg_fail(3)) SWIG_fail;
14394 if (arg3 == NULL) {
14395 SWIG_null_ref("wxBitmap");
14396 }
14397 if (SWIG_arg_fail(3)) SWIG_fail;
14398 }
14399 {
14400 arg4 = &temp4;
14401 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
14402 }
14403 if (obj4) {
14404 {
14405 arg5 = (int)(SWIG_As_int(obj4));
14406 if (SWIG_arg_fail(5)) SWIG_fail;
14407 }
14408 }
14409 if (obj5) {
14410 {
14411 arg6 = (int)(SWIG_As_int(obj5));
14412 if (SWIG_arg_fail(6)) SWIG_fail;
14413 }
14414 }
14415 {
14416 PyThreadState* __tstate = wxPyBeginAllowThreads();
14417 result = wxDC_DrawImageLabel(arg1,(wxString const &)*arg2,(wxBitmap const &)*arg3,(wxRect const &)*arg4,arg5,arg6);
14418
14419 wxPyEndAllowThreads(__tstate);
14420 if (PyErr_Occurred()) SWIG_fail;
14421 }
14422 {
14423 wxRect * resultptr;
14424 resultptr = new wxRect((wxRect &)(result));
14425 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
14426 }
14427 {
14428 if (temp2)
14429 delete arg2;
14430 }
14431 return resultobj;
14432 fail:
14433 {
14434 if (temp2)
14435 delete arg2;
14436 }
14437 return NULL;
14438 }
14439
14440
14441 static PyObject *_wrap_DC_DrawSpline(PyObject *, PyObject *args, PyObject *kwargs) {
14442 PyObject *resultobj;
14443 wxDC *arg1 = (wxDC *) 0 ;
14444 int arg2 ;
14445 wxPoint *arg3 = (wxPoint *) 0 ;
14446 PyObject * obj0 = 0 ;
14447 PyObject * obj1 = 0 ;
14448 char *kwnames[] = {
14449 (char *) "self",(char *) "points", NULL
14450 };
14451
14452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawSpline",kwnames,&obj0,&obj1)) goto fail;
14453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14454 if (SWIG_arg_fail(1)) SWIG_fail;
14455 {
14456 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14457 if (arg3 == NULL) SWIG_fail;
14458 }
14459 {
14460 PyThreadState* __tstate = wxPyBeginAllowThreads();
14461 (arg1)->DrawSpline(arg2,arg3);
14462
14463 wxPyEndAllowThreads(__tstate);
14464 if (PyErr_Occurred()) SWIG_fail;
14465 }
14466 Py_INCREF(Py_None); resultobj = Py_None;
14467 {
14468 if (arg3) delete [] arg3;
14469 }
14470 return resultobj;
14471 fail:
14472 {
14473 if (arg3) delete [] arg3;
14474 }
14475 return NULL;
14476 }
14477
14478
14479 static PyObject *_wrap_DC_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
14480 PyObject *resultobj;
14481 wxDC *arg1 = (wxDC *) 0 ;
14482 PyObject * obj0 = 0 ;
14483 char *kwnames[] = {
14484 (char *) "self", NULL
14485 };
14486
14487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Clear",kwnames,&obj0)) goto fail;
14488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14489 if (SWIG_arg_fail(1)) SWIG_fail;
14490 {
14491 PyThreadState* __tstate = wxPyBeginAllowThreads();
14492 (arg1)->Clear();
14493
14494 wxPyEndAllowThreads(__tstate);
14495 if (PyErr_Occurred()) SWIG_fail;
14496 }
14497 Py_INCREF(Py_None); resultobj = Py_None;
14498 return resultobj;
14499 fail:
14500 return NULL;
14501 }
14502
14503
14504 static PyObject *_wrap_DC_StartDoc(PyObject *, PyObject *args, PyObject *kwargs) {
14505 PyObject *resultobj;
14506 wxDC *arg1 = (wxDC *) 0 ;
14507 wxString *arg2 = 0 ;
14508 bool result;
14509 bool temp2 = false ;
14510 PyObject * obj0 = 0 ;
14511 PyObject * obj1 = 0 ;
14512 char *kwnames[] = {
14513 (char *) "self",(char *) "message", NULL
14514 };
14515
14516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_StartDoc",kwnames,&obj0,&obj1)) goto fail;
14517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14518 if (SWIG_arg_fail(1)) SWIG_fail;
14519 {
14520 arg2 = wxString_in_helper(obj1);
14521 if (arg2 == NULL) SWIG_fail;
14522 temp2 = true;
14523 }
14524 {
14525 PyThreadState* __tstate = wxPyBeginAllowThreads();
14526 result = (bool)(arg1)->StartDoc((wxString const &)*arg2);
14527
14528 wxPyEndAllowThreads(__tstate);
14529 if (PyErr_Occurred()) SWIG_fail;
14530 }
14531 {
14532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14533 }
14534 {
14535 if (temp2)
14536 delete arg2;
14537 }
14538 return resultobj;
14539 fail:
14540 {
14541 if (temp2)
14542 delete arg2;
14543 }
14544 return NULL;
14545 }
14546
14547
14548 static PyObject *_wrap_DC_EndDoc(PyObject *, PyObject *args, PyObject *kwargs) {
14549 PyObject *resultobj;
14550 wxDC *arg1 = (wxDC *) 0 ;
14551 PyObject * obj0 = 0 ;
14552 char *kwnames[] = {
14553 (char *) "self", NULL
14554 };
14555
14556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDoc",kwnames,&obj0)) goto fail;
14557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14558 if (SWIG_arg_fail(1)) SWIG_fail;
14559 {
14560 PyThreadState* __tstate = wxPyBeginAllowThreads();
14561 (arg1)->EndDoc();
14562
14563 wxPyEndAllowThreads(__tstate);
14564 if (PyErr_Occurred()) SWIG_fail;
14565 }
14566 Py_INCREF(Py_None); resultobj = Py_None;
14567 return resultobj;
14568 fail:
14569 return NULL;
14570 }
14571
14572
14573 static PyObject *_wrap_DC_StartPage(PyObject *, PyObject *args, PyObject *kwargs) {
14574 PyObject *resultobj;
14575 wxDC *arg1 = (wxDC *) 0 ;
14576 PyObject * obj0 = 0 ;
14577 char *kwnames[] = {
14578 (char *) "self", NULL
14579 };
14580
14581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_StartPage",kwnames,&obj0)) goto fail;
14582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14583 if (SWIG_arg_fail(1)) SWIG_fail;
14584 {
14585 PyThreadState* __tstate = wxPyBeginAllowThreads();
14586 (arg1)->StartPage();
14587
14588 wxPyEndAllowThreads(__tstate);
14589 if (PyErr_Occurred()) SWIG_fail;
14590 }
14591 Py_INCREF(Py_None); resultobj = Py_None;
14592 return resultobj;
14593 fail:
14594 return NULL;
14595 }
14596
14597
14598 static PyObject *_wrap_DC_EndPage(PyObject *, PyObject *args, PyObject *kwargs) {
14599 PyObject *resultobj;
14600 wxDC *arg1 = (wxDC *) 0 ;
14601 PyObject * obj0 = 0 ;
14602 char *kwnames[] = {
14603 (char *) "self", NULL
14604 };
14605
14606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndPage",kwnames,&obj0)) goto fail;
14607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14608 if (SWIG_arg_fail(1)) SWIG_fail;
14609 {
14610 PyThreadState* __tstate = wxPyBeginAllowThreads();
14611 (arg1)->EndPage();
14612
14613 wxPyEndAllowThreads(__tstate);
14614 if (PyErr_Occurred()) SWIG_fail;
14615 }
14616 Py_INCREF(Py_None); resultobj = Py_None;
14617 return resultobj;
14618 fail:
14619 return NULL;
14620 }
14621
14622
14623 static PyObject *_wrap_DC_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
14624 PyObject *resultobj;
14625 wxDC *arg1 = (wxDC *) 0 ;
14626 wxFont *arg2 = 0 ;
14627 PyObject * obj0 = 0 ;
14628 PyObject * obj1 = 0 ;
14629 char *kwnames[] = {
14630 (char *) "self",(char *) "font", NULL
14631 };
14632
14633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetFont",kwnames,&obj0,&obj1)) goto fail;
14634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14635 if (SWIG_arg_fail(1)) SWIG_fail;
14636 {
14637 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
14638 if (SWIG_arg_fail(2)) SWIG_fail;
14639 if (arg2 == NULL) {
14640 SWIG_null_ref("wxFont");
14641 }
14642 if (SWIG_arg_fail(2)) SWIG_fail;
14643 }
14644 {
14645 PyThreadState* __tstate = wxPyBeginAllowThreads();
14646 (arg1)->SetFont((wxFont const &)*arg2);
14647
14648 wxPyEndAllowThreads(__tstate);
14649 if (PyErr_Occurred()) SWIG_fail;
14650 }
14651 Py_INCREF(Py_None); resultobj = Py_None;
14652 return resultobj;
14653 fail:
14654 return NULL;
14655 }
14656
14657
14658 static PyObject *_wrap_DC_SetPen(PyObject *, PyObject *args, PyObject *kwargs) {
14659 PyObject *resultobj;
14660 wxDC *arg1 = (wxDC *) 0 ;
14661 wxPen *arg2 = 0 ;
14662 PyObject * obj0 = 0 ;
14663 PyObject * obj1 = 0 ;
14664 char *kwnames[] = {
14665 (char *) "self",(char *) "pen", NULL
14666 };
14667
14668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPen",kwnames,&obj0,&obj1)) goto fail;
14669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14670 if (SWIG_arg_fail(1)) SWIG_fail;
14671 {
14672 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
14673 if (SWIG_arg_fail(2)) SWIG_fail;
14674 if (arg2 == NULL) {
14675 SWIG_null_ref("wxPen");
14676 }
14677 if (SWIG_arg_fail(2)) SWIG_fail;
14678 }
14679 {
14680 PyThreadState* __tstate = wxPyBeginAllowThreads();
14681 (arg1)->SetPen((wxPen const &)*arg2);
14682
14683 wxPyEndAllowThreads(__tstate);
14684 if (PyErr_Occurred()) SWIG_fail;
14685 }
14686 Py_INCREF(Py_None); resultobj = Py_None;
14687 return resultobj;
14688 fail:
14689 return NULL;
14690 }
14691
14692
14693 static PyObject *_wrap_DC_SetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
14694 PyObject *resultobj;
14695 wxDC *arg1 = (wxDC *) 0 ;
14696 wxBrush *arg2 = 0 ;
14697 PyObject * obj0 = 0 ;
14698 PyObject * obj1 = 0 ;
14699 char *kwnames[] = {
14700 (char *) "self",(char *) "brush", NULL
14701 };
14702
14703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBrush",kwnames,&obj0,&obj1)) goto fail;
14704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14705 if (SWIG_arg_fail(1)) SWIG_fail;
14706 {
14707 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
14708 if (SWIG_arg_fail(2)) SWIG_fail;
14709 if (arg2 == NULL) {
14710 SWIG_null_ref("wxBrush");
14711 }
14712 if (SWIG_arg_fail(2)) SWIG_fail;
14713 }
14714 {
14715 PyThreadState* __tstate = wxPyBeginAllowThreads();
14716 (arg1)->SetBrush((wxBrush const &)*arg2);
14717
14718 wxPyEndAllowThreads(__tstate);
14719 if (PyErr_Occurred()) SWIG_fail;
14720 }
14721 Py_INCREF(Py_None); resultobj = Py_None;
14722 return resultobj;
14723 fail:
14724 return NULL;
14725 }
14726
14727
14728 static PyObject *_wrap_DC_SetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
14729 PyObject *resultobj;
14730 wxDC *arg1 = (wxDC *) 0 ;
14731 wxBrush *arg2 = 0 ;
14732 PyObject * obj0 = 0 ;
14733 PyObject * obj1 = 0 ;
14734 char *kwnames[] = {
14735 (char *) "self",(char *) "brush", NULL
14736 };
14737
14738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackground",kwnames,&obj0,&obj1)) goto fail;
14739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14740 if (SWIG_arg_fail(1)) SWIG_fail;
14741 {
14742 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
14743 if (SWIG_arg_fail(2)) SWIG_fail;
14744 if (arg2 == NULL) {
14745 SWIG_null_ref("wxBrush");
14746 }
14747 if (SWIG_arg_fail(2)) SWIG_fail;
14748 }
14749 {
14750 PyThreadState* __tstate = wxPyBeginAllowThreads();
14751 (arg1)->SetBackground((wxBrush const &)*arg2);
14752
14753 wxPyEndAllowThreads(__tstate);
14754 if (PyErr_Occurred()) SWIG_fail;
14755 }
14756 Py_INCREF(Py_None); resultobj = Py_None;
14757 return resultobj;
14758 fail:
14759 return NULL;
14760 }
14761
14762
14763 static PyObject *_wrap_DC_SetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
14764 PyObject *resultobj;
14765 wxDC *arg1 = (wxDC *) 0 ;
14766 int arg2 ;
14767 PyObject * obj0 = 0 ;
14768 PyObject * obj1 = 0 ;
14769 char *kwnames[] = {
14770 (char *) "self",(char *) "mode", NULL
14771 };
14772
14773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackgroundMode",kwnames,&obj0,&obj1)) goto fail;
14774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14775 if (SWIG_arg_fail(1)) SWIG_fail;
14776 {
14777 arg2 = (int)(SWIG_As_int(obj1));
14778 if (SWIG_arg_fail(2)) SWIG_fail;
14779 }
14780 {
14781 PyThreadState* __tstate = wxPyBeginAllowThreads();
14782 (arg1)->SetBackgroundMode(arg2);
14783
14784 wxPyEndAllowThreads(__tstate);
14785 if (PyErr_Occurred()) SWIG_fail;
14786 }
14787 Py_INCREF(Py_None); resultobj = Py_None;
14788 return resultobj;
14789 fail:
14790 return NULL;
14791 }
14792
14793
14794 static PyObject *_wrap_DC_SetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
14795 PyObject *resultobj;
14796 wxDC *arg1 = (wxDC *) 0 ;
14797 wxPalette *arg2 = 0 ;
14798 PyObject * obj0 = 0 ;
14799 PyObject * obj1 = 0 ;
14800 char *kwnames[] = {
14801 (char *) "self",(char *) "palette", NULL
14802 };
14803
14804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPalette",kwnames,&obj0,&obj1)) goto fail;
14805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14806 if (SWIG_arg_fail(1)) SWIG_fail;
14807 {
14808 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
14809 if (SWIG_arg_fail(2)) SWIG_fail;
14810 if (arg2 == NULL) {
14811 SWIG_null_ref("wxPalette");
14812 }
14813 if (SWIG_arg_fail(2)) SWIG_fail;
14814 }
14815 {
14816 PyThreadState* __tstate = wxPyBeginAllowThreads();
14817 (arg1)->SetPalette((wxPalette const &)*arg2);
14818
14819 wxPyEndAllowThreads(__tstate);
14820 if (PyErr_Occurred()) SWIG_fail;
14821 }
14822 Py_INCREF(Py_None); resultobj = Py_None;
14823 return resultobj;
14824 fail:
14825 return NULL;
14826 }
14827
14828
14829 static PyObject *_wrap_DC_DestroyClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14830 PyObject *resultobj;
14831 wxDC *arg1 = (wxDC *) 0 ;
14832 PyObject * obj0 = 0 ;
14833 char *kwnames[] = {
14834 (char *) "self", NULL
14835 };
14836
14837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_DestroyClippingRegion",kwnames,&obj0)) goto fail;
14838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14839 if (SWIG_arg_fail(1)) SWIG_fail;
14840 {
14841 PyThreadState* __tstate = wxPyBeginAllowThreads();
14842 (arg1)->DestroyClippingRegion();
14843
14844 wxPyEndAllowThreads(__tstate);
14845 if (PyErr_Occurred()) SWIG_fail;
14846 }
14847 Py_INCREF(Py_None); resultobj = Py_None;
14848 return resultobj;
14849 fail:
14850 return NULL;
14851 }
14852
14853
14854 static PyObject *_wrap_DC_GetClippingBox(PyObject *, PyObject *args, PyObject *kwargs) {
14855 PyObject *resultobj;
14856 wxDC *arg1 = (wxDC *) 0 ;
14857 int *arg2 = (int *) 0 ;
14858 int *arg3 = (int *) 0 ;
14859 int *arg4 = (int *) 0 ;
14860 int *arg5 = (int *) 0 ;
14861 int temp2 ;
14862 int res2 = 0 ;
14863 int temp3 ;
14864 int res3 = 0 ;
14865 int temp4 ;
14866 int res4 = 0 ;
14867 int temp5 ;
14868 int res5 = 0 ;
14869 PyObject * obj0 = 0 ;
14870 char *kwnames[] = {
14871 (char *) "self", NULL
14872 };
14873
14874 arg2 = &temp2; res2 = SWIG_NEWOBJ;
14875 arg3 = &temp3; res3 = SWIG_NEWOBJ;
14876 arg4 = &temp4; res4 = SWIG_NEWOBJ;
14877 arg5 = &temp5; res5 = SWIG_NEWOBJ;
14878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingBox",kwnames,&obj0)) goto fail;
14879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14880 if (SWIG_arg_fail(1)) SWIG_fail;
14881 {
14882 PyThreadState* __tstate = wxPyBeginAllowThreads();
14883 ((wxDC const *)arg1)->GetClippingBox(arg2,arg3,arg4,arg5);
14884
14885 wxPyEndAllowThreads(__tstate);
14886 if (PyErr_Occurred()) SWIG_fail;
14887 }
14888 Py_INCREF(Py_None); resultobj = Py_None;
14889 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
14890 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
14891 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
14892 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
14893 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
14894 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
14895 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
14896 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
14897 return resultobj;
14898 fail:
14899 return NULL;
14900 }
14901
14902
14903 static PyObject *_wrap_DC_GetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
14904 PyObject *resultobj;
14905 wxDC *arg1 = (wxDC *) 0 ;
14906 wxRect result;
14907 PyObject * obj0 = 0 ;
14908 char *kwnames[] = {
14909 (char *) "self", NULL
14910 };
14911
14912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingRect",kwnames,&obj0)) goto fail;
14913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14914 if (SWIG_arg_fail(1)) SWIG_fail;
14915 {
14916 PyThreadState* __tstate = wxPyBeginAllowThreads();
14917 result = wxDC_GetClippingRect(arg1);
14918
14919 wxPyEndAllowThreads(__tstate);
14920 if (PyErr_Occurred()) SWIG_fail;
14921 }
14922 {
14923 wxRect * resultptr;
14924 resultptr = new wxRect((wxRect &)(result));
14925 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
14926 }
14927 return resultobj;
14928 fail:
14929 return NULL;
14930 }
14931
14932
14933 static PyObject *_wrap_DC_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
14934 PyObject *resultobj;
14935 wxDC *arg1 = (wxDC *) 0 ;
14936 int result;
14937 PyObject * obj0 = 0 ;
14938 char *kwnames[] = {
14939 (char *) "self", NULL
14940 };
14941
14942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharHeight",kwnames,&obj0)) goto fail;
14943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14944 if (SWIG_arg_fail(1)) SWIG_fail;
14945 {
14946 PyThreadState* __tstate = wxPyBeginAllowThreads();
14947 result = (int)((wxDC const *)arg1)->GetCharHeight();
14948
14949 wxPyEndAllowThreads(__tstate);
14950 if (PyErr_Occurred()) SWIG_fail;
14951 }
14952 {
14953 resultobj = SWIG_From_int((int)(result));
14954 }
14955 return resultobj;
14956 fail:
14957 return NULL;
14958 }
14959
14960
14961 static PyObject *_wrap_DC_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
14962 PyObject *resultobj;
14963 wxDC *arg1 = (wxDC *) 0 ;
14964 int result;
14965 PyObject * obj0 = 0 ;
14966 char *kwnames[] = {
14967 (char *) "self", NULL
14968 };
14969
14970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharWidth",kwnames,&obj0)) goto fail;
14971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14972 if (SWIG_arg_fail(1)) SWIG_fail;
14973 {
14974 PyThreadState* __tstate = wxPyBeginAllowThreads();
14975 result = (int)((wxDC const *)arg1)->GetCharWidth();
14976
14977 wxPyEndAllowThreads(__tstate);
14978 if (PyErr_Occurred()) SWIG_fail;
14979 }
14980 {
14981 resultobj = SWIG_From_int((int)(result));
14982 }
14983 return resultobj;
14984 fail:
14985 return NULL;
14986 }
14987
14988
14989 static PyObject *_wrap_DC_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
14990 PyObject *resultobj;
14991 wxDC *arg1 = (wxDC *) 0 ;
14992 wxString *arg2 = 0 ;
14993 int *arg3 = (int *) 0 ;
14994 int *arg4 = (int *) 0 ;
14995 bool temp2 = false ;
14996 int temp3 ;
14997 int res3 = 0 ;
14998 int temp4 ;
14999 int res4 = 0 ;
15000 PyObject * obj0 = 0 ;
15001 PyObject * obj1 = 0 ;
15002 char *kwnames[] = {
15003 (char *) "self",(char *) "string", NULL
15004 };
15005
15006 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15007 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
15009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15010 if (SWIG_arg_fail(1)) SWIG_fail;
15011 {
15012 arg2 = wxString_in_helper(obj1);
15013 if (arg2 == NULL) SWIG_fail;
15014 temp2 = true;
15015 }
15016 {
15017 PyThreadState* __tstate = wxPyBeginAllowThreads();
15018 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
15019
15020 wxPyEndAllowThreads(__tstate);
15021 if (PyErr_Occurred()) SWIG_fail;
15022 }
15023 Py_INCREF(Py_None); resultobj = Py_None;
15024 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15025 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15026 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15027 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15028 {
15029 if (temp2)
15030 delete arg2;
15031 }
15032 return resultobj;
15033 fail:
15034 {
15035 if (temp2)
15036 delete arg2;
15037 }
15038 return NULL;
15039 }
15040
15041
15042 static PyObject *_wrap_DC_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15043 PyObject *resultobj;
15044 wxDC *arg1 = (wxDC *) 0 ;
15045 wxString *arg2 = 0 ;
15046 int *arg3 = (int *) 0 ;
15047 int *arg4 = (int *) 0 ;
15048 int *arg5 = (int *) 0 ;
15049 int *arg6 = (int *) 0 ;
15050 wxFont *arg7 = (wxFont *) NULL ;
15051 bool temp2 = false ;
15052 int temp3 ;
15053 int res3 = 0 ;
15054 int temp4 ;
15055 int res4 = 0 ;
15056 int temp5 ;
15057 int res5 = 0 ;
15058 int temp6 ;
15059 int res6 = 0 ;
15060 PyObject * obj0 = 0 ;
15061 PyObject * obj1 = 0 ;
15062 PyObject * obj2 = 0 ;
15063 char *kwnames[] = {
15064 (char *) "self",(char *) "string",(char *) "font", NULL
15065 };
15066
15067 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15068 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15069 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15070 arg6 = &temp6; res6 = SWIG_NEWOBJ;
15071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15073 if (SWIG_arg_fail(1)) SWIG_fail;
15074 {
15075 arg2 = wxString_in_helper(obj1);
15076 if (arg2 == NULL) SWIG_fail;
15077 temp2 = true;
15078 }
15079 if (obj2) {
15080 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15081 if (SWIG_arg_fail(7)) SWIG_fail;
15082 }
15083 {
15084 PyThreadState* __tstate = wxPyBeginAllowThreads();
15085 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7);
15086
15087 wxPyEndAllowThreads(__tstate);
15088 if (PyErr_Occurred()) SWIG_fail;
15089 }
15090 Py_INCREF(Py_None); resultobj = Py_None;
15091 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15092 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15093 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15094 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15095 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15096 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15097 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
15098 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
15099 {
15100 if (temp2)
15101 delete arg2;
15102 }
15103 return resultobj;
15104 fail:
15105 {
15106 if (temp2)
15107 delete arg2;
15108 }
15109 return NULL;
15110 }
15111
15112
15113 static PyObject *_wrap_DC_GetMultiLineTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15114 PyObject *resultobj;
15115 wxDC *arg1 = (wxDC *) 0 ;
15116 wxString *arg2 = 0 ;
15117 int *arg3 = (int *) 0 ;
15118 int *arg4 = (int *) 0 ;
15119 int *arg5 = (int *) 0 ;
15120 wxFont *arg6 = (wxFont *) NULL ;
15121 bool temp2 = false ;
15122 int temp3 ;
15123 int res3 = 0 ;
15124 int temp4 ;
15125 int res4 = 0 ;
15126 int temp5 ;
15127 int res5 = 0 ;
15128 PyObject * obj0 = 0 ;
15129 PyObject * obj1 = 0 ;
15130 PyObject * obj2 = 0 ;
15131 char *kwnames[] = {
15132 (char *) "self",(char *) "text",(char *) "font", NULL
15133 };
15134
15135 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15136 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15137 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetMultiLineTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15140 if (SWIG_arg_fail(1)) SWIG_fail;
15141 {
15142 arg2 = wxString_in_helper(obj1);
15143 if (arg2 == NULL) SWIG_fail;
15144 temp2 = true;
15145 }
15146 if (obj2) {
15147 SWIG_Python_ConvertPtr(obj2, (void **)&arg6, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15148 if (SWIG_arg_fail(6)) SWIG_fail;
15149 }
15150 {
15151 PyThreadState* __tstate = wxPyBeginAllowThreads();
15152 (arg1)->GetMultiLineTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6);
15153
15154 wxPyEndAllowThreads(__tstate);
15155 if (PyErr_Occurred()) SWIG_fail;
15156 }
15157 Py_INCREF(Py_None); resultobj = Py_None;
15158 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15159 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15160 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15161 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15162 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15163 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15164 {
15165 if (temp2)
15166 delete arg2;
15167 }
15168 return resultobj;
15169 fail:
15170 {
15171 if (temp2)
15172 delete arg2;
15173 }
15174 return NULL;
15175 }
15176
15177
15178 static PyObject *_wrap_DC_GetPartialTextExtents(PyObject *, PyObject *args, PyObject *kwargs) {
15179 PyObject *resultobj;
15180 wxDC *arg1 = (wxDC *) 0 ;
15181 wxString *arg2 = 0 ;
15182 wxArrayInt result;
15183 bool temp2 = false ;
15184 PyObject * obj0 = 0 ;
15185 PyObject * obj1 = 0 ;
15186 char *kwnames[] = {
15187 (char *) "self",(char *) "text", NULL
15188 };
15189
15190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPartialTextExtents",kwnames,&obj0,&obj1)) goto fail;
15191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15192 if (SWIG_arg_fail(1)) SWIG_fail;
15193 {
15194 arg2 = wxString_in_helper(obj1);
15195 if (arg2 == NULL) SWIG_fail;
15196 temp2 = true;
15197 }
15198 {
15199 PyThreadState* __tstate = wxPyBeginAllowThreads();
15200 result = wxDC_GetPartialTextExtents(arg1,(wxString const &)*arg2);
15201
15202 wxPyEndAllowThreads(__tstate);
15203 if (PyErr_Occurred()) SWIG_fail;
15204 }
15205 {
15206 resultobj = PyList_New(0);
15207 size_t idx;
15208 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
15209 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
15210 PyList_Append(resultobj, val);
15211 Py_DECREF(val);
15212 }
15213 }
15214 {
15215 if (temp2)
15216 delete arg2;
15217 }
15218 return resultobj;
15219 fail:
15220 {
15221 if (temp2)
15222 delete arg2;
15223 }
15224 return NULL;
15225 }
15226
15227
15228 static PyObject *_wrap_DC_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
15229 PyObject *resultobj;
15230 wxDC *arg1 = (wxDC *) 0 ;
15231 wxSize result;
15232 PyObject * obj0 = 0 ;
15233 char *kwnames[] = {
15234 (char *) "self", NULL
15235 };
15236
15237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSize",kwnames,&obj0)) goto fail;
15238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15239 if (SWIG_arg_fail(1)) SWIG_fail;
15240 {
15241 PyThreadState* __tstate = wxPyBeginAllowThreads();
15242 result = (arg1)->GetSize();
15243
15244 wxPyEndAllowThreads(__tstate);
15245 if (PyErr_Occurred()) SWIG_fail;
15246 }
15247 {
15248 wxSize * resultptr;
15249 resultptr = new wxSize((wxSize &)(result));
15250 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15251 }
15252 return resultobj;
15253 fail:
15254 return NULL;
15255 }
15256
15257
15258 static PyObject *_wrap_DC_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
15259 PyObject *resultobj;
15260 wxDC *arg1 = (wxDC *) 0 ;
15261 int *arg2 = (int *) 0 ;
15262 int *arg3 = (int *) 0 ;
15263 int temp2 ;
15264 int res2 = 0 ;
15265 int temp3 ;
15266 int res3 = 0 ;
15267 PyObject * obj0 = 0 ;
15268 char *kwnames[] = {
15269 (char *) "self", NULL
15270 };
15271
15272 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15273 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeTuple",kwnames,&obj0)) goto fail;
15275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15276 if (SWIG_arg_fail(1)) SWIG_fail;
15277 {
15278 PyThreadState* __tstate = wxPyBeginAllowThreads();
15279 (arg1)->GetSize(arg2,arg3);
15280
15281 wxPyEndAllowThreads(__tstate);
15282 if (PyErr_Occurred()) SWIG_fail;
15283 }
15284 Py_INCREF(Py_None); resultobj = Py_None;
15285 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15286 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15287 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15288 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15289 return resultobj;
15290 fail:
15291 return NULL;
15292 }
15293
15294
15295 static PyObject *_wrap_DC_GetSizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
15296 PyObject *resultobj;
15297 wxDC *arg1 = (wxDC *) 0 ;
15298 wxSize result;
15299 PyObject * obj0 = 0 ;
15300 char *kwnames[] = {
15301 (char *) "self", NULL
15302 };
15303
15304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMM",kwnames,&obj0)) goto fail;
15305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15306 if (SWIG_arg_fail(1)) SWIG_fail;
15307 {
15308 PyThreadState* __tstate = wxPyBeginAllowThreads();
15309 result = ((wxDC const *)arg1)->GetSizeMM();
15310
15311 wxPyEndAllowThreads(__tstate);
15312 if (PyErr_Occurred()) SWIG_fail;
15313 }
15314 {
15315 wxSize * resultptr;
15316 resultptr = new wxSize((wxSize &)(result));
15317 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15318 }
15319 return resultobj;
15320 fail:
15321 return NULL;
15322 }
15323
15324
15325 static PyObject *_wrap_DC_GetSizeMMTuple(PyObject *, PyObject *args, PyObject *kwargs) {
15326 PyObject *resultobj;
15327 wxDC *arg1 = (wxDC *) 0 ;
15328 int *arg2 = (int *) 0 ;
15329 int *arg3 = (int *) 0 ;
15330 int temp2 ;
15331 int res2 = 0 ;
15332 int temp3 ;
15333 int res3 = 0 ;
15334 PyObject * obj0 = 0 ;
15335 char *kwnames[] = {
15336 (char *) "self", NULL
15337 };
15338
15339 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15340 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMMTuple",kwnames,&obj0)) goto fail;
15342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15343 if (SWIG_arg_fail(1)) SWIG_fail;
15344 {
15345 PyThreadState* __tstate = wxPyBeginAllowThreads();
15346 ((wxDC const *)arg1)->GetSizeMM(arg2,arg3);
15347
15348 wxPyEndAllowThreads(__tstate);
15349 if (PyErr_Occurred()) SWIG_fail;
15350 }
15351 Py_INCREF(Py_None); resultobj = Py_None;
15352 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15353 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15354 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15355 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15356 return resultobj;
15357 fail:
15358 return NULL;
15359 }
15360
15361
15362 static PyObject *_wrap_DC_DeviceToLogicalX(PyObject *, PyObject *args, PyObject *kwargs) {
15363 PyObject *resultobj;
15364 wxDC *arg1 = (wxDC *) 0 ;
15365 int arg2 ;
15366 int result;
15367 PyObject * obj0 = 0 ;
15368 PyObject * obj1 = 0 ;
15369 char *kwnames[] = {
15370 (char *) "self",(char *) "x", NULL
15371 };
15372
15373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalX",kwnames,&obj0,&obj1)) goto fail;
15374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15375 if (SWIG_arg_fail(1)) SWIG_fail;
15376 {
15377 arg2 = (int)(SWIG_As_int(obj1));
15378 if (SWIG_arg_fail(2)) SWIG_fail;
15379 }
15380 {
15381 PyThreadState* __tstate = wxPyBeginAllowThreads();
15382 result = (int)((wxDC const *)arg1)->DeviceToLogicalX(arg2);
15383
15384 wxPyEndAllowThreads(__tstate);
15385 if (PyErr_Occurred()) SWIG_fail;
15386 }
15387 {
15388 resultobj = SWIG_From_int((int)(result));
15389 }
15390 return resultobj;
15391 fail:
15392 return NULL;
15393 }
15394
15395
15396 static PyObject *_wrap_DC_DeviceToLogicalY(PyObject *, PyObject *args, PyObject *kwargs) {
15397 PyObject *resultobj;
15398 wxDC *arg1 = (wxDC *) 0 ;
15399 int arg2 ;
15400 int result;
15401 PyObject * obj0 = 0 ;
15402 PyObject * obj1 = 0 ;
15403 char *kwnames[] = {
15404 (char *) "self",(char *) "y", NULL
15405 };
15406
15407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalY",kwnames,&obj0,&obj1)) goto fail;
15408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15409 if (SWIG_arg_fail(1)) SWIG_fail;
15410 {
15411 arg2 = (int)(SWIG_As_int(obj1));
15412 if (SWIG_arg_fail(2)) SWIG_fail;
15413 }
15414 {
15415 PyThreadState* __tstate = wxPyBeginAllowThreads();
15416 result = (int)((wxDC const *)arg1)->DeviceToLogicalY(arg2);
15417
15418 wxPyEndAllowThreads(__tstate);
15419 if (PyErr_Occurred()) SWIG_fail;
15420 }
15421 {
15422 resultobj = SWIG_From_int((int)(result));
15423 }
15424 return resultobj;
15425 fail:
15426 return NULL;
15427 }
15428
15429
15430 static PyObject *_wrap_DC_DeviceToLogicalXRel(PyObject *, PyObject *args, PyObject *kwargs) {
15431 PyObject *resultobj;
15432 wxDC *arg1 = (wxDC *) 0 ;
15433 int arg2 ;
15434 int result;
15435 PyObject * obj0 = 0 ;
15436 PyObject * obj1 = 0 ;
15437 char *kwnames[] = {
15438 (char *) "self",(char *) "x", NULL
15439 };
15440
15441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalXRel",kwnames,&obj0,&obj1)) goto fail;
15442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15443 if (SWIG_arg_fail(1)) SWIG_fail;
15444 {
15445 arg2 = (int)(SWIG_As_int(obj1));
15446 if (SWIG_arg_fail(2)) SWIG_fail;
15447 }
15448 {
15449 PyThreadState* __tstate = wxPyBeginAllowThreads();
15450 result = (int)((wxDC const *)arg1)->DeviceToLogicalXRel(arg2);
15451
15452 wxPyEndAllowThreads(__tstate);
15453 if (PyErr_Occurred()) SWIG_fail;
15454 }
15455 {
15456 resultobj = SWIG_From_int((int)(result));
15457 }
15458 return resultobj;
15459 fail:
15460 return NULL;
15461 }
15462
15463
15464 static PyObject *_wrap_DC_DeviceToLogicalYRel(PyObject *, PyObject *args, PyObject *kwargs) {
15465 PyObject *resultobj;
15466 wxDC *arg1 = (wxDC *) 0 ;
15467 int arg2 ;
15468 int result;
15469 PyObject * obj0 = 0 ;
15470 PyObject * obj1 = 0 ;
15471 char *kwnames[] = {
15472 (char *) "self",(char *) "y", NULL
15473 };
15474
15475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalYRel",kwnames,&obj0,&obj1)) goto fail;
15476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15477 if (SWIG_arg_fail(1)) SWIG_fail;
15478 {
15479 arg2 = (int)(SWIG_As_int(obj1));
15480 if (SWIG_arg_fail(2)) SWIG_fail;
15481 }
15482 {
15483 PyThreadState* __tstate = wxPyBeginAllowThreads();
15484 result = (int)((wxDC const *)arg1)->DeviceToLogicalYRel(arg2);
15485
15486 wxPyEndAllowThreads(__tstate);
15487 if (PyErr_Occurred()) SWIG_fail;
15488 }
15489 {
15490 resultobj = SWIG_From_int((int)(result));
15491 }
15492 return resultobj;
15493 fail:
15494 return NULL;
15495 }
15496
15497
15498 static PyObject *_wrap_DC_LogicalToDeviceX(PyObject *, PyObject *args, PyObject *kwargs) {
15499 PyObject *resultobj;
15500 wxDC *arg1 = (wxDC *) 0 ;
15501 int arg2 ;
15502 int result;
15503 PyObject * obj0 = 0 ;
15504 PyObject * obj1 = 0 ;
15505 char *kwnames[] = {
15506 (char *) "self",(char *) "x", NULL
15507 };
15508
15509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceX",kwnames,&obj0,&obj1)) goto fail;
15510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15511 if (SWIG_arg_fail(1)) SWIG_fail;
15512 {
15513 arg2 = (int)(SWIG_As_int(obj1));
15514 if (SWIG_arg_fail(2)) SWIG_fail;
15515 }
15516 {
15517 PyThreadState* __tstate = wxPyBeginAllowThreads();
15518 result = (int)((wxDC const *)arg1)->LogicalToDeviceX(arg2);
15519
15520 wxPyEndAllowThreads(__tstate);
15521 if (PyErr_Occurred()) SWIG_fail;
15522 }
15523 {
15524 resultobj = SWIG_From_int((int)(result));
15525 }
15526 return resultobj;
15527 fail:
15528 return NULL;
15529 }
15530
15531
15532 static PyObject *_wrap_DC_LogicalToDeviceY(PyObject *, PyObject *args, PyObject *kwargs) {
15533 PyObject *resultobj;
15534 wxDC *arg1 = (wxDC *) 0 ;
15535 int arg2 ;
15536 int result;
15537 PyObject * obj0 = 0 ;
15538 PyObject * obj1 = 0 ;
15539 char *kwnames[] = {
15540 (char *) "self",(char *) "y", NULL
15541 };
15542
15543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceY",kwnames,&obj0,&obj1)) goto fail;
15544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15545 if (SWIG_arg_fail(1)) SWIG_fail;
15546 {
15547 arg2 = (int)(SWIG_As_int(obj1));
15548 if (SWIG_arg_fail(2)) SWIG_fail;
15549 }
15550 {
15551 PyThreadState* __tstate = wxPyBeginAllowThreads();
15552 result = (int)((wxDC const *)arg1)->LogicalToDeviceY(arg2);
15553
15554 wxPyEndAllowThreads(__tstate);
15555 if (PyErr_Occurred()) SWIG_fail;
15556 }
15557 {
15558 resultobj = SWIG_From_int((int)(result));
15559 }
15560 return resultobj;
15561 fail:
15562 return NULL;
15563 }
15564
15565
15566 static PyObject *_wrap_DC_LogicalToDeviceXRel(PyObject *, PyObject *args, PyObject *kwargs) {
15567 PyObject *resultobj;
15568 wxDC *arg1 = (wxDC *) 0 ;
15569 int arg2 ;
15570 int result;
15571 PyObject * obj0 = 0 ;
15572 PyObject * obj1 = 0 ;
15573 char *kwnames[] = {
15574 (char *) "self",(char *) "x", NULL
15575 };
15576
15577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceXRel",kwnames,&obj0,&obj1)) goto fail;
15578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15579 if (SWIG_arg_fail(1)) SWIG_fail;
15580 {
15581 arg2 = (int)(SWIG_As_int(obj1));
15582 if (SWIG_arg_fail(2)) SWIG_fail;
15583 }
15584 {
15585 PyThreadState* __tstate = wxPyBeginAllowThreads();
15586 result = (int)((wxDC const *)arg1)->LogicalToDeviceXRel(arg2);
15587
15588 wxPyEndAllowThreads(__tstate);
15589 if (PyErr_Occurred()) SWIG_fail;
15590 }
15591 {
15592 resultobj = SWIG_From_int((int)(result));
15593 }
15594 return resultobj;
15595 fail:
15596 return NULL;
15597 }
15598
15599
15600 static PyObject *_wrap_DC_LogicalToDeviceYRel(PyObject *, PyObject *args, PyObject *kwargs) {
15601 PyObject *resultobj;
15602 wxDC *arg1 = (wxDC *) 0 ;
15603 int arg2 ;
15604 int result;
15605 PyObject * obj0 = 0 ;
15606 PyObject * obj1 = 0 ;
15607 char *kwnames[] = {
15608 (char *) "self",(char *) "y", NULL
15609 };
15610
15611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceYRel",kwnames,&obj0,&obj1)) goto fail;
15612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15613 if (SWIG_arg_fail(1)) SWIG_fail;
15614 {
15615 arg2 = (int)(SWIG_As_int(obj1));
15616 if (SWIG_arg_fail(2)) SWIG_fail;
15617 }
15618 {
15619 PyThreadState* __tstate = wxPyBeginAllowThreads();
15620 result = (int)((wxDC const *)arg1)->LogicalToDeviceYRel(arg2);
15621
15622 wxPyEndAllowThreads(__tstate);
15623 if (PyErr_Occurred()) SWIG_fail;
15624 }
15625 {
15626 resultobj = SWIG_From_int((int)(result));
15627 }
15628 return resultobj;
15629 fail:
15630 return NULL;
15631 }
15632
15633
15634 static PyObject *_wrap_DC_CanDrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
15635 PyObject *resultobj;
15636 wxDC *arg1 = (wxDC *) 0 ;
15637 bool result;
15638 PyObject * obj0 = 0 ;
15639 char *kwnames[] = {
15640 (char *) "self", NULL
15641 };
15642
15643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanDrawBitmap",kwnames,&obj0)) goto fail;
15644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15645 if (SWIG_arg_fail(1)) SWIG_fail;
15646 {
15647 PyThreadState* __tstate = wxPyBeginAllowThreads();
15648 result = (bool)((wxDC const *)arg1)->CanDrawBitmap();
15649
15650 wxPyEndAllowThreads(__tstate);
15651 if (PyErr_Occurred()) SWIG_fail;
15652 }
15653 {
15654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15655 }
15656 return resultobj;
15657 fail:
15658 return NULL;
15659 }
15660
15661
15662 static PyObject *_wrap_DC_CanGetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15663 PyObject *resultobj;
15664 wxDC *arg1 = (wxDC *) 0 ;
15665 bool result;
15666 PyObject * obj0 = 0 ;
15667 char *kwnames[] = {
15668 (char *) "self", NULL
15669 };
15670
15671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanGetTextExtent",kwnames,&obj0)) goto fail;
15672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15673 if (SWIG_arg_fail(1)) SWIG_fail;
15674 {
15675 PyThreadState* __tstate = wxPyBeginAllowThreads();
15676 result = (bool)((wxDC const *)arg1)->CanGetTextExtent();
15677
15678 wxPyEndAllowThreads(__tstate);
15679 if (PyErr_Occurred()) SWIG_fail;
15680 }
15681 {
15682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15683 }
15684 return resultobj;
15685 fail:
15686 return NULL;
15687 }
15688
15689
15690 static PyObject *_wrap_DC_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
15691 PyObject *resultobj;
15692 wxDC *arg1 = (wxDC *) 0 ;
15693 int result;
15694 PyObject * obj0 = 0 ;
15695 char *kwnames[] = {
15696 (char *) "self", NULL
15697 };
15698
15699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDepth",kwnames,&obj0)) goto fail;
15700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15701 if (SWIG_arg_fail(1)) SWIG_fail;
15702 {
15703 PyThreadState* __tstate = wxPyBeginAllowThreads();
15704 result = (int)((wxDC const *)arg1)->GetDepth();
15705
15706 wxPyEndAllowThreads(__tstate);
15707 if (PyErr_Occurred()) SWIG_fail;
15708 }
15709 {
15710 resultobj = SWIG_From_int((int)(result));
15711 }
15712 return resultobj;
15713 fail:
15714 return NULL;
15715 }
15716
15717
15718 static PyObject *_wrap_DC_GetPPI(PyObject *, PyObject *args, PyObject *kwargs) {
15719 PyObject *resultobj;
15720 wxDC *arg1 = (wxDC *) 0 ;
15721 wxSize result;
15722 PyObject * obj0 = 0 ;
15723 char *kwnames[] = {
15724 (char *) "self", NULL
15725 };
15726
15727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPPI",kwnames,&obj0)) goto fail;
15728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15729 if (SWIG_arg_fail(1)) SWIG_fail;
15730 {
15731 PyThreadState* __tstate = wxPyBeginAllowThreads();
15732 result = ((wxDC const *)arg1)->GetPPI();
15733
15734 wxPyEndAllowThreads(__tstate);
15735 if (PyErr_Occurred()) SWIG_fail;
15736 }
15737 {
15738 wxSize * resultptr;
15739 resultptr = new wxSize((wxSize &)(result));
15740 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15741 }
15742 return resultobj;
15743 fail:
15744 return NULL;
15745 }
15746
15747
15748 static PyObject *_wrap_DC_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
15749 PyObject *resultobj;
15750 wxDC *arg1 = (wxDC *) 0 ;
15751 bool result;
15752 PyObject * obj0 = 0 ;
15753 char *kwnames[] = {
15754 (char *) "self", NULL
15755 };
15756
15757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Ok",kwnames,&obj0)) goto fail;
15758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15759 if (SWIG_arg_fail(1)) SWIG_fail;
15760 {
15761 PyThreadState* __tstate = wxPyBeginAllowThreads();
15762 result = (bool)((wxDC const *)arg1)->Ok();
15763
15764 wxPyEndAllowThreads(__tstate);
15765 if (PyErr_Occurred()) SWIG_fail;
15766 }
15767 {
15768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15769 }
15770 return resultobj;
15771 fail:
15772 return NULL;
15773 }
15774
15775
15776 static PyObject *_wrap_DC_GetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
15777 PyObject *resultobj;
15778 wxDC *arg1 = (wxDC *) 0 ;
15779 int result;
15780 PyObject * obj0 = 0 ;
15781 char *kwnames[] = {
15782 (char *) "self", NULL
15783 };
15784
15785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackgroundMode",kwnames,&obj0)) goto fail;
15786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15787 if (SWIG_arg_fail(1)) SWIG_fail;
15788 {
15789 PyThreadState* __tstate = wxPyBeginAllowThreads();
15790 result = (int)((wxDC const *)arg1)->GetBackgroundMode();
15791
15792 wxPyEndAllowThreads(__tstate);
15793 if (PyErr_Occurred()) SWIG_fail;
15794 }
15795 {
15796 resultobj = SWIG_From_int((int)(result));
15797 }
15798 return resultobj;
15799 fail:
15800 return NULL;
15801 }
15802
15803
15804 static PyObject *_wrap_DC_GetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
15805 PyObject *resultobj;
15806 wxDC *arg1 = (wxDC *) 0 ;
15807 wxBrush *result;
15808 PyObject * obj0 = 0 ;
15809 char *kwnames[] = {
15810 (char *) "self", NULL
15811 };
15812
15813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackground",kwnames,&obj0)) goto fail;
15814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15815 if (SWIG_arg_fail(1)) SWIG_fail;
15816 {
15817 PyThreadState* __tstate = wxPyBeginAllowThreads();
15818 {
15819 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBackground();
15820 result = (wxBrush *) &_result_ref;
15821 }
15822
15823 wxPyEndAllowThreads(__tstate);
15824 if (PyErr_Occurred()) SWIG_fail;
15825 }
15826 {
15827 wxBrush* resultptr = new wxBrush(*result);
15828 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
15829 }
15830 return resultobj;
15831 fail:
15832 return NULL;
15833 }
15834
15835
15836 static PyObject *_wrap_DC_GetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
15837 PyObject *resultobj;
15838 wxDC *arg1 = (wxDC *) 0 ;
15839 wxBrush *result;
15840 PyObject * obj0 = 0 ;
15841 char *kwnames[] = {
15842 (char *) "self", NULL
15843 };
15844
15845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBrush",kwnames,&obj0)) goto fail;
15846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15847 if (SWIG_arg_fail(1)) SWIG_fail;
15848 {
15849 PyThreadState* __tstate = wxPyBeginAllowThreads();
15850 {
15851 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBrush();
15852 result = (wxBrush *) &_result_ref;
15853 }
15854
15855 wxPyEndAllowThreads(__tstate);
15856 if (PyErr_Occurred()) SWIG_fail;
15857 }
15858 {
15859 wxBrush* resultptr = new wxBrush(*result);
15860 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
15861 }
15862 return resultobj;
15863 fail:
15864 return NULL;
15865 }
15866
15867
15868 static PyObject *_wrap_DC_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
15869 PyObject *resultobj;
15870 wxDC *arg1 = (wxDC *) 0 ;
15871 wxFont *result;
15872 PyObject * obj0 = 0 ;
15873 char *kwnames[] = {
15874 (char *) "self", NULL
15875 };
15876
15877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetFont",kwnames,&obj0)) goto fail;
15878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15879 if (SWIG_arg_fail(1)) SWIG_fail;
15880 {
15881 PyThreadState* __tstate = wxPyBeginAllowThreads();
15882 {
15883 wxFont const &_result_ref = ((wxDC const *)arg1)->GetFont();
15884 result = (wxFont *) &_result_ref;
15885 }
15886
15887 wxPyEndAllowThreads(__tstate);
15888 if (PyErr_Occurred()) SWIG_fail;
15889 }
15890 {
15891 wxFont* resultptr = new wxFont(*result);
15892 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxFont, 1);
15893 }
15894 return resultobj;
15895 fail:
15896 return NULL;
15897 }
15898
15899
15900 static PyObject *_wrap_DC_GetPen(PyObject *, PyObject *args, PyObject *kwargs) {
15901 PyObject *resultobj;
15902 wxDC *arg1 = (wxDC *) 0 ;
15903 wxPen *result;
15904 PyObject * obj0 = 0 ;
15905 char *kwnames[] = {
15906 (char *) "self", NULL
15907 };
15908
15909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPen",kwnames,&obj0)) goto fail;
15910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15911 if (SWIG_arg_fail(1)) SWIG_fail;
15912 {
15913 PyThreadState* __tstate = wxPyBeginAllowThreads();
15914 {
15915 wxPen const &_result_ref = ((wxDC const *)arg1)->GetPen();
15916 result = (wxPen *) &_result_ref;
15917 }
15918
15919 wxPyEndAllowThreads(__tstate);
15920 if (PyErr_Occurred()) SWIG_fail;
15921 }
15922 {
15923 wxPen* resultptr = new wxPen(*result);
15924 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxPen, 1);
15925 }
15926 return resultobj;
15927 fail:
15928 return NULL;
15929 }
15930
15931
15932 static PyObject *_wrap_DC_GetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
15933 PyObject *resultobj;
15934 wxDC *arg1 = (wxDC *) 0 ;
15935 wxColour *result;
15936 PyObject * obj0 = 0 ;
15937 char *kwnames[] = {
15938 (char *) "self", NULL
15939 };
15940
15941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextBackground",kwnames,&obj0)) goto fail;
15942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15943 if (SWIG_arg_fail(1)) SWIG_fail;
15944 {
15945 PyThreadState* __tstate = wxPyBeginAllowThreads();
15946 {
15947 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextBackground();
15948 result = (wxColour *) &_result_ref;
15949 }
15950
15951 wxPyEndAllowThreads(__tstate);
15952 if (PyErr_Occurred()) SWIG_fail;
15953 }
15954 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
15955 return resultobj;
15956 fail:
15957 return NULL;
15958 }
15959
15960
15961 static PyObject *_wrap_DC_GetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
15962 PyObject *resultobj;
15963 wxDC *arg1 = (wxDC *) 0 ;
15964 wxColour *result;
15965 PyObject * obj0 = 0 ;
15966 char *kwnames[] = {
15967 (char *) "self", NULL
15968 };
15969
15970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextForeground",kwnames,&obj0)) goto fail;
15971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15972 if (SWIG_arg_fail(1)) SWIG_fail;
15973 {
15974 PyThreadState* __tstate = wxPyBeginAllowThreads();
15975 {
15976 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextForeground();
15977 result = (wxColour *) &_result_ref;
15978 }
15979
15980 wxPyEndAllowThreads(__tstate);
15981 if (PyErr_Occurred()) SWIG_fail;
15982 }
15983 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
15984 return resultobj;
15985 fail:
15986 return NULL;
15987 }
15988
15989
15990 static PyObject *_wrap_DC_SetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
15991 PyObject *resultobj;
15992 wxDC *arg1 = (wxDC *) 0 ;
15993 wxColour *arg2 = 0 ;
15994 wxColour temp2 ;
15995 PyObject * obj0 = 0 ;
15996 PyObject * obj1 = 0 ;
15997 char *kwnames[] = {
15998 (char *) "self",(char *) "colour", NULL
15999 };
16000
16001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextForeground",kwnames,&obj0,&obj1)) goto fail;
16002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16003 if (SWIG_arg_fail(1)) SWIG_fail;
16004 {
16005 arg2 = &temp2;
16006 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16007 }
16008 {
16009 PyThreadState* __tstate = wxPyBeginAllowThreads();
16010 (arg1)->SetTextForeground((wxColour const &)*arg2);
16011
16012 wxPyEndAllowThreads(__tstate);
16013 if (PyErr_Occurred()) SWIG_fail;
16014 }
16015 Py_INCREF(Py_None); resultobj = Py_None;
16016 return resultobj;
16017 fail:
16018 return NULL;
16019 }
16020
16021
16022 static PyObject *_wrap_DC_SetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16023 PyObject *resultobj;
16024 wxDC *arg1 = (wxDC *) 0 ;
16025 wxColour *arg2 = 0 ;
16026 wxColour temp2 ;
16027 PyObject * obj0 = 0 ;
16028 PyObject * obj1 = 0 ;
16029 char *kwnames[] = {
16030 (char *) "self",(char *) "colour", NULL
16031 };
16032
16033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextBackground",kwnames,&obj0,&obj1)) goto fail;
16034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16035 if (SWIG_arg_fail(1)) SWIG_fail;
16036 {
16037 arg2 = &temp2;
16038 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16039 }
16040 {
16041 PyThreadState* __tstate = wxPyBeginAllowThreads();
16042 (arg1)->SetTextBackground((wxColour const &)*arg2);
16043
16044 wxPyEndAllowThreads(__tstate);
16045 if (PyErr_Occurred()) SWIG_fail;
16046 }
16047 Py_INCREF(Py_None); resultobj = Py_None;
16048 return resultobj;
16049 fail:
16050 return NULL;
16051 }
16052
16053
16054 static PyObject *_wrap_DC_GetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16055 PyObject *resultobj;
16056 wxDC *arg1 = (wxDC *) 0 ;
16057 int result;
16058 PyObject * obj0 = 0 ;
16059 char *kwnames[] = {
16060 (char *) "self", NULL
16061 };
16062
16063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetMapMode",kwnames,&obj0)) goto fail;
16064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16065 if (SWIG_arg_fail(1)) SWIG_fail;
16066 {
16067 PyThreadState* __tstate = wxPyBeginAllowThreads();
16068 result = (int)((wxDC const *)arg1)->GetMapMode();
16069
16070 wxPyEndAllowThreads(__tstate);
16071 if (PyErr_Occurred()) SWIG_fail;
16072 }
16073 {
16074 resultobj = SWIG_From_int((int)(result));
16075 }
16076 return resultobj;
16077 fail:
16078 return NULL;
16079 }
16080
16081
16082 static PyObject *_wrap_DC_SetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16083 PyObject *resultobj;
16084 wxDC *arg1 = (wxDC *) 0 ;
16085 int arg2 ;
16086 PyObject * obj0 = 0 ;
16087 PyObject * obj1 = 0 ;
16088 char *kwnames[] = {
16089 (char *) "self",(char *) "mode", NULL
16090 };
16091
16092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetMapMode",kwnames,&obj0,&obj1)) goto fail;
16093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16094 if (SWIG_arg_fail(1)) SWIG_fail;
16095 {
16096 arg2 = (int)(SWIG_As_int(obj1));
16097 if (SWIG_arg_fail(2)) SWIG_fail;
16098 }
16099 {
16100 PyThreadState* __tstate = wxPyBeginAllowThreads();
16101 (arg1)->SetMapMode(arg2);
16102
16103 wxPyEndAllowThreads(__tstate);
16104 if (PyErr_Occurred()) SWIG_fail;
16105 }
16106 Py_INCREF(Py_None); resultobj = Py_None;
16107 return resultobj;
16108 fail:
16109 return NULL;
16110 }
16111
16112
16113 static PyObject *_wrap_DC_GetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16114 PyObject *resultobj;
16115 wxDC *arg1 = (wxDC *) 0 ;
16116 double *arg2 = (double *) 0 ;
16117 double *arg3 = (double *) 0 ;
16118 double temp2 ;
16119 int res2 = 0 ;
16120 double temp3 ;
16121 int res3 = 0 ;
16122 PyObject * obj0 = 0 ;
16123 char *kwnames[] = {
16124 (char *) "self", NULL
16125 };
16126
16127 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16128 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetUserScale",kwnames,&obj0)) goto fail;
16130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16131 if (SWIG_arg_fail(1)) SWIG_fail;
16132 {
16133 PyThreadState* __tstate = wxPyBeginAllowThreads();
16134 ((wxDC const *)arg1)->GetUserScale(arg2,arg3);
16135
16136 wxPyEndAllowThreads(__tstate);
16137 if (PyErr_Occurred()) SWIG_fail;
16138 }
16139 Py_INCREF(Py_None); resultobj = Py_None;
16140 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16141 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16142 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16143 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16144 return resultobj;
16145 fail:
16146 return NULL;
16147 }
16148
16149
16150 static PyObject *_wrap_DC_SetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16151 PyObject *resultobj;
16152 wxDC *arg1 = (wxDC *) 0 ;
16153 double arg2 ;
16154 double arg3 ;
16155 PyObject * obj0 = 0 ;
16156 PyObject * obj1 = 0 ;
16157 PyObject * obj2 = 0 ;
16158 char *kwnames[] = {
16159 (char *) "self",(char *) "x",(char *) "y", NULL
16160 };
16161
16162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetUserScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16164 if (SWIG_arg_fail(1)) SWIG_fail;
16165 {
16166 arg2 = (double)(SWIG_As_double(obj1));
16167 if (SWIG_arg_fail(2)) SWIG_fail;
16168 }
16169 {
16170 arg3 = (double)(SWIG_As_double(obj2));
16171 if (SWIG_arg_fail(3)) SWIG_fail;
16172 }
16173 {
16174 PyThreadState* __tstate = wxPyBeginAllowThreads();
16175 (arg1)->SetUserScale(arg2,arg3);
16176
16177 wxPyEndAllowThreads(__tstate);
16178 if (PyErr_Occurred()) SWIG_fail;
16179 }
16180 Py_INCREF(Py_None); resultobj = Py_None;
16181 return resultobj;
16182 fail:
16183 return NULL;
16184 }
16185
16186
16187 static PyObject *_wrap_DC_GetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16188 PyObject *resultobj;
16189 wxDC *arg1 = (wxDC *) 0 ;
16190 double *arg2 = (double *) 0 ;
16191 double *arg3 = (double *) 0 ;
16192 double temp2 ;
16193 int res2 = 0 ;
16194 double temp3 ;
16195 int res3 = 0 ;
16196 PyObject * obj0 = 0 ;
16197 char *kwnames[] = {
16198 (char *) "self", NULL
16199 };
16200
16201 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16202 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalScale",kwnames,&obj0)) goto fail;
16204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16205 if (SWIG_arg_fail(1)) SWIG_fail;
16206 {
16207 PyThreadState* __tstate = wxPyBeginAllowThreads();
16208 (arg1)->GetLogicalScale(arg2,arg3);
16209
16210 wxPyEndAllowThreads(__tstate);
16211 if (PyErr_Occurred()) SWIG_fail;
16212 }
16213 Py_INCREF(Py_None); resultobj = Py_None;
16214 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16215 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16216 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16217 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16218 return resultobj;
16219 fail:
16220 return NULL;
16221 }
16222
16223
16224 static PyObject *_wrap_DC_SetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16225 PyObject *resultobj;
16226 wxDC *arg1 = (wxDC *) 0 ;
16227 double arg2 ;
16228 double arg3 ;
16229 PyObject * obj0 = 0 ;
16230 PyObject * obj1 = 0 ;
16231 PyObject * obj2 = 0 ;
16232 char *kwnames[] = {
16233 (char *) "self",(char *) "x",(char *) "y", NULL
16234 };
16235
16236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16238 if (SWIG_arg_fail(1)) SWIG_fail;
16239 {
16240 arg2 = (double)(SWIG_As_double(obj1));
16241 if (SWIG_arg_fail(2)) SWIG_fail;
16242 }
16243 {
16244 arg3 = (double)(SWIG_As_double(obj2));
16245 if (SWIG_arg_fail(3)) SWIG_fail;
16246 }
16247 {
16248 PyThreadState* __tstate = wxPyBeginAllowThreads();
16249 (arg1)->SetLogicalScale(arg2,arg3);
16250
16251 wxPyEndAllowThreads(__tstate);
16252 if (PyErr_Occurred()) SWIG_fail;
16253 }
16254 Py_INCREF(Py_None); resultobj = Py_None;
16255 return resultobj;
16256 fail:
16257 return NULL;
16258 }
16259
16260
16261 static PyObject *_wrap_DC_GetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16262 PyObject *resultobj;
16263 wxDC *arg1 = (wxDC *) 0 ;
16264 wxPoint result;
16265 PyObject * obj0 = 0 ;
16266 char *kwnames[] = {
16267 (char *) "self", NULL
16268 };
16269
16270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOrigin",kwnames,&obj0)) goto fail;
16271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16272 if (SWIG_arg_fail(1)) SWIG_fail;
16273 {
16274 PyThreadState* __tstate = wxPyBeginAllowThreads();
16275 result = ((wxDC const *)arg1)->GetLogicalOrigin();
16276
16277 wxPyEndAllowThreads(__tstate);
16278 if (PyErr_Occurred()) SWIG_fail;
16279 }
16280 {
16281 wxPoint * resultptr;
16282 resultptr = new wxPoint((wxPoint &)(result));
16283 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16284 }
16285 return resultobj;
16286 fail:
16287 return NULL;
16288 }
16289
16290
16291 static PyObject *_wrap_DC_GetLogicalOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16292 PyObject *resultobj;
16293 wxDC *arg1 = (wxDC *) 0 ;
16294 int *arg2 = (int *) 0 ;
16295 int *arg3 = (int *) 0 ;
16296 int temp2 ;
16297 int res2 = 0 ;
16298 int temp3 ;
16299 int res3 = 0 ;
16300 PyObject * obj0 = 0 ;
16301 char *kwnames[] = {
16302 (char *) "self", NULL
16303 };
16304
16305 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16306 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOriginTuple",kwnames,&obj0)) goto fail;
16308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16309 if (SWIG_arg_fail(1)) SWIG_fail;
16310 {
16311 PyThreadState* __tstate = wxPyBeginAllowThreads();
16312 ((wxDC const *)arg1)->GetLogicalOrigin(arg2,arg3);
16313
16314 wxPyEndAllowThreads(__tstate);
16315 if (PyErr_Occurred()) SWIG_fail;
16316 }
16317 Py_INCREF(Py_None); resultobj = Py_None;
16318 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16319 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16320 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16321 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16322 return resultobj;
16323 fail:
16324 return NULL;
16325 }
16326
16327
16328 static PyObject *_wrap_DC_SetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16329 PyObject *resultobj;
16330 wxDC *arg1 = (wxDC *) 0 ;
16331 int arg2 ;
16332 int arg3 ;
16333 PyObject * obj0 = 0 ;
16334 PyObject * obj1 = 0 ;
16335 PyObject * obj2 = 0 ;
16336 char *kwnames[] = {
16337 (char *) "self",(char *) "x",(char *) "y", NULL
16338 };
16339
16340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
16341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16342 if (SWIG_arg_fail(1)) SWIG_fail;
16343 {
16344 arg2 = (int)(SWIG_As_int(obj1));
16345 if (SWIG_arg_fail(2)) SWIG_fail;
16346 }
16347 {
16348 arg3 = (int)(SWIG_As_int(obj2));
16349 if (SWIG_arg_fail(3)) SWIG_fail;
16350 }
16351 {
16352 PyThreadState* __tstate = wxPyBeginAllowThreads();
16353 (arg1)->SetLogicalOrigin(arg2,arg3);
16354
16355 wxPyEndAllowThreads(__tstate);
16356 if (PyErr_Occurred()) SWIG_fail;
16357 }
16358 Py_INCREF(Py_None); resultobj = Py_None;
16359 return resultobj;
16360 fail:
16361 return NULL;
16362 }
16363
16364
16365 static PyObject *_wrap_DC_SetLogicalOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16366 PyObject *resultobj;
16367 wxDC *arg1 = (wxDC *) 0 ;
16368 wxPoint *arg2 = 0 ;
16369 wxPoint temp2 ;
16370 PyObject * obj0 = 0 ;
16371 PyObject * obj1 = 0 ;
16372 char *kwnames[] = {
16373 (char *) "self",(char *) "point", NULL
16374 };
16375
16376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalOriginPoint",kwnames,&obj0,&obj1)) goto fail;
16377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16378 if (SWIG_arg_fail(1)) SWIG_fail;
16379 {
16380 arg2 = &temp2;
16381 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16382 }
16383 {
16384 PyThreadState* __tstate = wxPyBeginAllowThreads();
16385 wxDC_SetLogicalOriginPoint(arg1,(wxPoint const &)*arg2);
16386
16387 wxPyEndAllowThreads(__tstate);
16388 if (PyErr_Occurred()) SWIG_fail;
16389 }
16390 Py_INCREF(Py_None); resultobj = Py_None;
16391 return resultobj;
16392 fail:
16393 return NULL;
16394 }
16395
16396
16397 static PyObject *_wrap_DC_GetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16398 PyObject *resultobj;
16399 wxDC *arg1 = (wxDC *) 0 ;
16400 wxPoint result;
16401 PyObject * obj0 = 0 ;
16402 char *kwnames[] = {
16403 (char *) "self", NULL
16404 };
16405
16406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOrigin",kwnames,&obj0)) goto fail;
16407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16408 if (SWIG_arg_fail(1)) SWIG_fail;
16409 {
16410 PyThreadState* __tstate = wxPyBeginAllowThreads();
16411 result = ((wxDC const *)arg1)->GetDeviceOrigin();
16412
16413 wxPyEndAllowThreads(__tstate);
16414 if (PyErr_Occurred()) SWIG_fail;
16415 }
16416 {
16417 wxPoint * resultptr;
16418 resultptr = new wxPoint((wxPoint &)(result));
16419 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16420 }
16421 return resultobj;
16422 fail:
16423 return NULL;
16424 }
16425
16426
16427 static PyObject *_wrap_DC_GetDeviceOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16428 PyObject *resultobj;
16429 wxDC *arg1 = (wxDC *) 0 ;
16430 int *arg2 = (int *) 0 ;
16431 int *arg3 = (int *) 0 ;
16432 int temp2 ;
16433 int res2 = 0 ;
16434 int temp3 ;
16435 int res3 = 0 ;
16436 PyObject * obj0 = 0 ;
16437 char *kwnames[] = {
16438 (char *) "self", NULL
16439 };
16440
16441 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16442 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOriginTuple",kwnames,&obj0)) goto fail;
16444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16445 if (SWIG_arg_fail(1)) SWIG_fail;
16446 {
16447 PyThreadState* __tstate = wxPyBeginAllowThreads();
16448 ((wxDC const *)arg1)->GetDeviceOrigin(arg2,arg3);
16449
16450 wxPyEndAllowThreads(__tstate);
16451 if (PyErr_Occurred()) SWIG_fail;
16452 }
16453 Py_INCREF(Py_None); resultobj = Py_None;
16454 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16455 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16456 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16457 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16458 return resultobj;
16459 fail:
16460 return NULL;
16461 }
16462
16463
16464 static PyObject *_wrap_DC_SetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16465 PyObject *resultobj;
16466 wxDC *arg1 = (wxDC *) 0 ;
16467 int arg2 ;
16468 int arg3 ;
16469 PyObject * obj0 = 0 ;
16470 PyObject * obj1 = 0 ;
16471 PyObject * obj2 = 0 ;
16472 char *kwnames[] = {
16473 (char *) "self",(char *) "x",(char *) "y", NULL
16474 };
16475
16476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetDeviceOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
16477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16478 if (SWIG_arg_fail(1)) SWIG_fail;
16479 {
16480 arg2 = (int)(SWIG_As_int(obj1));
16481 if (SWIG_arg_fail(2)) SWIG_fail;
16482 }
16483 {
16484 arg3 = (int)(SWIG_As_int(obj2));
16485 if (SWIG_arg_fail(3)) SWIG_fail;
16486 }
16487 {
16488 PyThreadState* __tstate = wxPyBeginAllowThreads();
16489 (arg1)->SetDeviceOrigin(arg2,arg3);
16490
16491 wxPyEndAllowThreads(__tstate);
16492 if (PyErr_Occurred()) SWIG_fail;
16493 }
16494 Py_INCREF(Py_None); resultobj = Py_None;
16495 return resultobj;
16496 fail:
16497 return NULL;
16498 }
16499
16500
16501 static PyObject *_wrap_DC_SetDeviceOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16502 PyObject *resultobj;
16503 wxDC *arg1 = (wxDC *) 0 ;
16504 wxPoint *arg2 = 0 ;
16505 wxPoint temp2 ;
16506 PyObject * obj0 = 0 ;
16507 PyObject * obj1 = 0 ;
16508 char *kwnames[] = {
16509 (char *) "self",(char *) "point", NULL
16510 };
16511
16512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetDeviceOriginPoint",kwnames,&obj0,&obj1)) goto fail;
16513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16514 if (SWIG_arg_fail(1)) SWIG_fail;
16515 {
16516 arg2 = &temp2;
16517 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16518 }
16519 {
16520 PyThreadState* __tstate = wxPyBeginAllowThreads();
16521 wxDC_SetDeviceOriginPoint(arg1,(wxPoint const &)*arg2);
16522
16523 wxPyEndAllowThreads(__tstate);
16524 if (PyErr_Occurred()) SWIG_fail;
16525 }
16526 Py_INCREF(Py_None); resultobj = Py_None;
16527 return resultobj;
16528 fail:
16529 return NULL;
16530 }
16531
16532
16533 static PyObject *_wrap_DC_SetAxisOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16534 PyObject *resultobj;
16535 wxDC *arg1 = (wxDC *) 0 ;
16536 bool arg2 ;
16537 bool arg3 ;
16538 PyObject * obj0 = 0 ;
16539 PyObject * obj1 = 0 ;
16540 PyObject * obj2 = 0 ;
16541 char *kwnames[] = {
16542 (char *) "self",(char *) "xLeftRight",(char *) "yBottomUp", NULL
16543 };
16544
16545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetAxisOrientation",kwnames,&obj0,&obj1,&obj2)) goto fail;
16546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16547 if (SWIG_arg_fail(1)) SWIG_fail;
16548 {
16549 arg2 = (bool)(SWIG_As_bool(obj1));
16550 if (SWIG_arg_fail(2)) SWIG_fail;
16551 }
16552 {
16553 arg3 = (bool)(SWIG_As_bool(obj2));
16554 if (SWIG_arg_fail(3)) SWIG_fail;
16555 }
16556 {
16557 PyThreadState* __tstate = wxPyBeginAllowThreads();
16558 (arg1)->SetAxisOrientation(arg2,arg3);
16559
16560 wxPyEndAllowThreads(__tstate);
16561 if (PyErr_Occurred()) SWIG_fail;
16562 }
16563 Py_INCREF(Py_None); resultobj = Py_None;
16564 return resultobj;
16565 fail:
16566 return NULL;
16567 }
16568
16569
16570 static PyObject *_wrap_DC_GetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
16571 PyObject *resultobj;
16572 wxDC *arg1 = (wxDC *) 0 ;
16573 int result;
16574 PyObject * obj0 = 0 ;
16575 char *kwnames[] = {
16576 (char *) "self", NULL
16577 };
16578
16579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalFunction",kwnames,&obj0)) goto fail;
16580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16581 if (SWIG_arg_fail(1)) SWIG_fail;
16582 {
16583 PyThreadState* __tstate = wxPyBeginAllowThreads();
16584 result = (int)((wxDC const *)arg1)->GetLogicalFunction();
16585
16586 wxPyEndAllowThreads(__tstate);
16587 if (PyErr_Occurred()) SWIG_fail;
16588 }
16589 {
16590 resultobj = SWIG_From_int((int)(result));
16591 }
16592 return resultobj;
16593 fail:
16594 return NULL;
16595 }
16596
16597
16598 static PyObject *_wrap_DC_SetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
16599 PyObject *resultobj;
16600 wxDC *arg1 = (wxDC *) 0 ;
16601 int arg2 ;
16602 PyObject * obj0 = 0 ;
16603 PyObject * obj1 = 0 ;
16604 char *kwnames[] = {
16605 (char *) "self",(char *) "function", NULL
16606 };
16607
16608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalFunction",kwnames,&obj0,&obj1)) goto fail;
16609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16610 if (SWIG_arg_fail(1)) SWIG_fail;
16611 {
16612 arg2 = (int)(SWIG_As_int(obj1));
16613 if (SWIG_arg_fail(2)) SWIG_fail;
16614 }
16615 {
16616 PyThreadState* __tstate = wxPyBeginAllowThreads();
16617 (arg1)->SetLogicalFunction(arg2);
16618
16619 wxPyEndAllowThreads(__tstate);
16620 if (PyErr_Occurred()) SWIG_fail;
16621 }
16622 Py_INCREF(Py_None); resultobj = Py_None;
16623 return resultobj;
16624 fail:
16625 return NULL;
16626 }
16627
16628
16629 static PyObject *_wrap_DC_ComputeScaleAndOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16630 PyObject *resultobj;
16631 wxDC *arg1 = (wxDC *) 0 ;
16632 PyObject * obj0 = 0 ;
16633 char *kwnames[] = {
16634 (char *) "self", NULL
16635 };
16636
16637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ComputeScaleAndOrigin",kwnames,&obj0)) goto fail;
16638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16639 if (SWIG_arg_fail(1)) SWIG_fail;
16640 {
16641 PyThreadState* __tstate = wxPyBeginAllowThreads();
16642 (arg1)->ComputeScaleAndOrigin();
16643
16644 wxPyEndAllowThreads(__tstate);
16645 if (PyErr_Occurred()) SWIG_fail;
16646 }
16647 Py_INCREF(Py_None); resultobj = Py_None;
16648 return resultobj;
16649 fail:
16650 return NULL;
16651 }
16652
16653
16654 static PyObject *_wrap_DC_CalcBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16655 PyObject *resultobj;
16656 wxDC *arg1 = (wxDC *) 0 ;
16657 int arg2 ;
16658 int arg3 ;
16659 PyObject * obj0 = 0 ;
16660 PyObject * obj1 = 0 ;
16661 PyObject * obj2 = 0 ;
16662 char *kwnames[] = {
16663 (char *) "self",(char *) "x",(char *) "y", NULL
16664 };
16665
16666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CalcBoundingBox",kwnames,&obj0,&obj1,&obj2)) goto fail;
16667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16668 if (SWIG_arg_fail(1)) SWIG_fail;
16669 {
16670 arg2 = (int)(SWIG_As_int(obj1));
16671 if (SWIG_arg_fail(2)) SWIG_fail;
16672 }
16673 {
16674 arg3 = (int)(SWIG_As_int(obj2));
16675 if (SWIG_arg_fail(3)) SWIG_fail;
16676 }
16677 {
16678 PyThreadState* __tstate = wxPyBeginAllowThreads();
16679 (arg1)->CalcBoundingBox(arg2,arg3);
16680
16681 wxPyEndAllowThreads(__tstate);
16682 if (PyErr_Occurred()) SWIG_fail;
16683 }
16684 Py_INCREF(Py_None); resultobj = Py_None;
16685 return resultobj;
16686 fail:
16687 return NULL;
16688 }
16689
16690
16691 static PyObject *_wrap_DC_CalcBoundingBoxPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16692 PyObject *resultobj;
16693 wxDC *arg1 = (wxDC *) 0 ;
16694 wxPoint *arg2 = 0 ;
16695 wxPoint temp2 ;
16696 PyObject * obj0 = 0 ;
16697 PyObject * obj1 = 0 ;
16698 char *kwnames[] = {
16699 (char *) "self",(char *) "point", NULL
16700 };
16701
16702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CalcBoundingBoxPoint",kwnames,&obj0,&obj1)) goto fail;
16703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16704 if (SWIG_arg_fail(1)) SWIG_fail;
16705 {
16706 arg2 = &temp2;
16707 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16708 }
16709 {
16710 PyThreadState* __tstate = wxPyBeginAllowThreads();
16711 wxDC_CalcBoundingBoxPoint(arg1,(wxPoint const &)*arg2);
16712
16713 wxPyEndAllowThreads(__tstate);
16714 if (PyErr_Occurred()) SWIG_fail;
16715 }
16716 Py_INCREF(Py_None); resultobj = Py_None;
16717 return resultobj;
16718 fail:
16719 return NULL;
16720 }
16721
16722
16723 static PyObject *_wrap_DC_ResetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16724 PyObject *resultobj;
16725 wxDC *arg1 = (wxDC *) 0 ;
16726 PyObject * obj0 = 0 ;
16727 char *kwnames[] = {
16728 (char *) "self", NULL
16729 };
16730
16731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ResetBoundingBox",kwnames,&obj0)) goto fail;
16732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16733 if (SWIG_arg_fail(1)) SWIG_fail;
16734 {
16735 PyThreadState* __tstate = wxPyBeginAllowThreads();
16736 (arg1)->ResetBoundingBox();
16737
16738 wxPyEndAllowThreads(__tstate);
16739 if (PyErr_Occurred()) SWIG_fail;
16740 }
16741 Py_INCREF(Py_None); resultobj = Py_None;
16742 return resultobj;
16743 fail:
16744 return NULL;
16745 }
16746
16747
16748 static PyObject *_wrap_DC_MinX(PyObject *, PyObject *args, PyObject *kwargs) {
16749 PyObject *resultobj;
16750 wxDC *arg1 = (wxDC *) 0 ;
16751 int result;
16752 PyObject * obj0 = 0 ;
16753 char *kwnames[] = {
16754 (char *) "self", NULL
16755 };
16756
16757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinX",kwnames,&obj0)) goto fail;
16758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16759 if (SWIG_arg_fail(1)) SWIG_fail;
16760 {
16761 PyThreadState* __tstate = wxPyBeginAllowThreads();
16762 result = (int)((wxDC const *)arg1)->MinX();
16763
16764 wxPyEndAllowThreads(__tstate);
16765 if (PyErr_Occurred()) SWIG_fail;
16766 }
16767 {
16768 resultobj = SWIG_From_int((int)(result));
16769 }
16770 return resultobj;
16771 fail:
16772 return NULL;
16773 }
16774
16775
16776 static PyObject *_wrap_DC_MaxX(PyObject *, PyObject *args, PyObject *kwargs) {
16777 PyObject *resultobj;
16778 wxDC *arg1 = (wxDC *) 0 ;
16779 int result;
16780 PyObject * obj0 = 0 ;
16781 char *kwnames[] = {
16782 (char *) "self", NULL
16783 };
16784
16785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxX",kwnames,&obj0)) goto fail;
16786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16787 if (SWIG_arg_fail(1)) SWIG_fail;
16788 {
16789 PyThreadState* __tstate = wxPyBeginAllowThreads();
16790 result = (int)((wxDC const *)arg1)->MaxX();
16791
16792 wxPyEndAllowThreads(__tstate);
16793 if (PyErr_Occurred()) SWIG_fail;
16794 }
16795 {
16796 resultobj = SWIG_From_int((int)(result));
16797 }
16798 return resultobj;
16799 fail:
16800 return NULL;
16801 }
16802
16803
16804 static PyObject *_wrap_DC_MinY(PyObject *, PyObject *args, PyObject *kwargs) {
16805 PyObject *resultobj;
16806 wxDC *arg1 = (wxDC *) 0 ;
16807 int result;
16808 PyObject * obj0 = 0 ;
16809 char *kwnames[] = {
16810 (char *) "self", NULL
16811 };
16812
16813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinY",kwnames,&obj0)) goto fail;
16814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16815 if (SWIG_arg_fail(1)) SWIG_fail;
16816 {
16817 PyThreadState* __tstate = wxPyBeginAllowThreads();
16818 result = (int)((wxDC const *)arg1)->MinY();
16819
16820 wxPyEndAllowThreads(__tstate);
16821 if (PyErr_Occurred()) SWIG_fail;
16822 }
16823 {
16824 resultobj = SWIG_From_int((int)(result));
16825 }
16826 return resultobj;
16827 fail:
16828 return NULL;
16829 }
16830
16831
16832 static PyObject *_wrap_DC_MaxY(PyObject *, PyObject *args, PyObject *kwargs) {
16833 PyObject *resultobj;
16834 wxDC *arg1 = (wxDC *) 0 ;
16835 int result;
16836 PyObject * obj0 = 0 ;
16837 char *kwnames[] = {
16838 (char *) "self", NULL
16839 };
16840
16841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxY",kwnames,&obj0)) goto fail;
16842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16843 if (SWIG_arg_fail(1)) SWIG_fail;
16844 {
16845 PyThreadState* __tstate = wxPyBeginAllowThreads();
16846 result = (int)((wxDC const *)arg1)->MaxY();
16847
16848 wxPyEndAllowThreads(__tstate);
16849 if (PyErr_Occurred()) SWIG_fail;
16850 }
16851 {
16852 resultobj = SWIG_From_int((int)(result));
16853 }
16854 return resultobj;
16855 fail:
16856 return NULL;
16857 }
16858
16859
16860 static PyObject *_wrap_DC_GetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16861 PyObject *resultobj;
16862 wxDC *arg1 = (wxDC *) 0 ;
16863 int *arg2 = (int *) 0 ;
16864 int *arg3 = (int *) 0 ;
16865 int *arg4 = (int *) 0 ;
16866 int *arg5 = (int *) 0 ;
16867 int temp2 ;
16868 int res2 = 0 ;
16869 int temp3 ;
16870 int res3 = 0 ;
16871 int temp4 ;
16872 int res4 = 0 ;
16873 int temp5 ;
16874 int res5 = 0 ;
16875 PyObject * obj0 = 0 ;
16876 char *kwnames[] = {
16877 (char *) "self", NULL
16878 };
16879
16880 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16881 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16882 arg4 = &temp4; res4 = SWIG_NEWOBJ;
16883 arg5 = &temp5; res5 = SWIG_NEWOBJ;
16884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBoundingBox",kwnames,&obj0)) goto fail;
16885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16886 if (SWIG_arg_fail(1)) SWIG_fail;
16887 {
16888 PyThreadState* __tstate = wxPyBeginAllowThreads();
16889 wxDC_GetBoundingBox(arg1,arg2,arg3,arg4,arg5);
16890
16891 wxPyEndAllowThreads(__tstate);
16892 if (PyErr_Occurred()) SWIG_fail;
16893 }
16894 Py_INCREF(Py_None); resultobj = Py_None;
16895 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16896 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16897 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16898 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16899 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
16900 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
16901 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
16902 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
16903 return resultobj;
16904 fail:
16905 return NULL;
16906 }
16907
16908
16909 static PyObject *_wrap_DC__DrawPointList(PyObject *, PyObject *args, PyObject *kwargs) {
16910 PyObject *resultobj;
16911 wxDC *arg1 = (wxDC *) 0 ;
16912 PyObject *arg2 = (PyObject *) 0 ;
16913 PyObject *arg3 = (PyObject *) 0 ;
16914 PyObject *arg4 = (PyObject *) 0 ;
16915 PyObject *result;
16916 PyObject * obj0 = 0 ;
16917 PyObject * obj1 = 0 ;
16918 PyObject * obj2 = 0 ;
16919 PyObject * obj3 = 0 ;
16920 char *kwnames[] = {
16921 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
16922 };
16923
16924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPointList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16926 if (SWIG_arg_fail(1)) SWIG_fail;
16927 arg2 = obj1;
16928 arg3 = obj2;
16929 arg4 = obj3;
16930 {
16931 PyThreadState* __tstate = wxPyBeginAllowThreads();
16932 result = (PyObject *)wxDC__DrawPointList(arg1,arg2,arg3,arg4);
16933
16934 wxPyEndAllowThreads(__tstate);
16935 if (PyErr_Occurred()) SWIG_fail;
16936 }
16937 resultobj = result;
16938 return resultobj;
16939 fail:
16940 return NULL;
16941 }
16942
16943
16944 static PyObject *_wrap_DC__DrawLineList(PyObject *, PyObject *args, PyObject *kwargs) {
16945 PyObject *resultobj;
16946 wxDC *arg1 = (wxDC *) 0 ;
16947 PyObject *arg2 = (PyObject *) 0 ;
16948 PyObject *arg3 = (PyObject *) 0 ;
16949 PyObject *arg4 = (PyObject *) 0 ;
16950 PyObject *result;
16951 PyObject * obj0 = 0 ;
16952 PyObject * obj1 = 0 ;
16953 PyObject * obj2 = 0 ;
16954 PyObject * obj3 = 0 ;
16955 char *kwnames[] = {
16956 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
16957 };
16958
16959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawLineList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16961 if (SWIG_arg_fail(1)) SWIG_fail;
16962 arg2 = obj1;
16963 arg3 = obj2;
16964 arg4 = obj3;
16965 {
16966 PyThreadState* __tstate = wxPyBeginAllowThreads();
16967 result = (PyObject *)wxDC__DrawLineList(arg1,arg2,arg3,arg4);
16968
16969 wxPyEndAllowThreads(__tstate);
16970 if (PyErr_Occurred()) SWIG_fail;
16971 }
16972 resultobj = result;
16973 return resultobj;
16974 fail:
16975 return NULL;
16976 }
16977
16978
16979 static PyObject *_wrap_DC__DrawRectangleList(PyObject *, PyObject *args, PyObject *kwargs) {
16980 PyObject *resultobj;
16981 wxDC *arg1 = (wxDC *) 0 ;
16982 PyObject *arg2 = (PyObject *) 0 ;
16983 PyObject *arg3 = (PyObject *) 0 ;
16984 PyObject *arg4 = (PyObject *) 0 ;
16985 PyObject *result;
16986 PyObject * obj0 = 0 ;
16987 PyObject * obj1 = 0 ;
16988 PyObject * obj2 = 0 ;
16989 PyObject * obj3 = 0 ;
16990 char *kwnames[] = {
16991 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
16992 };
16993
16994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawRectangleList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16996 if (SWIG_arg_fail(1)) SWIG_fail;
16997 arg2 = obj1;
16998 arg3 = obj2;
16999 arg4 = obj3;
17000 {
17001 PyThreadState* __tstate = wxPyBeginAllowThreads();
17002 result = (PyObject *)wxDC__DrawRectangleList(arg1,arg2,arg3,arg4);
17003
17004 wxPyEndAllowThreads(__tstate);
17005 if (PyErr_Occurred()) SWIG_fail;
17006 }
17007 resultobj = result;
17008 return resultobj;
17009 fail:
17010 return NULL;
17011 }
17012
17013
17014 static PyObject *_wrap_DC__DrawEllipseList(PyObject *, PyObject *args, PyObject *kwargs) {
17015 PyObject *resultobj;
17016 wxDC *arg1 = (wxDC *) 0 ;
17017 PyObject *arg2 = (PyObject *) 0 ;
17018 PyObject *arg3 = (PyObject *) 0 ;
17019 PyObject *arg4 = (PyObject *) 0 ;
17020 PyObject *result;
17021 PyObject * obj0 = 0 ;
17022 PyObject * obj1 = 0 ;
17023 PyObject * obj2 = 0 ;
17024 PyObject * obj3 = 0 ;
17025 char *kwnames[] = {
17026 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17027 };
17028
17029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawEllipseList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17031 if (SWIG_arg_fail(1)) SWIG_fail;
17032 arg2 = obj1;
17033 arg3 = obj2;
17034 arg4 = obj3;
17035 {
17036 PyThreadState* __tstate = wxPyBeginAllowThreads();
17037 result = (PyObject *)wxDC__DrawEllipseList(arg1,arg2,arg3,arg4);
17038
17039 wxPyEndAllowThreads(__tstate);
17040 if (PyErr_Occurred()) SWIG_fail;
17041 }
17042 resultobj = result;
17043 return resultobj;
17044 fail:
17045 return NULL;
17046 }
17047
17048
17049 static PyObject *_wrap_DC__DrawPolygonList(PyObject *, PyObject *args, PyObject *kwargs) {
17050 PyObject *resultobj;
17051 wxDC *arg1 = (wxDC *) 0 ;
17052 PyObject *arg2 = (PyObject *) 0 ;
17053 PyObject *arg3 = (PyObject *) 0 ;
17054 PyObject *arg4 = (PyObject *) 0 ;
17055 PyObject *result;
17056 PyObject * obj0 = 0 ;
17057 PyObject * obj1 = 0 ;
17058 PyObject * obj2 = 0 ;
17059 PyObject * obj3 = 0 ;
17060 char *kwnames[] = {
17061 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17062 };
17063
17064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPolygonList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17066 if (SWIG_arg_fail(1)) SWIG_fail;
17067 arg2 = obj1;
17068 arg3 = obj2;
17069 arg4 = obj3;
17070 {
17071 PyThreadState* __tstate = wxPyBeginAllowThreads();
17072 result = (PyObject *)wxDC__DrawPolygonList(arg1,arg2,arg3,arg4);
17073
17074 wxPyEndAllowThreads(__tstate);
17075 if (PyErr_Occurred()) SWIG_fail;
17076 }
17077 resultobj = result;
17078 return resultobj;
17079 fail:
17080 return NULL;
17081 }
17082
17083
17084 static PyObject *_wrap_DC__DrawTextList(PyObject *, PyObject *args, PyObject *kwargs) {
17085 PyObject *resultobj;
17086 wxDC *arg1 = (wxDC *) 0 ;
17087 PyObject *arg2 = (PyObject *) 0 ;
17088 PyObject *arg3 = (PyObject *) 0 ;
17089 PyObject *arg4 = (PyObject *) 0 ;
17090 PyObject *arg5 = (PyObject *) 0 ;
17091 PyObject *result;
17092 PyObject * obj0 = 0 ;
17093 PyObject * obj1 = 0 ;
17094 PyObject * obj2 = 0 ;
17095 PyObject * obj3 = 0 ;
17096 PyObject * obj4 = 0 ;
17097 char *kwnames[] = {
17098 (char *) "self",(char *) "textList",(char *) "pyPoints",(char *) "foregroundList",(char *) "backgroundList", NULL
17099 };
17100
17101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC__DrawTextList",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
17102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17103 if (SWIG_arg_fail(1)) SWIG_fail;
17104 arg2 = obj1;
17105 arg3 = obj2;
17106 arg4 = obj3;
17107 arg5 = obj4;
17108 {
17109 PyThreadState* __tstate = wxPyBeginAllowThreads();
17110 result = (PyObject *)wxDC__DrawTextList(arg1,arg2,arg3,arg4,arg5);
17111
17112 wxPyEndAllowThreads(__tstate);
17113 if (PyErr_Occurred()) SWIG_fail;
17114 }
17115 resultobj = result;
17116 return resultobj;
17117 fail:
17118 return NULL;
17119 }
17120
17121
17122 static PyObject * DC_swigregister(PyObject *, PyObject *args) {
17123 PyObject *obj;
17124 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17125 SWIG_TypeClientData(SWIGTYPE_p_wxDC, obj);
17126 Py_INCREF(obj);
17127 return Py_BuildValue((char *)"");
17128 }
17129 static PyObject *_wrap_new_MemoryDC(PyObject *, PyObject *args, PyObject *kwargs) {
17130 PyObject *resultobj;
17131 wxMemoryDC *result;
17132 char *kwnames[] = {
17133 NULL
17134 };
17135
17136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryDC",kwnames)) goto fail;
17137 {
17138 if (!wxPyCheckForApp()) SWIG_fail;
17139 PyThreadState* __tstate = wxPyBeginAllowThreads();
17140 result = (wxMemoryDC *)new wxMemoryDC();
17141
17142 wxPyEndAllowThreads(__tstate);
17143 if (PyErr_Occurred()) SWIG_fail;
17144 }
17145 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17146 return resultobj;
17147 fail:
17148 return NULL;
17149 }
17150
17151
17152 static PyObject *_wrap_new_MemoryDCFromDC(PyObject *, PyObject *args, PyObject *kwargs) {
17153 PyObject *resultobj;
17154 wxDC *arg1 = (wxDC *) 0 ;
17155 wxMemoryDC *result;
17156 PyObject * obj0 = 0 ;
17157 char *kwnames[] = {
17158 (char *) "oldDC", NULL
17159 };
17160
17161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_MemoryDCFromDC",kwnames,&obj0)) goto fail;
17162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17163 if (SWIG_arg_fail(1)) SWIG_fail;
17164 {
17165 if (!wxPyCheckForApp()) SWIG_fail;
17166 PyThreadState* __tstate = wxPyBeginAllowThreads();
17167 result = (wxMemoryDC *)new wxMemoryDC(arg1);
17168
17169 wxPyEndAllowThreads(__tstate);
17170 if (PyErr_Occurred()) SWIG_fail;
17171 }
17172 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17173 return resultobj;
17174 fail:
17175 return NULL;
17176 }
17177
17178
17179 static PyObject *_wrap_MemoryDC_SelectObject(PyObject *, PyObject *args, PyObject *kwargs) {
17180 PyObject *resultobj;
17181 wxMemoryDC *arg1 = (wxMemoryDC *) 0 ;
17182 wxBitmap *arg2 = 0 ;
17183 PyObject * obj0 = 0 ;
17184 PyObject * obj1 = 0 ;
17185 char *kwnames[] = {
17186 (char *) "self",(char *) "bitmap", NULL
17187 };
17188
17189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryDC_SelectObject",kwnames,&obj0,&obj1)) goto fail;
17190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryDC, SWIG_POINTER_EXCEPTION | 0);
17191 if (SWIG_arg_fail(1)) SWIG_fail;
17192 {
17193 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17194 if (SWIG_arg_fail(2)) SWIG_fail;
17195 if (arg2 == NULL) {
17196 SWIG_null_ref("wxBitmap");
17197 }
17198 if (SWIG_arg_fail(2)) SWIG_fail;
17199 }
17200 {
17201 PyThreadState* __tstate = wxPyBeginAllowThreads();
17202 (arg1)->SelectObject((wxBitmap const &)*arg2);
17203
17204 wxPyEndAllowThreads(__tstate);
17205 if (PyErr_Occurred()) SWIG_fail;
17206 }
17207 Py_INCREF(Py_None); resultobj = Py_None;
17208 return resultobj;
17209 fail:
17210 return NULL;
17211 }
17212
17213
17214 static PyObject * MemoryDC_swigregister(PyObject *, PyObject *args) {
17215 PyObject *obj;
17216 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17217 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryDC, obj);
17218 Py_INCREF(obj);
17219 return Py_BuildValue((char *)"");
17220 }
17221 static PyObject *_wrap_new_BufferedDC__SWIG_0(PyObject *, PyObject *args) {
17222 PyObject *resultobj;
17223 wxDC *arg1 = (wxDC *) 0 ;
17224 wxBitmap const &arg2_defvalue = wxNullBitmap ;
17225 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
17226 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
17227 wxBufferedDC *result;
17228 PyObject * obj0 = 0 ;
17229 PyObject * obj1 = 0 ;
17230 PyObject * obj2 = 0 ;
17231
17232 if(!PyArg_ParseTuple(args,(char *)"O|OO:new_BufferedDC",&obj0,&obj1,&obj2)) goto fail;
17233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17234 if (SWIG_arg_fail(1)) SWIG_fail;
17235 if (obj1) {
17236 {
17237 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17238 if (SWIG_arg_fail(2)) SWIG_fail;
17239 if (arg2 == NULL) {
17240 SWIG_null_ref("wxBitmap");
17241 }
17242 if (SWIG_arg_fail(2)) SWIG_fail;
17243 }
17244 }
17245 if (obj2) {
17246 {
17247 arg3 = (int)(SWIG_As_int(obj2));
17248 if (SWIG_arg_fail(3)) SWIG_fail;
17249 }
17250 }
17251 {
17252 if (!wxPyCheckForApp()) SWIG_fail;
17253 PyThreadState* __tstate = wxPyBeginAllowThreads();
17254 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxBitmap const &)*arg2,arg3);
17255
17256 wxPyEndAllowThreads(__tstate);
17257 if (PyErr_Occurred()) SWIG_fail;
17258 }
17259 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
17260 return resultobj;
17261 fail:
17262 return NULL;
17263 }
17264
17265
17266 static PyObject *_wrap_new_BufferedDC__SWIG_1(PyObject *, PyObject *args) {
17267 PyObject *resultobj;
17268 wxDC *arg1 = (wxDC *) 0 ;
17269 wxSize *arg2 = 0 ;
17270 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
17271 wxBufferedDC *result;
17272 wxSize temp2 ;
17273 PyObject * obj0 = 0 ;
17274 PyObject * obj1 = 0 ;
17275 PyObject * obj2 = 0 ;
17276
17277 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_BufferedDC",&obj0,&obj1,&obj2)) goto fail;
17278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17279 if (SWIG_arg_fail(1)) SWIG_fail;
17280 {
17281 arg2 = &temp2;
17282 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
17283 }
17284 if (obj2) {
17285 {
17286 arg3 = (int)(SWIG_As_int(obj2));
17287 if (SWIG_arg_fail(3)) SWIG_fail;
17288 }
17289 }
17290 {
17291 if (!wxPyCheckForApp()) SWIG_fail;
17292 PyThreadState* __tstate = wxPyBeginAllowThreads();
17293 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxSize const &)*arg2,arg3);
17294
17295 wxPyEndAllowThreads(__tstate);
17296 if (PyErr_Occurred()) SWIG_fail;
17297 }
17298 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
17299 return resultobj;
17300 fail:
17301 return NULL;
17302 }
17303
17304
17305 static PyObject *_wrap_new_BufferedDC(PyObject *self, PyObject *args) {
17306 int argc;
17307 PyObject *argv[4];
17308 int ii;
17309
17310 argc = PyObject_Length(args);
17311 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
17312 argv[ii] = PyTuple_GetItem(args,ii);
17313 }
17314 if ((argc >= 1) && (argc <= 3)) {
17315 int _v;
17316 {
17317 void *ptr;
17318 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
17319 _v = 0;
17320 PyErr_Clear();
17321 } else {
17322 _v = 1;
17323 }
17324 }
17325 if (_v) {
17326 if (argc <= 1) {
17327 return _wrap_new_BufferedDC__SWIG_0(self,args);
17328 }
17329 {
17330 void *ptr = 0;
17331 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxBitmap, 0) == -1) {
17332 _v = 0;
17333 PyErr_Clear();
17334 } else {
17335 _v = (ptr != 0);
17336 }
17337 }
17338 if (_v) {
17339 if (argc <= 2) {
17340 return _wrap_new_BufferedDC__SWIG_0(self,args);
17341 }
17342 _v = SWIG_Check_int(argv[2]);
17343 if (_v) {
17344 return _wrap_new_BufferedDC__SWIG_0(self,args);
17345 }
17346 }
17347 }
17348 }
17349 if ((argc >= 2) && (argc <= 3)) {
17350 int _v;
17351 {
17352 void *ptr;
17353 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
17354 _v = 0;
17355 PyErr_Clear();
17356 } else {
17357 _v = 1;
17358 }
17359 }
17360 if (_v) {
17361 {
17362 _v = wxPySimple_typecheck(argv[1], wxT("wxSize"), 2);
17363 }
17364 if (_v) {
17365 if (argc <= 2) {
17366 return _wrap_new_BufferedDC__SWIG_1(self,args);
17367 }
17368 _v = SWIG_Check_int(argv[2]);
17369 if (_v) {
17370 return _wrap_new_BufferedDC__SWIG_1(self,args);
17371 }
17372 }
17373 }
17374 }
17375
17376 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_BufferedDC'");
17377 return NULL;
17378 }
17379
17380
17381 static PyObject *_wrap_delete_BufferedDC(PyObject *, PyObject *args, PyObject *kwargs) {
17382 PyObject *resultobj;
17383 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
17384 PyObject * obj0 = 0 ;
17385 char *kwnames[] = {
17386 (char *) "self", NULL
17387 };
17388
17389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BufferedDC",kwnames,&obj0)) goto fail;
17390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
17391 if (SWIG_arg_fail(1)) SWIG_fail;
17392 {
17393 PyThreadState* __tstate = wxPyBeginAllowThreads();
17394 delete arg1;
17395
17396 wxPyEndAllowThreads(__tstate);
17397 if (PyErr_Occurred()) SWIG_fail;
17398 }
17399 Py_INCREF(Py_None); resultobj = Py_None;
17400 return resultobj;
17401 fail:
17402 return NULL;
17403 }
17404
17405
17406 static PyObject *_wrap_BufferedDC_UnMask(PyObject *, PyObject *args, PyObject *kwargs) {
17407 PyObject *resultobj;
17408 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
17409 PyObject * obj0 = 0 ;
17410 char *kwnames[] = {
17411 (char *) "self", NULL
17412 };
17413
17414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BufferedDC_UnMask",kwnames,&obj0)) goto fail;
17415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
17416 if (SWIG_arg_fail(1)) SWIG_fail;
17417 {
17418 PyThreadState* __tstate = wxPyBeginAllowThreads();
17419 (arg1)->UnMask();
17420
17421 wxPyEndAllowThreads(__tstate);
17422 if (PyErr_Occurred()) SWIG_fail;
17423 }
17424 Py_INCREF(Py_None); resultobj = Py_None;
17425 return resultobj;
17426 fail:
17427 return NULL;
17428 }
17429
17430
17431 static PyObject * BufferedDC_swigregister(PyObject *, PyObject *args) {
17432 PyObject *obj;
17433 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17434 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedDC, obj);
17435 Py_INCREF(obj);
17436 return Py_BuildValue((char *)"");
17437 }
17438 static PyObject *_wrap_new_BufferedPaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
17439 PyObject *resultobj;
17440 wxWindow *arg1 = (wxWindow *) 0 ;
17441 wxBitmap const &arg2_defvalue = wxNullBitmap ;
17442 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
17443 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
17444 wxBufferedPaintDC *result;
17445 PyObject * obj0 = 0 ;
17446 PyObject * obj1 = 0 ;
17447 PyObject * obj2 = 0 ;
17448 char *kwnames[] = {
17449 (char *) "window",(char *) "buffer",(char *) "style", NULL
17450 };
17451
17452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_BufferedPaintDC",kwnames,&obj0,&obj1,&obj2)) goto fail;
17453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17454 if (SWIG_arg_fail(1)) SWIG_fail;
17455 if (obj1) {
17456 {
17457 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17458 if (SWIG_arg_fail(2)) SWIG_fail;
17459 if (arg2 == NULL) {
17460 SWIG_null_ref("wxBitmap");
17461 }
17462 if (SWIG_arg_fail(2)) SWIG_fail;
17463 }
17464 }
17465 if (obj2) {
17466 {
17467 arg3 = (int)(SWIG_As_int(obj2));
17468 if (SWIG_arg_fail(3)) SWIG_fail;
17469 }
17470 }
17471 {
17472 if (!wxPyCheckForApp()) SWIG_fail;
17473 PyThreadState* __tstate = wxPyBeginAllowThreads();
17474 result = (wxBufferedPaintDC *)new wxBufferedPaintDC(arg1,(wxBitmap const &)*arg2,arg3);
17475
17476 wxPyEndAllowThreads(__tstate);
17477 if (PyErr_Occurred()) SWIG_fail;
17478 }
17479 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedPaintDC, 1);
17480 return resultobj;
17481 fail:
17482 return NULL;
17483 }
17484
17485
17486 static PyObject * BufferedPaintDC_swigregister(PyObject *, PyObject *args) {
17487 PyObject *obj;
17488 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17489 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedPaintDC, obj);
17490 Py_INCREF(obj);
17491 return Py_BuildValue((char *)"");
17492 }
17493 static PyObject *_wrap_new_ScreenDC(PyObject *, PyObject *args, PyObject *kwargs) {
17494 PyObject *resultobj;
17495 wxScreenDC *result;
17496 char *kwnames[] = {
17497 NULL
17498 };
17499
17500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ScreenDC",kwnames)) goto fail;
17501 {
17502 if (!wxPyCheckForApp()) SWIG_fail;
17503 PyThreadState* __tstate = wxPyBeginAllowThreads();
17504 result = (wxScreenDC *)new wxScreenDC();
17505
17506 wxPyEndAllowThreads(__tstate);
17507 if (PyErr_Occurred()) SWIG_fail;
17508 }
17509 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScreenDC, 1);
17510 return resultobj;
17511 fail:
17512 return NULL;
17513 }
17514
17515
17516 static PyObject *_wrap_ScreenDC_StartDrawingOnTopWin(PyObject *, PyObject *args, PyObject *kwargs) {
17517 PyObject *resultobj;
17518 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17519 wxWindow *arg2 = (wxWindow *) 0 ;
17520 bool result;
17521 PyObject * obj0 = 0 ;
17522 PyObject * obj1 = 0 ;
17523 char *kwnames[] = {
17524 (char *) "self",(char *) "window", NULL
17525 };
17526
17527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScreenDC_StartDrawingOnTopWin",kwnames,&obj0,&obj1)) goto fail;
17528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17529 if (SWIG_arg_fail(1)) SWIG_fail;
17530 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17531 if (SWIG_arg_fail(2)) SWIG_fail;
17532 {
17533 PyThreadState* __tstate = wxPyBeginAllowThreads();
17534 result = (bool)(arg1)->StartDrawingOnTop(arg2);
17535
17536 wxPyEndAllowThreads(__tstate);
17537 if (PyErr_Occurred()) SWIG_fail;
17538 }
17539 {
17540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17541 }
17542 return resultobj;
17543 fail:
17544 return NULL;
17545 }
17546
17547
17548 static PyObject *_wrap_ScreenDC_StartDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
17549 PyObject *resultobj;
17550 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17551 wxRect *arg2 = (wxRect *) NULL ;
17552 bool result;
17553 PyObject * obj0 = 0 ;
17554 PyObject * obj1 = 0 ;
17555 char *kwnames[] = {
17556 (char *) "self",(char *) "rect", NULL
17557 };
17558
17559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ScreenDC_StartDrawingOnTop",kwnames,&obj0,&obj1)) goto fail;
17560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17561 if (SWIG_arg_fail(1)) SWIG_fail;
17562 if (obj1) {
17563 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
17564 if (SWIG_arg_fail(2)) SWIG_fail;
17565 }
17566 {
17567 PyThreadState* __tstate = wxPyBeginAllowThreads();
17568 result = (bool)(arg1)->StartDrawingOnTop(arg2);
17569
17570 wxPyEndAllowThreads(__tstate);
17571 if (PyErr_Occurred()) SWIG_fail;
17572 }
17573 {
17574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17575 }
17576 return resultobj;
17577 fail:
17578 return NULL;
17579 }
17580
17581
17582 static PyObject *_wrap_ScreenDC_EndDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
17583 PyObject *resultobj;
17584 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17585 bool result;
17586 PyObject * obj0 = 0 ;
17587 char *kwnames[] = {
17588 (char *) "self", NULL
17589 };
17590
17591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScreenDC_EndDrawingOnTop",kwnames,&obj0)) goto fail;
17592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17593 if (SWIG_arg_fail(1)) SWIG_fail;
17594 {
17595 PyThreadState* __tstate = wxPyBeginAllowThreads();
17596 result = (bool)(arg1)->EndDrawingOnTop();
17597
17598 wxPyEndAllowThreads(__tstate);
17599 if (PyErr_Occurred()) SWIG_fail;
17600 }
17601 {
17602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17603 }
17604 return resultobj;
17605 fail:
17606 return NULL;
17607 }
17608
17609
17610 static PyObject * ScreenDC_swigregister(PyObject *, PyObject *args) {
17611 PyObject *obj;
17612 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17613 SWIG_TypeClientData(SWIGTYPE_p_wxScreenDC, obj);
17614 Py_INCREF(obj);
17615 return Py_BuildValue((char *)"");
17616 }
17617 static PyObject *_wrap_new_ClientDC(PyObject *, PyObject *args, PyObject *kwargs) {
17618 PyObject *resultobj;
17619 wxWindow *arg1 = (wxWindow *) 0 ;
17620 wxClientDC *result;
17621 PyObject * obj0 = 0 ;
17622 char *kwnames[] = {
17623 (char *) "win", NULL
17624 };
17625
17626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ClientDC",kwnames,&obj0)) goto fail;
17627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17628 if (SWIG_arg_fail(1)) SWIG_fail;
17629 {
17630 if (!wxPyCheckForApp()) SWIG_fail;
17631 PyThreadState* __tstate = wxPyBeginAllowThreads();
17632 result = (wxClientDC *)new wxClientDC(arg1);
17633
17634 wxPyEndAllowThreads(__tstate);
17635 if (PyErr_Occurred()) SWIG_fail;
17636 }
17637 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClientDC, 1);
17638 return resultobj;
17639 fail:
17640 return NULL;
17641 }
17642
17643
17644 static PyObject * ClientDC_swigregister(PyObject *, PyObject *args) {
17645 PyObject *obj;
17646 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17647 SWIG_TypeClientData(SWIGTYPE_p_wxClientDC, obj);
17648 Py_INCREF(obj);
17649 return Py_BuildValue((char *)"");
17650 }
17651 static PyObject *_wrap_new_PaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
17652 PyObject *resultobj;
17653 wxWindow *arg1 = (wxWindow *) 0 ;
17654 wxPaintDC *result;
17655 PyObject * obj0 = 0 ;
17656 char *kwnames[] = {
17657 (char *) "win", NULL
17658 };
17659
17660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PaintDC",kwnames,&obj0)) goto fail;
17661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17662 if (SWIG_arg_fail(1)) SWIG_fail;
17663 {
17664 if (!wxPyCheckForApp()) SWIG_fail;
17665 PyThreadState* __tstate = wxPyBeginAllowThreads();
17666 result = (wxPaintDC *)new wxPaintDC(arg1);
17667
17668 wxPyEndAllowThreads(__tstate);
17669 if (PyErr_Occurred()) SWIG_fail;
17670 }
17671 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintDC, 1);
17672 return resultobj;
17673 fail:
17674 return NULL;
17675 }
17676
17677
17678 static PyObject * PaintDC_swigregister(PyObject *, PyObject *args) {
17679 PyObject *obj;
17680 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17681 SWIG_TypeClientData(SWIGTYPE_p_wxPaintDC, obj);
17682 Py_INCREF(obj);
17683 return Py_BuildValue((char *)"");
17684 }
17685 static PyObject *_wrap_new_WindowDC(PyObject *, PyObject *args, PyObject *kwargs) {
17686 PyObject *resultobj;
17687 wxWindow *arg1 = (wxWindow *) 0 ;
17688 wxWindowDC *result;
17689 PyObject * obj0 = 0 ;
17690 char *kwnames[] = {
17691 (char *) "win", NULL
17692 };
17693
17694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_WindowDC",kwnames,&obj0)) goto fail;
17695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17696 if (SWIG_arg_fail(1)) SWIG_fail;
17697 {
17698 if (!wxPyCheckForApp()) SWIG_fail;
17699 PyThreadState* __tstate = wxPyBeginAllowThreads();
17700 result = (wxWindowDC *)new wxWindowDC(arg1);
17701
17702 wxPyEndAllowThreads(__tstate);
17703 if (PyErr_Occurred()) SWIG_fail;
17704 }
17705 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDC, 1);
17706 return resultobj;
17707 fail:
17708 return NULL;
17709 }
17710
17711
17712 static PyObject * WindowDC_swigregister(PyObject *, PyObject *args) {
17713 PyObject *obj;
17714 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17715 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDC, obj);
17716 Py_INCREF(obj);
17717 return Py_BuildValue((char *)"");
17718 }
17719 static PyObject *_wrap_new_MirrorDC(PyObject *, PyObject *args, PyObject *kwargs) {
17720 PyObject *resultobj;
17721 wxDC *arg1 = 0 ;
17722 bool arg2 ;
17723 wxMirrorDC *result;
17724 PyObject * obj0 = 0 ;
17725 PyObject * obj1 = 0 ;
17726 char *kwnames[] = {
17727 (char *) "dc",(char *) "mirror", NULL
17728 };
17729
17730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_MirrorDC",kwnames,&obj0,&obj1)) goto fail;
17731 {
17732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17733 if (SWIG_arg_fail(1)) SWIG_fail;
17734 if (arg1 == NULL) {
17735 SWIG_null_ref("wxDC");
17736 }
17737 if (SWIG_arg_fail(1)) SWIG_fail;
17738 }
17739 {
17740 arg2 = (bool)(SWIG_As_bool(obj1));
17741 if (SWIG_arg_fail(2)) SWIG_fail;
17742 }
17743 {
17744 if (!wxPyCheckForApp()) SWIG_fail;
17745 PyThreadState* __tstate = wxPyBeginAllowThreads();
17746 result = (wxMirrorDC *)new wxMirrorDC(*arg1,arg2);
17747
17748 wxPyEndAllowThreads(__tstate);
17749 if (PyErr_Occurred()) SWIG_fail;
17750 }
17751 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMirrorDC, 1);
17752 return resultobj;
17753 fail:
17754 return NULL;
17755 }
17756
17757
17758 static PyObject * MirrorDC_swigregister(PyObject *, PyObject *args) {
17759 PyObject *obj;
17760 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17761 SWIG_TypeClientData(SWIGTYPE_p_wxMirrorDC, obj);
17762 Py_INCREF(obj);
17763 return Py_BuildValue((char *)"");
17764 }
17765 static PyObject *_wrap_new_PostScriptDC(PyObject *, PyObject *args, PyObject *kwargs) {
17766 PyObject *resultobj;
17767 wxPrintData *arg1 = 0 ;
17768 wxPostScriptDC *result;
17769 PyObject * obj0 = 0 ;
17770 char *kwnames[] = {
17771 (char *) "printData", NULL
17772 };
17773
17774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PostScriptDC",kwnames,&obj0)) goto fail;
17775 {
17776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
17777 if (SWIG_arg_fail(1)) SWIG_fail;
17778 if (arg1 == NULL) {
17779 SWIG_null_ref("wxPrintData");
17780 }
17781 if (SWIG_arg_fail(1)) SWIG_fail;
17782 }
17783 {
17784 if (!wxPyCheckForApp()) SWIG_fail;
17785 PyThreadState* __tstate = wxPyBeginAllowThreads();
17786 result = (wxPostScriptDC *)new wxPostScriptDC((wxPrintData const &)*arg1);
17787
17788 wxPyEndAllowThreads(__tstate);
17789 if (PyErr_Occurred()) SWIG_fail;
17790 }
17791 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPostScriptDC, 1);
17792 return resultobj;
17793 fail:
17794 return NULL;
17795 }
17796
17797
17798 static PyObject *_wrap_PostScriptDC_GetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
17799 PyObject *resultobj;
17800 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
17801 wxPrintData *result;
17802 PyObject * obj0 = 0 ;
17803 char *kwnames[] = {
17804 (char *) "self", NULL
17805 };
17806
17807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_GetPrintData",kwnames,&obj0)) goto fail;
17808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
17809 if (SWIG_arg_fail(1)) SWIG_fail;
17810 {
17811 PyThreadState* __tstate = wxPyBeginAllowThreads();
17812 {
17813 wxPrintData &_result_ref = (arg1)->GetPrintData();
17814 result = (wxPrintData *) &_result_ref;
17815 }
17816
17817 wxPyEndAllowThreads(__tstate);
17818 if (PyErr_Occurred()) SWIG_fail;
17819 }
17820 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 0);
17821 return resultobj;
17822 fail:
17823 return NULL;
17824 }
17825
17826
17827 static PyObject *_wrap_PostScriptDC_SetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
17828 PyObject *resultobj;
17829 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
17830 wxPrintData *arg2 = 0 ;
17831 PyObject * obj0 = 0 ;
17832 PyObject * obj1 = 0 ;
17833 char *kwnames[] = {
17834 (char *) "self",(char *) "data", NULL
17835 };
17836
17837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostScriptDC_SetPrintData",kwnames,&obj0,&obj1)) goto fail;
17838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
17839 if (SWIG_arg_fail(1)) SWIG_fail;
17840 {
17841 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
17842 if (SWIG_arg_fail(2)) SWIG_fail;
17843 if (arg2 == NULL) {
17844 SWIG_null_ref("wxPrintData");
17845 }
17846 if (SWIG_arg_fail(2)) SWIG_fail;
17847 }
17848 {
17849 PyThreadState* __tstate = wxPyBeginAllowThreads();
17850 (arg1)->SetPrintData((wxPrintData const &)*arg2);
17851
17852 wxPyEndAllowThreads(__tstate);
17853 if (PyErr_Occurred()) SWIG_fail;
17854 }
17855 Py_INCREF(Py_None); resultobj = Py_None;
17856 return resultobj;
17857 fail:
17858 return NULL;
17859 }
17860
17861
17862 static PyObject *_wrap_PostScriptDC_SetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
17863 PyObject *resultobj;
17864 int arg1 ;
17865 PyObject * obj0 = 0 ;
17866 char *kwnames[] = {
17867 (char *) "ppi", NULL
17868 };
17869
17870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_SetResolution",kwnames,&obj0)) goto fail;
17871 {
17872 arg1 = (int)(SWIG_As_int(obj0));
17873 if (SWIG_arg_fail(1)) SWIG_fail;
17874 }
17875 {
17876 PyThreadState* __tstate = wxPyBeginAllowThreads();
17877 wxPostScriptDC::SetResolution(arg1);
17878
17879 wxPyEndAllowThreads(__tstate);
17880 if (PyErr_Occurred()) SWIG_fail;
17881 }
17882 Py_INCREF(Py_None); resultobj = Py_None;
17883 return resultobj;
17884 fail:
17885 return NULL;
17886 }
17887
17888
17889 static PyObject *_wrap_PostScriptDC_GetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
17890 PyObject *resultobj;
17891 int result;
17892 char *kwnames[] = {
17893 NULL
17894 };
17895
17896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PostScriptDC_GetResolution",kwnames)) goto fail;
17897 {
17898 PyThreadState* __tstate = wxPyBeginAllowThreads();
17899 result = (int)wxPostScriptDC::GetResolution();
17900
17901 wxPyEndAllowThreads(__tstate);
17902 if (PyErr_Occurred()) SWIG_fail;
17903 }
17904 {
17905 resultobj = SWIG_From_int((int)(result));
17906 }
17907 return resultobj;
17908 fail:
17909 return NULL;
17910 }
17911
17912
17913 static PyObject * PostScriptDC_swigregister(PyObject *, PyObject *args) {
17914 PyObject *obj;
17915 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17916 SWIG_TypeClientData(SWIGTYPE_p_wxPostScriptDC, obj);
17917 Py_INCREF(obj);
17918 return Py_BuildValue((char *)"");
17919 }
17920 static PyObject *_wrap_new_MetaFile(PyObject *, PyObject *args, PyObject *kwargs) {
17921 PyObject *resultobj;
17922 wxString const &arg1_defvalue = wxPyEmptyString ;
17923 wxString *arg1 = (wxString *) &arg1_defvalue ;
17924 wxMetaFile *result;
17925 bool temp1 = false ;
17926 PyObject * obj0 = 0 ;
17927 char *kwnames[] = {
17928 (char *) "filename", NULL
17929 };
17930
17931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MetaFile",kwnames,&obj0)) goto fail;
17932 if (obj0) {
17933 {
17934 arg1 = wxString_in_helper(obj0);
17935 if (arg1 == NULL) SWIG_fail;
17936 temp1 = true;
17937 }
17938 }
17939 {
17940 if (!wxPyCheckForApp()) SWIG_fail;
17941 PyThreadState* __tstate = wxPyBeginAllowThreads();
17942 result = (wxMetaFile *)new wxMetaFile((wxString const &)*arg1);
17943
17944 wxPyEndAllowThreads(__tstate);
17945 if (PyErr_Occurred()) SWIG_fail;
17946 }
17947 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFile, 1);
17948 {
17949 if (temp1)
17950 delete arg1;
17951 }
17952 return resultobj;
17953 fail:
17954 {
17955 if (temp1)
17956 delete arg1;
17957 }
17958 return NULL;
17959 }
17960
17961
17962 static PyObject * MetaFile_swigregister(PyObject *, PyObject *args) {
17963 PyObject *obj;
17964 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17965 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFile, obj);
17966 Py_INCREF(obj);
17967 return Py_BuildValue((char *)"");
17968 }
17969 static PyObject *_wrap_new_MetaFileDC(PyObject *, PyObject *args, PyObject *kwargs) {
17970 PyObject *resultobj;
17971 wxString const &arg1_defvalue = wxPyEmptyString ;
17972 wxString *arg1 = (wxString *) &arg1_defvalue ;
17973 int arg2 = (int) 0 ;
17974 int arg3 = (int) 0 ;
17975 wxString const &arg4_defvalue = wxPyEmptyString ;
17976 wxString *arg4 = (wxString *) &arg4_defvalue ;
17977 wxMetaFileDC *result;
17978 bool temp1 = false ;
17979 bool temp4 = false ;
17980 PyObject * obj0 = 0 ;
17981 PyObject * obj1 = 0 ;
17982 PyObject * obj2 = 0 ;
17983 PyObject * obj3 = 0 ;
17984 char *kwnames[] = {
17985 (char *) "filename",(char *) "width",(char *) "height",(char *) "description", NULL
17986 };
17987
17988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_MetaFileDC",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17989 if (obj0) {
17990 {
17991 arg1 = wxString_in_helper(obj0);
17992 if (arg1 == NULL) SWIG_fail;
17993 temp1 = true;
17994 }
17995 }
17996 if (obj1) {
17997 {
17998 arg2 = (int)(SWIG_As_int(obj1));
17999 if (SWIG_arg_fail(2)) SWIG_fail;
18000 }
18001 }
18002 if (obj2) {
18003 {
18004 arg3 = (int)(SWIG_As_int(obj2));
18005 if (SWIG_arg_fail(3)) SWIG_fail;
18006 }
18007 }
18008 if (obj3) {
18009 {
18010 arg4 = wxString_in_helper(obj3);
18011 if (arg4 == NULL) SWIG_fail;
18012 temp4 = true;
18013 }
18014 }
18015 {
18016 if (!wxPyCheckForApp()) SWIG_fail;
18017 PyThreadState* __tstate = wxPyBeginAllowThreads();
18018 result = (wxMetaFileDC *)new wxMetaFileDC((wxString const &)*arg1,arg2,arg3,(wxString const &)*arg4);
18019
18020 wxPyEndAllowThreads(__tstate);
18021 if (PyErr_Occurred()) SWIG_fail;
18022 }
18023 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFileDC, 1);
18024 {
18025 if (temp1)
18026 delete arg1;
18027 }
18028 {
18029 if (temp4)
18030 delete arg4;
18031 }
18032 return resultobj;
18033 fail:
18034 {
18035 if (temp1)
18036 delete arg1;
18037 }
18038 {
18039 if (temp4)
18040 delete arg4;
18041 }
18042 return NULL;
18043 }
18044
18045
18046 static PyObject * MetaFileDC_swigregister(PyObject *, PyObject *args) {
18047 PyObject *obj;
18048 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18049 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFileDC, obj);
18050 Py_INCREF(obj);
18051 return Py_BuildValue((char *)"");
18052 }
18053 static PyObject *_wrap_new_PrinterDC(PyObject *, PyObject *args, PyObject *kwargs) {
18054 PyObject *resultobj;
18055 wxPrintData *arg1 = 0 ;
18056 wxPrinterDC *result;
18057 PyObject * obj0 = 0 ;
18058 char *kwnames[] = {
18059 (char *) "printData", NULL
18060 };
18061
18062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PrinterDC",kwnames,&obj0)) goto fail;
18063 {
18064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
18065 if (SWIG_arg_fail(1)) SWIG_fail;
18066 if (arg1 == NULL) {
18067 SWIG_null_ref("wxPrintData");
18068 }
18069 if (SWIG_arg_fail(1)) SWIG_fail;
18070 }
18071 {
18072 if (!wxPyCheckForApp()) SWIG_fail;
18073 PyThreadState* __tstate = wxPyBeginAllowThreads();
18074 result = (wxPrinterDC *)new wxPrinterDC((wxPrintData const &)*arg1);
18075
18076 wxPyEndAllowThreads(__tstate);
18077 if (PyErr_Occurred()) SWIG_fail;
18078 }
18079 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrinterDC, 1);
18080 return resultobj;
18081 fail:
18082 return NULL;
18083 }
18084
18085
18086 static PyObject * PrinterDC_swigregister(PyObject *, PyObject *args) {
18087 PyObject *obj;
18088 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18089 SWIG_TypeClientData(SWIGTYPE_p_wxPrinterDC, obj);
18090 Py_INCREF(obj);
18091 return Py_BuildValue((char *)"");
18092 }
18093 static PyObject *_wrap_new_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
18094 PyObject *resultobj;
18095 int arg1 ;
18096 int arg2 ;
18097 int arg3 = (int) true ;
18098 int arg4 = (int) 1 ;
18099 wxImageList *result;
18100 PyObject * obj0 = 0 ;
18101 PyObject * obj1 = 0 ;
18102 PyObject * obj2 = 0 ;
18103 PyObject * obj3 = 0 ;
18104 char *kwnames[] = {
18105 (char *) "width",(char *) "height",(char *) "mask",(char *) "initialCount", NULL
18106 };
18107
18108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_ImageList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
18109 {
18110 arg1 = (int)(SWIG_As_int(obj0));
18111 if (SWIG_arg_fail(1)) SWIG_fail;
18112 }
18113 {
18114 arg2 = (int)(SWIG_As_int(obj1));
18115 if (SWIG_arg_fail(2)) SWIG_fail;
18116 }
18117 if (obj2) {
18118 {
18119 arg3 = (int)(SWIG_As_int(obj2));
18120 if (SWIG_arg_fail(3)) SWIG_fail;
18121 }
18122 }
18123 if (obj3) {
18124 {
18125 arg4 = (int)(SWIG_As_int(obj3));
18126 if (SWIG_arg_fail(4)) SWIG_fail;
18127 }
18128 }
18129 {
18130 if (!wxPyCheckForApp()) SWIG_fail;
18131 PyThreadState* __tstate = wxPyBeginAllowThreads();
18132 result = (wxImageList *)new wxImageList(arg1,arg2,arg3,arg4);
18133
18134 wxPyEndAllowThreads(__tstate);
18135 if (PyErr_Occurred()) SWIG_fail;
18136 }
18137 {
18138 resultobj = wxPyMake_wxObject(result, 1);
18139 }
18140 return resultobj;
18141 fail:
18142 return NULL;
18143 }
18144
18145
18146 static PyObject *_wrap_delete_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
18147 PyObject *resultobj;
18148 wxImageList *arg1 = (wxImageList *) 0 ;
18149 PyObject * obj0 = 0 ;
18150 char *kwnames[] = {
18151 (char *) "self", NULL
18152 };
18153
18154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ImageList",kwnames,&obj0)) goto fail;
18155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18156 if (SWIG_arg_fail(1)) SWIG_fail;
18157 {
18158 PyThreadState* __tstate = wxPyBeginAllowThreads();
18159 delete arg1;
18160
18161 wxPyEndAllowThreads(__tstate);
18162 if (PyErr_Occurred()) SWIG_fail;
18163 }
18164 Py_INCREF(Py_None); resultobj = Py_None;
18165 return resultobj;
18166 fail:
18167 return NULL;
18168 }
18169
18170
18171 static PyObject *_wrap_ImageList_Add(PyObject *, PyObject *args, PyObject *kwargs) {
18172 PyObject *resultobj;
18173 wxImageList *arg1 = (wxImageList *) 0 ;
18174 wxBitmap *arg2 = 0 ;
18175 wxBitmap const &arg3_defvalue = wxNullBitmap ;
18176 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
18177 int result;
18178 PyObject * obj0 = 0 ;
18179 PyObject * obj1 = 0 ;
18180 PyObject * obj2 = 0 ;
18181 char *kwnames[] = {
18182 (char *) "self",(char *) "bitmap",(char *) "mask", NULL
18183 };
18184
18185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ImageList_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
18186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18187 if (SWIG_arg_fail(1)) SWIG_fail;
18188 {
18189 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18190 if (SWIG_arg_fail(2)) SWIG_fail;
18191 if (arg2 == NULL) {
18192 SWIG_null_ref("wxBitmap");
18193 }
18194 if (SWIG_arg_fail(2)) SWIG_fail;
18195 }
18196 if (obj2) {
18197 {
18198 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18199 if (SWIG_arg_fail(3)) SWIG_fail;
18200 if (arg3 == NULL) {
18201 SWIG_null_ref("wxBitmap");
18202 }
18203 if (SWIG_arg_fail(3)) SWIG_fail;
18204 }
18205 }
18206 {
18207 PyThreadState* __tstate = wxPyBeginAllowThreads();
18208 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
18209
18210 wxPyEndAllowThreads(__tstate);
18211 if (PyErr_Occurred()) SWIG_fail;
18212 }
18213 {
18214 resultobj = SWIG_From_int((int)(result));
18215 }
18216 return resultobj;
18217 fail:
18218 return NULL;
18219 }
18220
18221
18222 static PyObject *_wrap_ImageList_AddWithColourMask(PyObject *, PyObject *args, PyObject *kwargs) {
18223 PyObject *resultobj;
18224 wxImageList *arg1 = (wxImageList *) 0 ;
18225 wxBitmap *arg2 = 0 ;
18226 wxColour *arg3 = 0 ;
18227 int result;
18228 wxColour temp3 ;
18229 PyObject * obj0 = 0 ;
18230 PyObject * obj1 = 0 ;
18231 PyObject * obj2 = 0 ;
18232 char *kwnames[] = {
18233 (char *) "self",(char *) "bitmap",(char *) "maskColour", NULL
18234 };
18235
18236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_AddWithColourMask",kwnames,&obj0,&obj1,&obj2)) goto fail;
18237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18238 if (SWIG_arg_fail(1)) SWIG_fail;
18239 {
18240 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18241 if (SWIG_arg_fail(2)) SWIG_fail;
18242 if (arg2 == NULL) {
18243 SWIG_null_ref("wxBitmap");
18244 }
18245 if (SWIG_arg_fail(2)) SWIG_fail;
18246 }
18247 {
18248 arg3 = &temp3;
18249 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
18250 }
18251 {
18252 PyThreadState* __tstate = wxPyBeginAllowThreads();
18253 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxColour const &)*arg3);
18254
18255 wxPyEndAllowThreads(__tstate);
18256 if (PyErr_Occurred()) SWIG_fail;
18257 }
18258 {
18259 resultobj = SWIG_From_int((int)(result));
18260 }
18261 return resultobj;
18262 fail:
18263 return NULL;
18264 }
18265
18266
18267 static PyObject *_wrap_ImageList_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
18268 PyObject *resultobj;
18269 wxImageList *arg1 = (wxImageList *) 0 ;
18270 wxIcon *arg2 = 0 ;
18271 int result;
18272 PyObject * obj0 = 0 ;
18273 PyObject * obj1 = 0 ;
18274 char *kwnames[] = {
18275 (char *) "self",(char *) "icon", NULL
18276 };
18277
18278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_AddIcon",kwnames,&obj0,&obj1)) goto fail;
18279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18280 if (SWIG_arg_fail(1)) SWIG_fail;
18281 {
18282 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
18283 if (SWIG_arg_fail(2)) SWIG_fail;
18284 if (arg2 == NULL) {
18285 SWIG_null_ref("wxIcon");
18286 }
18287 if (SWIG_arg_fail(2)) SWIG_fail;
18288 }
18289 {
18290 PyThreadState* __tstate = wxPyBeginAllowThreads();
18291 result = (int)(arg1)->Add((wxIcon const &)*arg2);
18292
18293 wxPyEndAllowThreads(__tstate);
18294 if (PyErr_Occurred()) SWIG_fail;
18295 }
18296 {
18297 resultobj = SWIG_From_int((int)(result));
18298 }
18299 return resultobj;
18300 fail:
18301 return NULL;
18302 }
18303
18304
18305 static PyObject *_wrap_ImageList_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
18306 PyObject *resultobj;
18307 wxImageList *arg1 = (wxImageList *) 0 ;
18308 int arg2 ;
18309 SwigValueWrapper<wxBitmap > result;
18310 PyObject * obj0 = 0 ;
18311 PyObject * obj1 = 0 ;
18312 char *kwnames[] = {
18313 (char *) "self",(char *) "index", NULL
18314 };
18315
18316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetBitmap",kwnames,&obj0,&obj1)) goto fail;
18317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18318 if (SWIG_arg_fail(1)) SWIG_fail;
18319 {
18320 arg2 = (int)(SWIG_As_int(obj1));
18321 if (SWIG_arg_fail(2)) SWIG_fail;
18322 }
18323 {
18324 PyThreadState* __tstate = wxPyBeginAllowThreads();
18325 result = ((wxImageList const *)arg1)->GetBitmap(arg2);
18326
18327 wxPyEndAllowThreads(__tstate);
18328 if (PyErr_Occurred()) SWIG_fail;
18329 }
18330 {
18331 wxBitmap * resultptr;
18332 resultptr = new wxBitmap((wxBitmap &)(result));
18333 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
18334 }
18335 return resultobj;
18336 fail:
18337 return NULL;
18338 }
18339
18340
18341 static PyObject *_wrap_ImageList_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
18342 PyObject *resultobj;
18343 wxImageList *arg1 = (wxImageList *) 0 ;
18344 int arg2 ;
18345 wxIcon result;
18346 PyObject * obj0 = 0 ;
18347 PyObject * obj1 = 0 ;
18348 char *kwnames[] = {
18349 (char *) "self",(char *) "index", NULL
18350 };
18351
18352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetIcon",kwnames,&obj0,&obj1)) goto fail;
18353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18354 if (SWIG_arg_fail(1)) SWIG_fail;
18355 {
18356 arg2 = (int)(SWIG_As_int(obj1));
18357 if (SWIG_arg_fail(2)) SWIG_fail;
18358 }
18359 {
18360 PyThreadState* __tstate = wxPyBeginAllowThreads();
18361 result = ((wxImageList const *)arg1)->GetIcon(arg2);
18362
18363 wxPyEndAllowThreads(__tstate);
18364 if (PyErr_Occurred()) SWIG_fail;
18365 }
18366 {
18367 wxIcon * resultptr;
18368 resultptr = new wxIcon((wxIcon &)(result));
18369 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
18370 }
18371 return resultobj;
18372 fail:
18373 return NULL;
18374 }
18375
18376
18377 static PyObject *_wrap_ImageList_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
18378 PyObject *resultobj;
18379 wxImageList *arg1 = (wxImageList *) 0 ;
18380 int arg2 ;
18381 wxBitmap *arg3 = 0 ;
18382 bool result;
18383 PyObject * obj0 = 0 ;
18384 PyObject * obj1 = 0 ;
18385 PyObject * obj2 = 0 ;
18386 char *kwnames[] = {
18387 (char *) "self",(char *) "index",(char *) "bitmap", NULL
18388 };
18389
18390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_Replace",kwnames,&obj0,&obj1,&obj2)) goto fail;
18391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18392 if (SWIG_arg_fail(1)) SWIG_fail;
18393 {
18394 arg2 = (int)(SWIG_As_int(obj1));
18395 if (SWIG_arg_fail(2)) SWIG_fail;
18396 }
18397 {
18398 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18399 if (SWIG_arg_fail(3)) SWIG_fail;
18400 if (arg3 == NULL) {
18401 SWIG_null_ref("wxBitmap");
18402 }
18403 if (SWIG_arg_fail(3)) SWIG_fail;
18404 }
18405 {
18406 PyThreadState* __tstate = wxPyBeginAllowThreads();
18407 result = (bool)(arg1)->Replace(arg2,(wxBitmap const &)*arg3);
18408
18409 wxPyEndAllowThreads(__tstate);
18410 if (PyErr_Occurred()) SWIG_fail;
18411 }
18412 {
18413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18414 }
18415 return resultobj;
18416 fail:
18417 return NULL;
18418 }
18419
18420
18421 static PyObject *_wrap_ImageList_Draw(PyObject *, PyObject *args, PyObject *kwargs) {
18422 PyObject *resultobj;
18423 wxImageList *arg1 = (wxImageList *) 0 ;
18424 int arg2 ;
18425 wxDC *arg3 = 0 ;
18426 int arg4 ;
18427 int arg5 ;
18428 int arg6 = (int) wxIMAGELIST_DRAW_NORMAL ;
18429 bool arg7 = (bool) (bool)false ;
18430 bool result;
18431 PyObject * obj0 = 0 ;
18432 PyObject * obj1 = 0 ;
18433 PyObject * obj2 = 0 ;
18434 PyObject * obj3 = 0 ;
18435 PyObject * obj4 = 0 ;
18436 PyObject * obj5 = 0 ;
18437 PyObject * obj6 = 0 ;
18438 char *kwnames[] = {
18439 (char *) "self",(char *) "index",(char *) "dc",(char *) "x",(char *) "x",(char *) "flags",(char *) "solidBackground", NULL
18440 };
18441
18442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OO:ImageList_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
18443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18444 if (SWIG_arg_fail(1)) SWIG_fail;
18445 {
18446 arg2 = (int)(SWIG_As_int(obj1));
18447 if (SWIG_arg_fail(2)) SWIG_fail;
18448 }
18449 {
18450 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
18451 if (SWIG_arg_fail(3)) SWIG_fail;
18452 if (arg3 == NULL) {
18453 SWIG_null_ref("wxDC");
18454 }
18455 if (SWIG_arg_fail(3)) SWIG_fail;
18456 }
18457 {
18458 arg4 = (int)(SWIG_As_int(obj3));
18459 if (SWIG_arg_fail(4)) SWIG_fail;
18460 }
18461 {
18462 arg5 = (int)(SWIG_As_int(obj4));
18463 if (SWIG_arg_fail(5)) SWIG_fail;
18464 }
18465 if (obj5) {
18466 {
18467 arg6 = (int)(SWIG_As_int(obj5));
18468 if (SWIG_arg_fail(6)) SWIG_fail;
18469 }
18470 }
18471 if (obj6) {
18472 {
18473 arg7 = (bool const)(SWIG_As_bool(obj6));
18474 if (SWIG_arg_fail(7)) SWIG_fail;
18475 }
18476 }
18477 {
18478 PyThreadState* __tstate = wxPyBeginAllowThreads();
18479 result = (bool)(arg1)->Draw(arg2,*arg3,arg4,arg5,arg6,arg7);
18480
18481 wxPyEndAllowThreads(__tstate);
18482 if (PyErr_Occurred()) SWIG_fail;
18483 }
18484 {
18485 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18486 }
18487 return resultobj;
18488 fail:
18489 return NULL;
18490 }
18491
18492
18493 static PyObject *_wrap_ImageList_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
18494 PyObject *resultobj;
18495 wxImageList *arg1 = (wxImageList *) 0 ;
18496 int result;
18497 PyObject * obj0 = 0 ;
18498 char *kwnames[] = {
18499 (char *) "self", NULL
18500 };
18501
18502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_GetImageCount",kwnames,&obj0)) goto fail;
18503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18504 if (SWIG_arg_fail(1)) SWIG_fail;
18505 {
18506 PyThreadState* __tstate = wxPyBeginAllowThreads();
18507 result = (int)(arg1)->GetImageCount();
18508
18509 wxPyEndAllowThreads(__tstate);
18510 if (PyErr_Occurred()) SWIG_fail;
18511 }
18512 {
18513 resultobj = SWIG_From_int((int)(result));
18514 }
18515 return resultobj;
18516 fail:
18517 return NULL;
18518 }
18519
18520
18521 static PyObject *_wrap_ImageList_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
18522 PyObject *resultobj;
18523 wxImageList *arg1 = (wxImageList *) 0 ;
18524 int arg2 ;
18525 bool result;
18526 PyObject * obj0 = 0 ;
18527 PyObject * obj1 = 0 ;
18528 char *kwnames[] = {
18529 (char *) "self",(char *) "index", NULL
18530 };
18531
18532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_Remove",kwnames,&obj0,&obj1)) goto fail;
18533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18534 if (SWIG_arg_fail(1)) SWIG_fail;
18535 {
18536 arg2 = (int)(SWIG_As_int(obj1));
18537 if (SWIG_arg_fail(2)) SWIG_fail;
18538 }
18539 {
18540 PyThreadState* __tstate = wxPyBeginAllowThreads();
18541 result = (bool)(arg1)->Remove(arg2);
18542
18543 wxPyEndAllowThreads(__tstate);
18544 if (PyErr_Occurred()) SWIG_fail;
18545 }
18546 {
18547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18548 }
18549 return resultobj;
18550 fail:
18551 return NULL;
18552 }
18553
18554
18555 static PyObject *_wrap_ImageList_RemoveAll(PyObject *, PyObject *args, PyObject *kwargs) {
18556 PyObject *resultobj;
18557 wxImageList *arg1 = (wxImageList *) 0 ;
18558 bool result;
18559 PyObject * obj0 = 0 ;
18560 char *kwnames[] = {
18561 (char *) "self", NULL
18562 };
18563
18564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_RemoveAll",kwnames,&obj0)) goto fail;
18565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18566 if (SWIG_arg_fail(1)) SWIG_fail;
18567 {
18568 PyThreadState* __tstate = wxPyBeginAllowThreads();
18569 result = (bool)(arg1)->RemoveAll();
18570
18571 wxPyEndAllowThreads(__tstate);
18572 if (PyErr_Occurred()) SWIG_fail;
18573 }
18574 {
18575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18576 }
18577 return resultobj;
18578 fail:
18579 return NULL;
18580 }
18581
18582
18583 static PyObject *_wrap_ImageList_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18584 PyObject *resultobj;
18585 wxImageList *arg1 = (wxImageList *) 0 ;
18586 int arg2 ;
18587 int *arg3 = 0 ;
18588 int *arg4 = 0 ;
18589 int temp3 ;
18590 int res3 = 0 ;
18591 int temp4 ;
18592 int res4 = 0 ;
18593 PyObject * obj0 = 0 ;
18594 PyObject * obj1 = 0 ;
18595 char *kwnames[] = {
18596 (char *) "self",(char *) "index", NULL
18597 };
18598
18599 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18600 arg4 = &temp4; res4 = SWIG_NEWOBJ;
18601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetSize",kwnames,&obj0,&obj1)) goto fail;
18602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18603 if (SWIG_arg_fail(1)) SWIG_fail;
18604 {
18605 arg2 = (int)(SWIG_As_int(obj1));
18606 if (SWIG_arg_fail(2)) SWIG_fail;
18607 }
18608 {
18609 PyThreadState* __tstate = wxPyBeginAllowThreads();
18610 (arg1)->GetSize(arg2,*arg3,*arg4);
18611
18612 wxPyEndAllowThreads(__tstate);
18613 if (PyErr_Occurred()) SWIG_fail;
18614 }
18615 Py_INCREF(Py_None); resultobj = Py_None;
18616 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18617 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
18618 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
18619 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
18620 return resultobj;
18621 fail:
18622 return NULL;
18623 }
18624
18625
18626 static PyObject * ImageList_swigregister(PyObject *, PyObject *args) {
18627 PyObject *obj;
18628 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18629 SWIG_TypeClientData(SWIGTYPE_p_wxImageList, obj);
18630 Py_INCREF(obj);
18631 return Py_BuildValue((char *)"");
18632 }
18633 static int _wrap_NORMAL_FONT_set(PyObject *) {
18634 PyErr_SetString(PyExc_TypeError,"Variable NORMAL_FONT is read-only.");
18635 return 1;
18636 }
18637
18638
18639 static PyObject *_wrap_NORMAL_FONT_get(void) {
18640 PyObject *pyobj;
18641
18642 pyobj = SWIG_NewPointerObj((void *)(wxNORMAL_FONT), SWIGTYPE_p_wxFont, 0);
18643 return pyobj;
18644 }
18645
18646
18647 static int _wrap_SMALL_FONT_set(PyObject *) {
18648 PyErr_SetString(PyExc_TypeError,"Variable SMALL_FONT is read-only.");
18649 return 1;
18650 }
18651
18652
18653 static PyObject *_wrap_SMALL_FONT_get(void) {
18654 PyObject *pyobj;
18655
18656 pyobj = SWIG_NewPointerObj((void *)(wxSMALL_FONT), SWIGTYPE_p_wxFont, 0);
18657 return pyobj;
18658 }
18659
18660
18661 static int _wrap_ITALIC_FONT_set(PyObject *) {
18662 PyErr_SetString(PyExc_TypeError,"Variable ITALIC_FONT is read-only.");
18663 return 1;
18664 }
18665
18666
18667 static PyObject *_wrap_ITALIC_FONT_get(void) {
18668 PyObject *pyobj;
18669
18670 pyobj = SWIG_NewPointerObj((void *)(wxITALIC_FONT), SWIGTYPE_p_wxFont, 0);
18671 return pyobj;
18672 }
18673
18674
18675 static int _wrap_SWISS_FONT_set(PyObject *) {
18676 PyErr_SetString(PyExc_TypeError,"Variable SWISS_FONT is read-only.");
18677 return 1;
18678 }
18679
18680
18681 static PyObject *_wrap_SWISS_FONT_get(void) {
18682 PyObject *pyobj;
18683
18684 pyobj = SWIG_NewPointerObj((void *)(wxSWISS_FONT), SWIGTYPE_p_wxFont, 0);
18685 return pyobj;
18686 }
18687
18688
18689 static int _wrap_RED_PEN_set(PyObject *) {
18690 PyErr_SetString(PyExc_TypeError,"Variable RED_PEN is read-only.");
18691 return 1;
18692 }
18693
18694
18695 static PyObject *_wrap_RED_PEN_get(void) {
18696 PyObject *pyobj;
18697
18698 pyobj = SWIG_NewPointerObj((void *)(wxRED_PEN), SWIGTYPE_p_wxPen, 0);
18699 return pyobj;
18700 }
18701
18702
18703 static int _wrap_CYAN_PEN_set(PyObject *) {
18704 PyErr_SetString(PyExc_TypeError,"Variable CYAN_PEN is read-only.");
18705 return 1;
18706 }
18707
18708
18709 static PyObject *_wrap_CYAN_PEN_get(void) {
18710 PyObject *pyobj;
18711
18712 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_PEN), SWIGTYPE_p_wxPen, 0);
18713 return pyobj;
18714 }
18715
18716
18717 static int _wrap_GREEN_PEN_set(PyObject *) {
18718 PyErr_SetString(PyExc_TypeError,"Variable GREEN_PEN is read-only.");
18719 return 1;
18720 }
18721
18722
18723 static PyObject *_wrap_GREEN_PEN_get(void) {
18724 PyObject *pyobj;
18725
18726 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_PEN), SWIGTYPE_p_wxPen, 0);
18727 return pyobj;
18728 }
18729
18730
18731 static int _wrap_BLACK_PEN_set(PyObject *) {
18732 PyErr_SetString(PyExc_TypeError,"Variable BLACK_PEN is read-only.");
18733 return 1;
18734 }
18735
18736
18737 static PyObject *_wrap_BLACK_PEN_get(void) {
18738 PyObject *pyobj;
18739
18740 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_PEN), SWIGTYPE_p_wxPen, 0);
18741 return pyobj;
18742 }
18743
18744
18745 static int _wrap_WHITE_PEN_set(PyObject *) {
18746 PyErr_SetString(PyExc_TypeError,"Variable WHITE_PEN is read-only.");
18747 return 1;
18748 }
18749
18750
18751 static PyObject *_wrap_WHITE_PEN_get(void) {
18752 PyObject *pyobj;
18753
18754 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_PEN), SWIGTYPE_p_wxPen, 0);
18755 return pyobj;
18756 }
18757
18758
18759 static int _wrap_TRANSPARENT_PEN_set(PyObject *) {
18760 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_PEN is read-only.");
18761 return 1;
18762 }
18763
18764
18765 static PyObject *_wrap_TRANSPARENT_PEN_get(void) {
18766 PyObject *pyobj;
18767
18768 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_PEN), SWIGTYPE_p_wxPen, 0);
18769 return pyobj;
18770 }
18771
18772
18773 static int _wrap_BLACK_DASHED_PEN_set(PyObject *) {
18774 PyErr_SetString(PyExc_TypeError,"Variable BLACK_DASHED_PEN is read-only.");
18775 return 1;
18776 }
18777
18778
18779 static PyObject *_wrap_BLACK_DASHED_PEN_get(void) {
18780 PyObject *pyobj;
18781
18782 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_DASHED_PEN), SWIGTYPE_p_wxPen, 0);
18783 return pyobj;
18784 }
18785
18786
18787 static int _wrap_GREY_PEN_set(PyObject *) {
18788 PyErr_SetString(PyExc_TypeError,"Variable GREY_PEN is read-only.");
18789 return 1;
18790 }
18791
18792
18793 static PyObject *_wrap_GREY_PEN_get(void) {
18794 PyObject *pyobj;
18795
18796 pyobj = SWIG_NewPointerObj((void *)(wxGREY_PEN), SWIGTYPE_p_wxPen, 0);
18797 return pyobj;
18798 }
18799
18800
18801 static int _wrap_MEDIUM_GREY_PEN_set(PyObject *) {
18802 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_PEN is read-only.");
18803 return 1;
18804 }
18805
18806
18807 static PyObject *_wrap_MEDIUM_GREY_PEN_get(void) {
18808 PyObject *pyobj;
18809
18810 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_PEN), SWIGTYPE_p_wxPen, 0);
18811 return pyobj;
18812 }
18813
18814
18815 static int _wrap_LIGHT_GREY_PEN_set(PyObject *) {
18816 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_PEN is read-only.");
18817 return 1;
18818 }
18819
18820
18821 static PyObject *_wrap_LIGHT_GREY_PEN_get(void) {
18822 PyObject *pyobj;
18823
18824 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_PEN), SWIGTYPE_p_wxPen, 0);
18825 return pyobj;
18826 }
18827
18828
18829 static int _wrap_BLUE_BRUSH_set(PyObject *) {
18830 PyErr_SetString(PyExc_TypeError,"Variable BLUE_BRUSH is read-only.");
18831 return 1;
18832 }
18833
18834
18835 static PyObject *_wrap_BLUE_BRUSH_get(void) {
18836 PyObject *pyobj;
18837
18838 pyobj = SWIG_NewPointerObj((void *)(wxBLUE_BRUSH), SWIGTYPE_p_wxBrush, 0);
18839 return pyobj;
18840 }
18841
18842
18843 static int _wrap_GREEN_BRUSH_set(PyObject *) {
18844 PyErr_SetString(PyExc_TypeError,"Variable GREEN_BRUSH is read-only.");
18845 return 1;
18846 }
18847
18848
18849 static PyObject *_wrap_GREEN_BRUSH_get(void) {
18850 PyObject *pyobj;
18851
18852 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_BRUSH), SWIGTYPE_p_wxBrush, 0);
18853 return pyobj;
18854 }
18855
18856
18857 static int _wrap_WHITE_BRUSH_set(PyObject *) {
18858 PyErr_SetString(PyExc_TypeError,"Variable WHITE_BRUSH is read-only.");
18859 return 1;
18860 }
18861
18862
18863 static PyObject *_wrap_WHITE_BRUSH_get(void) {
18864 PyObject *pyobj;
18865
18866 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_BRUSH), SWIGTYPE_p_wxBrush, 0);
18867 return pyobj;
18868 }
18869
18870
18871 static int _wrap_BLACK_BRUSH_set(PyObject *) {
18872 PyErr_SetString(PyExc_TypeError,"Variable BLACK_BRUSH is read-only.");
18873 return 1;
18874 }
18875
18876
18877 static PyObject *_wrap_BLACK_BRUSH_get(void) {
18878 PyObject *pyobj;
18879
18880 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_BRUSH), SWIGTYPE_p_wxBrush, 0);
18881 return pyobj;
18882 }
18883
18884
18885 static int _wrap_TRANSPARENT_BRUSH_set(PyObject *) {
18886 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_BRUSH is read-only.");
18887 return 1;
18888 }
18889
18890
18891 static PyObject *_wrap_TRANSPARENT_BRUSH_get(void) {
18892 PyObject *pyobj;
18893
18894 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_BRUSH), SWIGTYPE_p_wxBrush, 0);
18895 return pyobj;
18896 }
18897
18898
18899 static int _wrap_CYAN_BRUSH_set(PyObject *) {
18900 PyErr_SetString(PyExc_TypeError,"Variable CYAN_BRUSH is read-only.");
18901 return 1;
18902 }
18903
18904
18905 static PyObject *_wrap_CYAN_BRUSH_get(void) {
18906 PyObject *pyobj;
18907
18908 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_BRUSH), SWIGTYPE_p_wxBrush, 0);
18909 return pyobj;
18910 }
18911
18912
18913 static int _wrap_RED_BRUSH_set(PyObject *) {
18914 PyErr_SetString(PyExc_TypeError,"Variable RED_BRUSH is read-only.");
18915 return 1;
18916 }
18917
18918
18919 static PyObject *_wrap_RED_BRUSH_get(void) {
18920 PyObject *pyobj;
18921
18922 pyobj = SWIG_NewPointerObj((void *)(wxRED_BRUSH), SWIGTYPE_p_wxBrush, 0);
18923 return pyobj;
18924 }
18925
18926
18927 static int _wrap_GREY_BRUSH_set(PyObject *) {
18928 PyErr_SetString(PyExc_TypeError,"Variable GREY_BRUSH is read-only.");
18929 return 1;
18930 }
18931
18932
18933 static PyObject *_wrap_GREY_BRUSH_get(void) {
18934 PyObject *pyobj;
18935
18936 pyobj = SWIG_NewPointerObj((void *)(wxGREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
18937 return pyobj;
18938 }
18939
18940
18941 static int _wrap_MEDIUM_GREY_BRUSH_set(PyObject *) {
18942 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_BRUSH is read-only.");
18943 return 1;
18944 }
18945
18946
18947 static PyObject *_wrap_MEDIUM_GREY_BRUSH_get(void) {
18948 PyObject *pyobj;
18949
18950 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
18951 return pyobj;
18952 }
18953
18954
18955 static int _wrap_LIGHT_GREY_BRUSH_set(PyObject *) {
18956 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_BRUSH is read-only.");
18957 return 1;
18958 }
18959
18960
18961 static PyObject *_wrap_LIGHT_GREY_BRUSH_get(void) {
18962 PyObject *pyobj;
18963
18964 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
18965 return pyobj;
18966 }
18967
18968
18969 static int _wrap_BLACK_set(PyObject *) {
18970 PyErr_SetString(PyExc_TypeError,"Variable BLACK is read-only.");
18971 return 1;
18972 }
18973
18974
18975 static PyObject *_wrap_BLACK_get(void) {
18976 PyObject *pyobj;
18977
18978 pyobj = SWIG_NewPointerObj((void *)(wxBLACK), SWIGTYPE_p_wxColour, 0);
18979 return pyobj;
18980 }
18981
18982
18983 static int _wrap_WHITE_set(PyObject *) {
18984 PyErr_SetString(PyExc_TypeError,"Variable WHITE is read-only.");
18985 return 1;
18986 }
18987
18988
18989 static PyObject *_wrap_WHITE_get(void) {
18990 PyObject *pyobj;
18991
18992 pyobj = SWIG_NewPointerObj((void *)(wxWHITE), SWIGTYPE_p_wxColour, 0);
18993 return pyobj;
18994 }
18995
18996
18997 static int _wrap_RED_set(PyObject *) {
18998 PyErr_SetString(PyExc_TypeError,"Variable RED is read-only.");
18999 return 1;
19000 }
19001
19002
19003 static PyObject *_wrap_RED_get(void) {
19004 PyObject *pyobj;
19005
19006 pyobj = SWIG_NewPointerObj((void *)(wxRED), SWIGTYPE_p_wxColour, 0);
19007 return pyobj;
19008 }
19009
19010
19011 static int _wrap_BLUE_set(PyObject *) {
19012 PyErr_SetString(PyExc_TypeError,"Variable BLUE is read-only.");
19013 return 1;
19014 }
19015
19016
19017 static PyObject *_wrap_BLUE_get(void) {
19018 PyObject *pyobj;
19019
19020 pyobj = SWIG_NewPointerObj((void *)(wxBLUE), SWIGTYPE_p_wxColour, 0);
19021 return pyobj;
19022 }
19023
19024
19025 static int _wrap_GREEN_set(PyObject *) {
19026 PyErr_SetString(PyExc_TypeError,"Variable GREEN is read-only.");
19027 return 1;
19028 }
19029
19030
19031 static PyObject *_wrap_GREEN_get(void) {
19032 PyObject *pyobj;
19033
19034 pyobj = SWIG_NewPointerObj((void *)(wxGREEN), SWIGTYPE_p_wxColour, 0);
19035 return pyobj;
19036 }
19037
19038
19039 static int _wrap_CYAN_set(PyObject *) {
19040 PyErr_SetString(PyExc_TypeError,"Variable CYAN is read-only.");
19041 return 1;
19042 }
19043
19044
19045 static PyObject *_wrap_CYAN_get(void) {
19046 PyObject *pyobj;
19047
19048 pyobj = SWIG_NewPointerObj((void *)(wxCYAN), SWIGTYPE_p_wxColour, 0);
19049 return pyobj;
19050 }
19051
19052
19053 static int _wrap_LIGHT_GREY_set(PyObject *) {
19054 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY is read-only.");
19055 return 1;
19056 }
19057
19058
19059 static PyObject *_wrap_LIGHT_GREY_get(void) {
19060 PyObject *pyobj;
19061
19062 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY), SWIGTYPE_p_wxColour, 0);
19063 return pyobj;
19064 }
19065
19066
19067 static int _wrap_STANDARD_CURSOR_set(PyObject *) {
19068 PyErr_SetString(PyExc_TypeError,"Variable STANDARD_CURSOR is read-only.");
19069 return 1;
19070 }
19071
19072
19073 static PyObject *_wrap_STANDARD_CURSOR_get(void) {
19074 PyObject *pyobj;
19075
19076 pyobj = SWIG_NewPointerObj((void *)(wxSTANDARD_CURSOR), SWIGTYPE_p_wxCursor, 0);
19077 return pyobj;
19078 }
19079
19080
19081 static int _wrap_HOURGLASS_CURSOR_set(PyObject *) {
19082 PyErr_SetString(PyExc_TypeError,"Variable HOURGLASS_CURSOR is read-only.");
19083 return 1;
19084 }
19085
19086
19087 static PyObject *_wrap_HOURGLASS_CURSOR_get(void) {
19088 PyObject *pyobj;
19089
19090 pyobj = SWIG_NewPointerObj((void *)(wxHOURGLASS_CURSOR), SWIGTYPE_p_wxCursor, 0);
19091 return pyobj;
19092 }
19093
19094
19095 static int _wrap_CROSS_CURSOR_set(PyObject *) {
19096 PyErr_SetString(PyExc_TypeError,"Variable CROSS_CURSOR is read-only.");
19097 return 1;
19098 }
19099
19100
19101 static PyObject *_wrap_CROSS_CURSOR_get(void) {
19102 PyObject *pyobj;
19103
19104 pyobj = SWIG_NewPointerObj((void *)(wxCROSS_CURSOR), SWIGTYPE_p_wxCursor, 0);
19105 return pyobj;
19106 }
19107
19108
19109 static int _wrap_NullBitmap_set(PyObject *) {
19110 PyErr_SetString(PyExc_TypeError,"Variable NullBitmap is read-only.");
19111 return 1;
19112 }
19113
19114
19115 static PyObject *_wrap_NullBitmap_get(void) {
19116 PyObject *pyobj;
19117
19118 pyobj = SWIG_NewPointerObj((void *)(&wxNullBitmap), SWIGTYPE_p_wxBitmap, 0);
19119 return pyobj;
19120 }
19121
19122
19123 static int _wrap_NullIcon_set(PyObject *) {
19124 PyErr_SetString(PyExc_TypeError,"Variable NullIcon is read-only.");
19125 return 1;
19126 }
19127
19128
19129 static PyObject *_wrap_NullIcon_get(void) {
19130 PyObject *pyobj;
19131
19132 pyobj = SWIG_NewPointerObj((void *)(&wxNullIcon), SWIGTYPE_p_wxIcon, 0);
19133 return pyobj;
19134 }
19135
19136
19137 static int _wrap_NullCursor_set(PyObject *) {
19138 PyErr_SetString(PyExc_TypeError,"Variable NullCursor is read-only.");
19139 return 1;
19140 }
19141
19142
19143 static PyObject *_wrap_NullCursor_get(void) {
19144 PyObject *pyobj;
19145
19146 pyobj = SWIG_NewPointerObj((void *)(&wxNullCursor), SWIGTYPE_p_wxCursor, 0);
19147 return pyobj;
19148 }
19149
19150
19151 static int _wrap_NullPen_set(PyObject *) {
19152 PyErr_SetString(PyExc_TypeError,"Variable NullPen is read-only.");
19153 return 1;
19154 }
19155
19156
19157 static PyObject *_wrap_NullPen_get(void) {
19158 PyObject *pyobj;
19159
19160 pyobj = SWIG_NewPointerObj((void *)(&wxNullPen), SWIGTYPE_p_wxPen, 0);
19161 return pyobj;
19162 }
19163
19164
19165 static int _wrap_NullBrush_set(PyObject *) {
19166 PyErr_SetString(PyExc_TypeError,"Variable NullBrush is read-only.");
19167 return 1;
19168 }
19169
19170
19171 static PyObject *_wrap_NullBrush_get(void) {
19172 PyObject *pyobj;
19173
19174 pyobj = SWIG_NewPointerObj((void *)(&wxNullBrush), SWIGTYPE_p_wxBrush, 0);
19175 return pyobj;
19176 }
19177
19178
19179 static int _wrap_NullPalette_set(PyObject *) {
19180 PyErr_SetString(PyExc_TypeError,"Variable NullPalette is read-only.");
19181 return 1;
19182 }
19183
19184
19185 static PyObject *_wrap_NullPalette_get(void) {
19186 PyObject *pyobj;
19187
19188 pyobj = SWIG_NewPointerObj((void *)(&wxNullPalette), SWIGTYPE_p_wxPalette, 0);
19189 return pyobj;
19190 }
19191
19192
19193 static int _wrap_NullFont_set(PyObject *) {
19194 PyErr_SetString(PyExc_TypeError,"Variable NullFont is read-only.");
19195 return 1;
19196 }
19197
19198
19199 static PyObject *_wrap_NullFont_get(void) {
19200 PyObject *pyobj;
19201
19202 pyobj = SWIG_NewPointerObj((void *)(&wxNullFont), SWIGTYPE_p_wxFont, 0);
19203 return pyobj;
19204 }
19205
19206
19207 static int _wrap_NullColour_set(PyObject *) {
19208 PyErr_SetString(PyExc_TypeError,"Variable NullColour is read-only.");
19209 return 1;
19210 }
19211
19212
19213 static PyObject *_wrap_NullColour_get(void) {
19214 PyObject *pyobj;
19215
19216 pyobj = SWIG_NewPointerObj((void *)(&wxNullColour), SWIGTYPE_p_wxColour, 0);
19217 return pyobj;
19218 }
19219
19220
19221 static PyObject *_wrap_PenList_AddPen(PyObject *, PyObject *args, PyObject *kwargs) {
19222 PyObject *resultobj;
19223 wxPenList *arg1 = (wxPenList *) 0 ;
19224 wxPen *arg2 = (wxPen *) 0 ;
19225 PyObject * obj0 = 0 ;
19226 PyObject * obj1 = 0 ;
19227 char *kwnames[] = {
19228 (char *) "self",(char *) "pen", NULL
19229 };
19230
19231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_AddPen",kwnames,&obj0,&obj1)) goto fail;
19232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19233 if (SWIG_arg_fail(1)) SWIG_fail;
19234 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
19235 if (SWIG_arg_fail(2)) SWIG_fail;
19236 {
19237 PyThreadState* __tstate = wxPyBeginAllowThreads();
19238 (arg1)->AddPen(arg2);
19239
19240 wxPyEndAllowThreads(__tstate);
19241 if (PyErr_Occurred()) SWIG_fail;
19242 }
19243 Py_INCREF(Py_None); resultobj = Py_None;
19244 return resultobj;
19245 fail:
19246 return NULL;
19247 }
19248
19249
19250 static PyObject *_wrap_PenList_FindOrCreatePen(PyObject *, PyObject *args, PyObject *kwargs) {
19251 PyObject *resultobj;
19252 wxPenList *arg1 = (wxPenList *) 0 ;
19253 wxColour *arg2 = 0 ;
19254 int arg3 ;
19255 int arg4 ;
19256 wxPen *result;
19257 wxColour temp2 ;
19258 PyObject * obj0 = 0 ;
19259 PyObject * obj1 = 0 ;
19260 PyObject * obj2 = 0 ;
19261 PyObject * obj3 = 0 ;
19262 char *kwnames[] = {
19263 (char *) "self",(char *) "colour",(char *) "width",(char *) "style", NULL
19264 };
19265
19266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PenList_FindOrCreatePen",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19268 if (SWIG_arg_fail(1)) SWIG_fail;
19269 {
19270 arg2 = &temp2;
19271 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19272 }
19273 {
19274 arg3 = (int)(SWIG_As_int(obj2));
19275 if (SWIG_arg_fail(3)) SWIG_fail;
19276 }
19277 {
19278 arg4 = (int)(SWIG_As_int(obj3));
19279 if (SWIG_arg_fail(4)) SWIG_fail;
19280 }
19281 {
19282 PyThreadState* __tstate = wxPyBeginAllowThreads();
19283 result = (wxPen *)(arg1)->FindOrCreatePen((wxColour const &)*arg2,arg3,arg4);
19284
19285 wxPyEndAllowThreads(__tstate);
19286 if (PyErr_Occurred()) SWIG_fail;
19287 }
19288 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 0);
19289 return resultobj;
19290 fail:
19291 return NULL;
19292 }
19293
19294
19295 static PyObject *_wrap_PenList_RemovePen(PyObject *, PyObject *args, PyObject *kwargs) {
19296 PyObject *resultobj;
19297 wxPenList *arg1 = (wxPenList *) 0 ;
19298 wxPen *arg2 = (wxPen *) 0 ;
19299 PyObject * obj0 = 0 ;
19300 PyObject * obj1 = 0 ;
19301 char *kwnames[] = {
19302 (char *) "self",(char *) "pen", NULL
19303 };
19304
19305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_RemovePen",kwnames,&obj0,&obj1)) goto fail;
19306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19307 if (SWIG_arg_fail(1)) SWIG_fail;
19308 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
19309 if (SWIG_arg_fail(2)) SWIG_fail;
19310 {
19311 PyThreadState* __tstate = wxPyBeginAllowThreads();
19312 (arg1)->RemovePen(arg2);
19313
19314 wxPyEndAllowThreads(__tstate);
19315 if (PyErr_Occurred()) SWIG_fail;
19316 }
19317 Py_INCREF(Py_None); resultobj = Py_None;
19318 return resultobj;
19319 fail:
19320 return NULL;
19321 }
19322
19323
19324 static PyObject *_wrap_PenList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
19325 PyObject *resultobj;
19326 wxPenList *arg1 = (wxPenList *) 0 ;
19327 int result;
19328 PyObject * obj0 = 0 ;
19329 char *kwnames[] = {
19330 (char *) "self", NULL
19331 };
19332
19333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PenList_GetCount",kwnames,&obj0)) goto fail;
19334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19335 if (SWIG_arg_fail(1)) SWIG_fail;
19336 {
19337 PyThreadState* __tstate = wxPyBeginAllowThreads();
19338 result = (int)(arg1)->GetCount();
19339
19340 wxPyEndAllowThreads(__tstate);
19341 if (PyErr_Occurred()) SWIG_fail;
19342 }
19343 {
19344 resultobj = SWIG_From_int((int)(result));
19345 }
19346 return resultobj;
19347 fail:
19348 return NULL;
19349 }
19350
19351
19352 static PyObject * PenList_swigregister(PyObject *, PyObject *args) {
19353 PyObject *obj;
19354 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19355 SWIG_TypeClientData(SWIGTYPE_p_wxPenList, obj);
19356 Py_INCREF(obj);
19357 return Py_BuildValue((char *)"");
19358 }
19359 static PyObject *_wrap_BrushList_AddBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19360 PyObject *resultobj;
19361 wxBrushList *arg1 = (wxBrushList *) 0 ;
19362 wxBrush *arg2 = (wxBrush *) 0 ;
19363 PyObject * obj0 = 0 ;
19364 PyObject * obj1 = 0 ;
19365 char *kwnames[] = {
19366 (char *) "self",(char *) "brush", NULL
19367 };
19368
19369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_AddBrush",kwnames,&obj0,&obj1)) goto fail;
19370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19371 if (SWIG_arg_fail(1)) SWIG_fail;
19372 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
19373 if (SWIG_arg_fail(2)) SWIG_fail;
19374 {
19375 PyThreadState* __tstate = wxPyBeginAllowThreads();
19376 (arg1)->AddBrush(arg2);
19377
19378 wxPyEndAllowThreads(__tstate);
19379 if (PyErr_Occurred()) SWIG_fail;
19380 }
19381 Py_INCREF(Py_None); resultobj = Py_None;
19382 return resultobj;
19383 fail:
19384 return NULL;
19385 }
19386
19387
19388 static PyObject *_wrap_BrushList_FindOrCreateBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19389 PyObject *resultobj;
19390 wxBrushList *arg1 = (wxBrushList *) 0 ;
19391 wxColour *arg2 = 0 ;
19392 int arg3 ;
19393 wxBrush *result;
19394 wxColour temp2 ;
19395 PyObject * obj0 = 0 ;
19396 PyObject * obj1 = 0 ;
19397 PyObject * obj2 = 0 ;
19398 char *kwnames[] = {
19399 (char *) "self",(char *) "colour",(char *) "style", NULL
19400 };
19401
19402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:BrushList_FindOrCreateBrush",kwnames,&obj0,&obj1,&obj2)) goto fail;
19403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19404 if (SWIG_arg_fail(1)) SWIG_fail;
19405 {
19406 arg2 = &temp2;
19407 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19408 }
19409 {
19410 arg3 = (int)(SWIG_As_int(obj2));
19411 if (SWIG_arg_fail(3)) SWIG_fail;
19412 }
19413 {
19414 PyThreadState* __tstate = wxPyBeginAllowThreads();
19415 result = (wxBrush *)(arg1)->FindOrCreateBrush((wxColour const &)*arg2,arg3);
19416
19417 wxPyEndAllowThreads(__tstate);
19418 if (PyErr_Occurred()) SWIG_fail;
19419 }
19420 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 0);
19421 return resultobj;
19422 fail:
19423 return NULL;
19424 }
19425
19426
19427 static PyObject *_wrap_BrushList_RemoveBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19428 PyObject *resultobj;
19429 wxBrushList *arg1 = (wxBrushList *) 0 ;
19430 wxBrush *arg2 = (wxBrush *) 0 ;
19431 PyObject * obj0 = 0 ;
19432 PyObject * obj1 = 0 ;
19433 char *kwnames[] = {
19434 (char *) "self",(char *) "brush", NULL
19435 };
19436
19437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_RemoveBrush",kwnames,&obj0,&obj1)) goto fail;
19438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19439 if (SWIG_arg_fail(1)) SWIG_fail;
19440 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
19441 if (SWIG_arg_fail(2)) SWIG_fail;
19442 {
19443 PyThreadState* __tstate = wxPyBeginAllowThreads();
19444 (arg1)->RemoveBrush(arg2);
19445
19446 wxPyEndAllowThreads(__tstate);
19447 if (PyErr_Occurred()) SWIG_fail;
19448 }
19449 Py_INCREF(Py_None); resultobj = Py_None;
19450 return resultobj;
19451 fail:
19452 return NULL;
19453 }
19454
19455
19456 static PyObject *_wrap_BrushList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
19457 PyObject *resultobj;
19458 wxBrushList *arg1 = (wxBrushList *) 0 ;
19459 int result;
19460 PyObject * obj0 = 0 ;
19461 char *kwnames[] = {
19462 (char *) "self", NULL
19463 };
19464
19465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BrushList_GetCount",kwnames,&obj0)) goto fail;
19466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19467 if (SWIG_arg_fail(1)) SWIG_fail;
19468 {
19469 PyThreadState* __tstate = wxPyBeginAllowThreads();
19470 result = (int)(arg1)->GetCount();
19471
19472 wxPyEndAllowThreads(__tstate);
19473 if (PyErr_Occurred()) SWIG_fail;
19474 }
19475 {
19476 resultobj = SWIG_From_int((int)(result));
19477 }
19478 return resultobj;
19479 fail:
19480 return NULL;
19481 }
19482
19483
19484 static PyObject * BrushList_swigregister(PyObject *, PyObject *args) {
19485 PyObject *obj;
19486 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19487 SWIG_TypeClientData(SWIGTYPE_p_wxBrushList, obj);
19488 Py_INCREF(obj);
19489 return Py_BuildValue((char *)"");
19490 }
19491 static PyObject *_wrap_new_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
19492 PyObject *resultobj;
19493 wxColourDatabase *result;
19494 char *kwnames[] = {
19495 NULL
19496 };
19497
19498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ColourDatabase",kwnames)) goto fail;
19499 {
19500 if (!wxPyCheckForApp()) SWIG_fail;
19501 PyThreadState* __tstate = wxPyBeginAllowThreads();
19502 result = (wxColourDatabase *)new wxColourDatabase();
19503
19504 wxPyEndAllowThreads(__tstate);
19505 if (PyErr_Occurred()) SWIG_fail;
19506 }
19507 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColourDatabase, 1);
19508 return resultobj;
19509 fail:
19510 return NULL;
19511 }
19512
19513
19514 static PyObject *_wrap_delete_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
19515 PyObject *resultobj;
19516 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19517 PyObject * obj0 = 0 ;
19518 char *kwnames[] = {
19519 (char *) "self", NULL
19520 };
19521
19522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ColourDatabase",kwnames,&obj0)) goto fail;
19523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19524 if (SWIG_arg_fail(1)) SWIG_fail;
19525 {
19526 PyThreadState* __tstate = wxPyBeginAllowThreads();
19527 delete arg1;
19528
19529 wxPyEndAllowThreads(__tstate);
19530 if (PyErr_Occurred()) SWIG_fail;
19531 }
19532 Py_INCREF(Py_None); resultobj = Py_None;
19533 return resultobj;
19534 fail:
19535 return NULL;
19536 }
19537
19538
19539 static PyObject *_wrap_ColourDatabase_Find(PyObject *, PyObject *args, PyObject *kwargs) {
19540 PyObject *resultobj;
19541 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19542 wxString *arg2 = 0 ;
19543 wxColour result;
19544 bool temp2 = false ;
19545 PyObject * obj0 = 0 ;
19546 PyObject * obj1 = 0 ;
19547 char *kwnames[] = {
19548 (char *) "self",(char *) "name", NULL
19549 };
19550
19551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_Find",kwnames,&obj0,&obj1)) goto fail;
19552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19553 if (SWIG_arg_fail(1)) SWIG_fail;
19554 {
19555 arg2 = wxString_in_helper(obj1);
19556 if (arg2 == NULL) SWIG_fail;
19557 temp2 = true;
19558 }
19559 {
19560 PyThreadState* __tstate = wxPyBeginAllowThreads();
19561 result = ((wxColourDatabase const *)arg1)->Find((wxString const &)*arg2);
19562
19563 wxPyEndAllowThreads(__tstate);
19564 if (PyErr_Occurred()) SWIG_fail;
19565 }
19566 {
19567 wxColour * resultptr;
19568 resultptr = new wxColour((wxColour &)(result));
19569 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
19570 }
19571 {
19572 if (temp2)
19573 delete arg2;
19574 }
19575 return resultobj;
19576 fail:
19577 {
19578 if (temp2)
19579 delete arg2;
19580 }
19581 return NULL;
19582 }
19583
19584
19585 static PyObject *_wrap_ColourDatabase_FindName(PyObject *, PyObject *args, PyObject *kwargs) {
19586 PyObject *resultobj;
19587 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19588 wxColour *arg2 = 0 ;
19589 wxString result;
19590 wxColour temp2 ;
19591 PyObject * obj0 = 0 ;
19592 PyObject * obj1 = 0 ;
19593 char *kwnames[] = {
19594 (char *) "self",(char *) "colour", NULL
19595 };
19596
19597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_FindName",kwnames,&obj0,&obj1)) goto fail;
19598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19599 if (SWIG_arg_fail(1)) SWIG_fail;
19600 {
19601 arg2 = &temp2;
19602 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19603 }
19604 {
19605 PyThreadState* __tstate = wxPyBeginAllowThreads();
19606 result = ((wxColourDatabase const *)arg1)->FindName((wxColour const &)*arg2);
19607
19608 wxPyEndAllowThreads(__tstate);
19609 if (PyErr_Occurred()) SWIG_fail;
19610 }
19611 {
19612 #if wxUSE_UNICODE
19613 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19614 #else
19615 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19616 #endif
19617 }
19618 return resultobj;
19619 fail:
19620 return NULL;
19621 }
19622
19623
19624 static PyObject *_wrap_ColourDatabase_AddColour(PyObject *, PyObject *args, PyObject *kwargs) {
19625 PyObject *resultobj;
19626 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19627 wxString *arg2 = 0 ;
19628 wxColour *arg3 = 0 ;
19629 bool temp2 = false ;
19630 wxColour temp3 ;
19631 PyObject * obj0 = 0 ;
19632 PyObject * obj1 = 0 ;
19633 PyObject * obj2 = 0 ;
19634 char *kwnames[] = {
19635 (char *) "self",(char *) "name",(char *) "colour", NULL
19636 };
19637
19638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ColourDatabase_AddColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
19639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19640 if (SWIG_arg_fail(1)) SWIG_fail;
19641 {
19642 arg2 = wxString_in_helper(obj1);
19643 if (arg2 == NULL) SWIG_fail;
19644 temp2 = true;
19645 }
19646 {
19647 arg3 = &temp3;
19648 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
19649 }
19650 {
19651 PyThreadState* __tstate = wxPyBeginAllowThreads();
19652 (arg1)->AddColour((wxString const &)*arg2,(wxColour const &)*arg3);
19653
19654 wxPyEndAllowThreads(__tstate);
19655 if (PyErr_Occurred()) SWIG_fail;
19656 }
19657 Py_INCREF(Py_None); resultobj = Py_None;
19658 {
19659 if (temp2)
19660 delete arg2;
19661 }
19662 return resultobj;
19663 fail:
19664 {
19665 if (temp2)
19666 delete arg2;
19667 }
19668 return NULL;
19669 }
19670
19671
19672 static PyObject *_wrap_ColourDatabase_Append(PyObject *, PyObject *args, PyObject *kwargs) {
19673 PyObject *resultobj;
19674 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19675 wxString *arg2 = 0 ;
19676 int arg3 ;
19677 int arg4 ;
19678 int arg5 ;
19679 bool temp2 = false ;
19680 PyObject * obj0 = 0 ;
19681 PyObject * obj1 = 0 ;
19682 PyObject * obj2 = 0 ;
19683 PyObject * obj3 = 0 ;
19684 PyObject * obj4 = 0 ;
19685 char *kwnames[] = {
19686 (char *) "self",(char *) "name",(char *) "red",(char *) "green",(char *) "blue", NULL
19687 };
19688
19689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:ColourDatabase_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19691 if (SWIG_arg_fail(1)) SWIG_fail;
19692 {
19693 arg2 = wxString_in_helper(obj1);
19694 if (arg2 == NULL) SWIG_fail;
19695 temp2 = true;
19696 }
19697 {
19698 arg3 = (int)(SWIG_As_int(obj2));
19699 if (SWIG_arg_fail(3)) SWIG_fail;
19700 }
19701 {
19702 arg4 = (int)(SWIG_As_int(obj3));
19703 if (SWIG_arg_fail(4)) SWIG_fail;
19704 }
19705 {
19706 arg5 = (int)(SWIG_As_int(obj4));
19707 if (SWIG_arg_fail(5)) SWIG_fail;
19708 }
19709 {
19710 PyThreadState* __tstate = wxPyBeginAllowThreads();
19711 wxColourDatabase_Append(arg1,(wxString const &)*arg2,arg3,arg4,arg5);
19712
19713 wxPyEndAllowThreads(__tstate);
19714 if (PyErr_Occurred()) SWIG_fail;
19715 }
19716 Py_INCREF(Py_None); resultobj = Py_None;
19717 {
19718 if (temp2)
19719 delete arg2;
19720 }
19721 return resultobj;
19722 fail:
19723 {
19724 if (temp2)
19725 delete arg2;
19726 }
19727 return NULL;
19728 }
19729
19730
19731 static PyObject * ColourDatabase_swigregister(PyObject *, PyObject *args) {
19732 PyObject *obj;
19733 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19734 SWIG_TypeClientData(SWIGTYPE_p_wxColourDatabase, obj);
19735 Py_INCREF(obj);
19736 return Py_BuildValue((char *)"");
19737 }
19738 static PyObject *_wrap_FontList_AddFont(PyObject *, PyObject *args, PyObject *kwargs) {
19739 PyObject *resultobj;
19740 wxFontList *arg1 = (wxFontList *) 0 ;
19741 wxFont *arg2 = (wxFont *) 0 ;
19742 PyObject * obj0 = 0 ;
19743 PyObject * obj1 = 0 ;
19744 char *kwnames[] = {
19745 (char *) "self",(char *) "font", NULL
19746 };
19747
19748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_AddFont",kwnames,&obj0,&obj1)) goto fail;
19749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
19750 if (SWIG_arg_fail(1)) SWIG_fail;
19751 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
19752 if (SWIG_arg_fail(2)) SWIG_fail;
19753 {
19754 PyThreadState* __tstate = wxPyBeginAllowThreads();
19755 (arg1)->AddFont(arg2);
19756
19757 wxPyEndAllowThreads(__tstate);
19758 if (PyErr_Occurred()) SWIG_fail;
19759 }
19760 Py_INCREF(Py_None); resultobj = Py_None;
19761 return resultobj;
19762 fail:
19763 return NULL;
19764 }
19765
19766
19767 static PyObject *_wrap_FontList_FindOrCreateFont(PyObject *, PyObject *args, PyObject *kwargs) {
19768 PyObject *resultobj;
19769 wxFontList *arg1 = (wxFontList *) 0 ;
19770 int arg2 ;
19771 int arg3 ;
19772 int arg4 ;
19773 int arg5 ;
19774 bool arg6 = (bool) false ;
19775 wxString const &arg7_defvalue = wxPyEmptyString ;
19776 wxString *arg7 = (wxString *) &arg7_defvalue ;
19777 wxFontEncoding arg8 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
19778 wxFont *result;
19779 bool temp7 = false ;
19780 PyObject * obj0 = 0 ;
19781 PyObject * obj1 = 0 ;
19782 PyObject * obj2 = 0 ;
19783 PyObject * obj3 = 0 ;
19784 PyObject * obj4 = 0 ;
19785 PyObject * obj5 = 0 ;
19786 PyObject * obj6 = 0 ;
19787 PyObject * obj7 = 0 ;
19788 char *kwnames[] = {
19789 (char *) "self",(char *) "point_size",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "facename",(char *) "encoding", NULL
19790 };
19791
19792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:FontList_FindOrCreateFont",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
19793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
19794 if (SWIG_arg_fail(1)) SWIG_fail;
19795 {
19796 arg2 = (int)(SWIG_As_int(obj1));
19797 if (SWIG_arg_fail(2)) SWIG_fail;
19798 }
19799 {
19800 arg3 = (int)(SWIG_As_int(obj2));
19801 if (SWIG_arg_fail(3)) SWIG_fail;
19802 }
19803 {
19804 arg4 = (int)(SWIG_As_int(obj3));
19805 if (SWIG_arg_fail(4)) SWIG_fail;
19806 }
19807 {
19808 arg5 = (int)(SWIG_As_int(obj4));
19809 if (SWIG_arg_fail(5)) SWIG_fail;
19810 }
19811 if (obj5) {
19812 {
19813 arg6 = (bool)(SWIG_As_bool(obj5));
19814 if (SWIG_arg_fail(6)) SWIG_fail;
19815 }
19816 }
19817 if (obj6) {
19818 {
19819 arg7 = wxString_in_helper(obj6);
19820 if (arg7 == NULL) SWIG_fail;
19821 temp7 = true;
19822 }
19823 }
19824 if (obj7) {
19825 {
19826 arg8 = (wxFontEncoding)(SWIG_As_int(obj7));
19827 if (SWIG_arg_fail(8)) SWIG_fail;
19828 }
19829 }
19830 {
19831 PyThreadState* __tstate = wxPyBeginAllowThreads();
19832 result = (wxFont *)(arg1)->FindOrCreateFont(arg2,arg3,arg4,arg5,arg6,(wxString const &)*arg7,(wxFontEncoding )arg8);
19833
19834 wxPyEndAllowThreads(__tstate);
19835 if (PyErr_Occurred()) SWIG_fail;
19836 }
19837 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
19838 {
19839 if (temp7)
19840 delete arg7;
19841 }
19842 return resultobj;
19843 fail:
19844 {
19845 if (temp7)
19846 delete arg7;
19847 }
19848 return NULL;
19849 }
19850
19851
19852 static PyObject *_wrap_FontList_RemoveFont(PyObject *, PyObject *args, PyObject *kwargs) {
19853 PyObject *resultobj;
19854 wxFontList *arg1 = (wxFontList *) 0 ;
19855 wxFont *arg2 = (wxFont *) 0 ;
19856 PyObject * obj0 = 0 ;
19857 PyObject * obj1 = 0 ;
19858 char *kwnames[] = {
19859 (char *) "self",(char *) "font", NULL
19860 };
19861
19862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_RemoveFont",kwnames,&obj0,&obj1)) goto fail;
19863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
19864 if (SWIG_arg_fail(1)) SWIG_fail;
19865 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
19866 if (SWIG_arg_fail(2)) SWIG_fail;
19867 {
19868 PyThreadState* __tstate = wxPyBeginAllowThreads();
19869 (arg1)->RemoveFont(arg2);
19870
19871 wxPyEndAllowThreads(__tstate);
19872 if (PyErr_Occurred()) SWIG_fail;
19873 }
19874 Py_INCREF(Py_None); resultobj = Py_None;
19875 return resultobj;
19876 fail:
19877 return NULL;
19878 }
19879
19880
19881 static PyObject *_wrap_FontList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
19882 PyObject *resultobj;
19883 wxFontList *arg1 = (wxFontList *) 0 ;
19884 int result;
19885 PyObject * obj0 = 0 ;
19886 char *kwnames[] = {
19887 (char *) "self", NULL
19888 };
19889
19890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontList_GetCount",kwnames,&obj0)) goto fail;
19891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
19892 if (SWIG_arg_fail(1)) SWIG_fail;
19893 {
19894 PyThreadState* __tstate = wxPyBeginAllowThreads();
19895 result = (int)(arg1)->GetCount();
19896
19897 wxPyEndAllowThreads(__tstate);
19898 if (PyErr_Occurred()) SWIG_fail;
19899 }
19900 {
19901 resultobj = SWIG_From_int((int)(result));
19902 }
19903 return resultobj;
19904 fail:
19905 return NULL;
19906 }
19907
19908
19909 static PyObject * FontList_swigregister(PyObject *, PyObject *args) {
19910 PyObject *obj;
19911 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19912 SWIG_TypeClientData(SWIGTYPE_p_wxFontList, obj);
19913 Py_INCREF(obj);
19914 return Py_BuildValue((char *)"");
19915 }
19916 static int _wrap_TheFontList_set(PyObject *) {
19917 PyErr_SetString(PyExc_TypeError,"Variable TheFontList is read-only.");
19918 return 1;
19919 }
19920
19921
19922 static PyObject *_wrap_TheFontList_get(void) {
19923 PyObject *pyobj;
19924
19925 pyobj = SWIG_NewPointerObj((void *)(wxTheFontList), SWIGTYPE_p_wxFontList, 0);
19926 return pyobj;
19927 }
19928
19929
19930 static int _wrap_ThePenList_set(PyObject *) {
19931 PyErr_SetString(PyExc_TypeError,"Variable ThePenList is read-only.");
19932 return 1;
19933 }
19934
19935
19936 static PyObject *_wrap_ThePenList_get(void) {
19937 PyObject *pyobj;
19938
19939 pyobj = SWIG_NewPointerObj((void *)(wxThePenList), SWIGTYPE_p_wxPenList, 0);
19940 return pyobj;
19941 }
19942
19943
19944 static int _wrap_TheBrushList_set(PyObject *) {
19945 PyErr_SetString(PyExc_TypeError,"Variable TheBrushList is read-only.");
19946 return 1;
19947 }
19948
19949
19950 static PyObject *_wrap_TheBrushList_get(void) {
19951 PyObject *pyobj;
19952
19953 pyobj = SWIG_NewPointerObj((void *)(wxTheBrushList), SWIGTYPE_p_wxBrushList, 0);
19954 return pyobj;
19955 }
19956
19957
19958 static int _wrap_TheColourDatabase_set(PyObject *) {
19959 PyErr_SetString(PyExc_TypeError,"Variable TheColourDatabase is read-only.");
19960 return 1;
19961 }
19962
19963
19964 static PyObject *_wrap_TheColourDatabase_get(void) {
19965 PyObject *pyobj;
19966
19967 pyobj = SWIG_NewPointerObj((void *)(wxTheColourDatabase), SWIGTYPE_p_wxColourDatabase, 0);
19968 return pyobj;
19969 }
19970
19971
19972 static PyObject *_wrap_new_Effects(PyObject *, PyObject *args, PyObject *kwargs) {
19973 PyObject *resultobj;
19974 wxEffects *result;
19975 char *kwnames[] = {
19976 NULL
19977 };
19978
19979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Effects",kwnames)) goto fail;
19980 {
19981 PyThreadState* __tstate = wxPyBeginAllowThreads();
19982 result = (wxEffects *)new wxEffects();
19983
19984 wxPyEndAllowThreads(__tstate);
19985 if (PyErr_Occurred()) SWIG_fail;
19986 }
19987 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEffects, 1);
19988 return resultobj;
19989 fail:
19990 return NULL;
19991 }
19992
19993
19994 static PyObject *_wrap_Effects_GetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
19995 PyObject *resultobj;
19996 wxEffects *arg1 = (wxEffects *) 0 ;
19997 wxColour result;
19998 PyObject * obj0 = 0 ;
19999 char *kwnames[] = {
20000 (char *) "self", NULL
20001 };
20002
20003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetHighlightColour",kwnames,&obj0)) goto fail;
20004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20005 if (SWIG_arg_fail(1)) SWIG_fail;
20006 {
20007 PyThreadState* __tstate = wxPyBeginAllowThreads();
20008 result = ((wxEffects const *)arg1)->GetHighlightColour();
20009
20010 wxPyEndAllowThreads(__tstate);
20011 if (PyErr_Occurred()) SWIG_fail;
20012 }
20013 {
20014 wxColour * resultptr;
20015 resultptr = new wxColour((wxColour &)(result));
20016 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20017 }
20018 return resultobj;
20019 fail:
20020 return NULL;
20021 }
20022
20023
20024 static PyObject *_wrap_Effects_GetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20025 PyObject *resultobj;
20026 wxEffects *arg1 = (wxEffects *) 0 ;
20027 wxColour result;
20028 PyObject * obj0 = 0 ;
20029 char *kwnames[] = {
20030 (char *) "self", NULL
20031 };
20032
20033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetLightShadow",kwnames,&obj0)) goto fail;
20034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20035 if (SWIG_arg_fail(1)) SWIG_fail;
20036 {
20037 PyThreadState* __tstate = wxPyBeginAllowThreads();
20038 result = ((wxEffects const *)arg1)->GetLightShadow();
20039
20040 wxPyEndAllowThreads(__tstate);
20041 if (PyErr_Occurred()) SWIG_fail;
20042 }
20043 {
20044 wxColour * resultptr;
20045 resultptr = new wxColour((wxColour &)(result));
20046 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20047 }
20048 return resultobj;
20049 fail:
20050 return NULL;
20051 }
20052
20053
20054 static PyObject *_wrap_Effects_GetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
20055 PyObject *resultobj;
20056 wxEffects *arg1 = (wxEffects *) 0 ;
20057 wxColour result;
20058 PyObject * obj0 = 0 ;
20059 char *kwnames[] = {
20060 (char *) "self", NULL
20061 };
20062
20063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetFaceColour",kwnames,&obj0)) goto fail;
20064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20065 if (SWIG_arg_fail(1)) SWIG_fail;
20066 {
20067 PyThreadState* __tstate = wxPyBeginAllowThreads();
20068 result = ((wxEffects const *)arg1)->GetFaceColour();
20069
20070 wxPyEndAllowThreads(__tstate);
20071 if (PyErr_Occurred()) SWIG_fail;
20072 }
20073 {
20074 wxColour * resultptr;
20075 resultptr = new wxColour((wxColour &)(result));
20076 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20077 }
20078 return resultobj;
20079 fail:
20080 return NULL;
20081 }
20082
20083
20084 static PyObject *_wrap_Effects_GetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20085 PyObject *resultobj;
20086 wxEffects *arg1 = (wxEffects *) 0 ;
20087 wxColour result;
20088 PyObject * obj0 = 0 ;
20089 char *kwnames[] = {
20090 (char *) "self", NULL
20091 };
20092
20093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetMediumShadow",kwnames,&obj0)) goto fail;
20094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20095 if (SWIG_arg_fail(1)) SWIG_fail;
20096 {
20097 PyThreadState* __tstate = wxPyBeginAllowThreads();
20098 result = ((wxEffects const *)arg1)->GetMediumShadow();
20099
20100 wxPyEndAllowThreads(__tstate);
20101 if (PyErr_Occurred()) SWIG_fail;
20102 }
20103 {
20104 wxColour * resultptr;
20105 resultptr = new wxColour((wxColour &)(result));
20106 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20107 }
20108 return resultobj;
20109 fail:
20110 return NULL;
20111 }
20112
20113
20114 static PyObject *_wrap_Effects_GetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20115 PyObject *resultobj;
20116 wxEffects *arg1 = (wxEffects *) 0 ;
20117 wxColour result;
20118 PyObject * obj0 = 0 ;
20119 char *kwnames[] = {
20120 (char *) "self", NULL
20121 };
20122
20123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetDarkShadow",kwnames,&obj0)) goto fail;
20124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20125 if (SWIG_arg_fail(1)) SWIG_fail;
20126 {
20127 PyThreadState* __tstate = wxPyBeginAllowThreads();
20128 result = ((wxEffects const *)arg1)->GetDarkShadow();
20129
20130 wxPyEndAllowThreads(__tstate);
20131 if (PyErr_Occurred()) SWIG_fail;
20132 }
20133 {
20134 wxColour * resultptr;
20135 resultptr = new wxColour((wxColour &)(result));
20136 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20137 }
20138 return resultobj;
20139 fail:
20140 return NULL;
20141 }
20142
20143
20144 static PyObject *_wrap_Effects_SetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
20145 PyObject *resultobj;
20146 wxEffects *arg1 = (wxEffects *) 0 ;
20147 wxColour *arg2 = 0 ;
20148 wxColour temp2 ;
20149 PyObject * obj0 = 0 ;
20150 PyObject * obj1 = 0 ;
20151 char *kwnames[] = {
20152 (char *) "self",(char *) "c", NULL
20153 };
20154
20155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetHighlightColour",kwnames,&obj0,&obj1)) goto fail;
20156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20157 if (SWIG_arg_fail(1)) SWIG_fail;
20158 {
20159 arg2 = &temp2;
20160 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20161 }
20162 {
20163 PyThreadState* __tstate = wxPyBeginAllowThreads();
20164 (arg1)->SetHighlightColour((wxColour const &)*arg2);
20165
20166 wxPyEndAllowThreads(__tstate);
20167 if (PyErr_Occurred()) SWIG_fail;
20168 }
20169 Py_INCREF(Py_None); resultobj = Py_None;
20170 return resultobj;
20171 fail:
20172 return NULL;
20173 }
20174
20175
20176 static PyObject *_wrap_Effects_SetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20177 PyObject *resultobj;
20178 wxEffects *arg1 = (wxEffects *) 0 ;
20179 wxColour *arg2 = 0 ;
20180 wxColour temp2 ;
20181 PyObject * obj0 = 0 ;
20182 PyObject * obj1 = 0 ;
20183 char *kwnames[] = {
20184 (char *) "self",(char *) "c", NULL
20185 };
20186
20187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetLightShadow",kwnames,&obj0,&obj1)) goto fail;
20188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20189 if (SWIG_arg_fail(1)) SWIG_fail;
20190 {
20191 arg2 = &temp2;
20192 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20193 }
20194 {
20195 PyThreadState* __tstate = wxPyBeginAllowThreads();
20196 (arg1)->SetLightShadow((wxColour const &)*arg2);
20197
20198 wxPyEndAllowThreads(__tstate);
20199 if (PyErr_Occurred()) SWIG_fail;
20200 }
20201 Py_INCREF(Py_None); resultobj = Py_None;
20202 return resultobj;
20203 fail:
20204 return NULL;
20205 }
20206
20207
20208 static PyObject *_wrap_Effects_SetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
20209 PyObject *resultobj;
20210 wxEffects *arg1 = (wxEffects *) 0 ;
20211 wxColour *arg2 = 0 ;
20212 wxColour temp2 ;
20213 PyObject * obj0 = 0 ;
20214 PyObject * obj1 = 0 ;
20215 char *kwnames[] = {
20216 (char *) "self",(char *) "c", NULL
20217 };
20218
20219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetFaceColour",kwnames,&obj0,&obj1)) goto fail;
20220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20221 if (SWIG_arg_fail(1)) SWIG_fail;
20222 {
20223 arg2 = &temp2;
20224 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20225 }
20226 {
20227 PyThreadState* __tstate = wxPyBeginAllowThreads();
20228 (arg1)->SetFaceColour((wxColour const &)*arg2);
20229
20230 wxPyEndAllowThreads(__tstate);
20231 if (PyErr_Occurred()) SWIG_fail;
20232 }
20233 Py_INCREF(Py_None); resultobj = Py_None;
20234 return resultobj;
20235 fail:
20236 return NULL;
20237 }
20238
20239
20240 static PyObject *_wrap_Effects_SetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20241 PyObject *resultobj;
20242 wxEffects *arg1 = (wxEffects *) 0 ;
20243 wxColour *arg2 = 0 ;
20244 wxColour temp2 ;
20245 PyObject * obj0 = 0 ;
20246 PyObject * obj1 = 0 ;
20247 char *kwnames[] = {
20248 (char *) "self",(char *) "c", NULL
20249 };
20250
20251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetMediumShadow",kwnames,&obj0,&obj1)) goto fail;
20252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20253 if (SWIG_arg_fail(1)) SWIG_fail;
20254 {
20255 arg2 = &temp2;
20256 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20257 }
20258 {
20259 PyThreadState* __tstate = wxPyBeginAllowThreads();
20260 (arg1)->SetMediumShadow((wxColour const &)*arg2);
20261
20262 wxPyEndAllowThreads(__tstate);
20263 if (PyErr_Occurred()) SWIG_fail;
20264 }
20265 Py_INCREF(Py_None); resultobj = Py_None;
20266 return resultobj;
20267 fail:
20268 return NULL;
20269 }
20270
20271
20272 static PyObject *_wrap_Effects_SetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20273 PyObject *resultobj;
20274 wxEffects *arg1 = (wxEffects *) 0 ;
20275 wxColour *arg2 = 0 ;
20276 wxColour temp2 ;
20277 PyObject * obj0 = 0 ;
20278 PyObject * obj1 = 0 ;
20279 char *kwnames[] = {
20280 (char *) "self",(char *) "c", NULL
20281 };
20282
20283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetDarkShadow",kwnames,&obj0,&obj1)) goto fail;
20284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20285 if (SWIG_arg_fail(1)) SWIG_fail;
20286 {
20287 arg2 = &temp2;
20288 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20289 }
20290 {
20291 PyThreadState* __tstate = wxPyBeginAllowThreads();
20292 (arg1)->SetDarkShadow((wxColour const &)*arg2);
20293
20294 wxPyEndAllowThreads(__tstate);
20295 if (PyErr_Occurred()) SWIG_fail;
20296 }
20297 Py_INCREF(Py_None); resultobj = Py_None;
20298 return resultobj;
20299 fail:
20300 return NULL;
20301 }
20302
20303
20304 static PyObject *_wrap_Effects_Set(PyObject *, PyObject *args, PyObject *kwargs) {
20305 PyObject *resultobj;
20306 wxEffects *arg1 = (wxEffects *) 0 ;
20307 wxColour *arg2 = 0 ;
20308 wxColour *arg3 = 0 ;
20309 wxColour *arg4 = 0 ;
20310 wxColour *arg5 = 0 ;
20311 wxColour *arg6 = 0 ;
20312 wxColour temp2 ;
20313 wxColour temp3 ;
20314 wxColour temp4 ;
20315 wxColour temp5 ;
20316 wxColour temp6 ;
20317 PyObject * obj0 = 0 ;
20318 PyObject * obj1 = 0 ;
20319 PyObject * obj2 = 0 ;
20320 PyObject * obj3 = 0 ;
20321 PyObject * obj4 = 0 ;
20322 PyObject * obj5 = 0 ;
20323 char *kwnames[] = {
20324 (char *) "self",(char *) "highlightColour",(char *) "lightShadow",(char *) "faceColour",(char *) "mediumShadow",(char *) "darkShadow", NULL
20325 };
20326
20327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Effects_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
20328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20329 if (SWIG_arg_fail(1)) SWIG_fail;
20330 {
20331 arg2 = &temp2;
20332 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20333 }
20334 {
20335 arg3 = &temp3;
20336 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
20337 }
20338 {
20339 arg4 = &temp4;
20340 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
20341 }
20342 {
20343 arg5 = &temp5;
20344 if ( ! wxColour_helper(obj4, &arg5)) SWIG_fail;
20345 }
20346 {
20347 arg6 = &temp6;
20348 if ( ! wxColour_helper(obj5, &arg6)) SWIG_fail;
20349 }
20350 {
20351 PyThreadState* __tstate = wxPyBeginAllowThreads();
20352 (arg1)->Set((wxColour const &)*arg2,(wxColour const &)*arg3,(wxColour const &)*arg4,(wxColour const &)*arg5,(wxColour const &)*arg6);
20353
20354 wxPyEndAllowThreads(__tstate);
20355 if (PyErr_Occurred()) SWIG_fail;
20356 }
20357 Py_INCREF(Py_None); resultobj = Py_None;
20358 return resultobj;
20359 fail:
20360 return NULL;
20361 }
20362
20363
20364 static PyObject *_wrap_Effects_DrawSunkenEdge(PyObject *, PyObject *args, PyObject *kwargs) {
20365 PyObject *resultobj;
20366 wxEffects *arg1 = (wxEffects *) 0 ;
20367 wxDC *arg2 = 0 ;
20368 wxRect *arg3 = 0 ;
20369 int arg4 = (int) 1 ;
20370 wxRect temp3 ;
20371 PyObject * obj0 = 0 ;
20372 PyObject * obj1 = 0 ;
20373 PyObject * obj2 = 0 ;
20374 PyObject * obj3 = 0 ;
20375 char *kwnames[] = {
20376 (char *) "self",(char *) "dc",(char *) "rect",(char *) "borderSize", NULL
20377 };
20378
20379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Effects_DrawSunkenEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20381 if (SWIG_arg_fail(1)) SWIG_fail;
20382 {
20383 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20384 if (SWIG_arg_fail(2)) SWIG_fail;
20385 if (arg2 == NULL) {
20386 SWIG_null_ref("wxDC");
20387 }
20388 if (SWIG_arg_fail(2)) SWIG_fail;
20389 }
20390 {
20391 arg3 = &temp3;
20392 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
20393 }
20394 if (obj3) {
20395 {
20396 arg4 = (int)(SWIG_As_int(obj3));
20397 if (SWIG_arg_fail(4)) SWIG_fail;
20398 }
20399 }
20400 {
20401 PyThreadState* __tstate = wxPyBeginAllowThreads();
20402 (arg1)->DrawSunkenEdge(*arg2,(wxRect const &)*arg3,arg4);
20403
20404 wxPyEndAllowThreads(__tstate);
20405 if (PyErr_Occurred()) SWIG_fail;
20406 }
20407 Py_INCREF(Py_None); resultobj = Py_None;
20408 return resultobj;
20409 fail:
20410 return NULL;
20411 }
20412
20413
20414 static PyObject *_wrap_Effects_TileBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
20415 PyObject *resultobj;
20416 wxEffects *arg1 = (wxEffects *) 0 ;
20417 wxRect *arg2 = 0 ;
20418 wxDC *arg3 = 0 ;
20419 wxBitmap *arg4 = 0 ;
20420 bool result;
20421 wxRect temp2 ;
20422 PyObject * obj0 = 0 ;
20423 PyObject * obj1 = 0 ;
20424 PyObject * obj2 = 0 ;
20425 PyObject * obj3 = 0 ;
20426 char *kwnames[] = {
20427 (char *) "self",(char *) "rect",(char *) "dc",(char *) "bitmap", NULL
20428 };
20429
20430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Effects_TileBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20432 if (SWIG_arg_fail(1)) SWIG_fail;
20433 {
20434 arg2 = &temp2;
20435 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
20436 }
20437 {
20438 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20439 if (SWIG_arg_fail(3)) SWIG_fail;
20440 if (arg3 == NULL) {
20441 SWIG_null_ref("wxDC");
20442 }
20443 if (SWIG_arg_fail(3)) SWIG_fail;
20444 }
20445 {
20446 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
20447 if (SWIG_arg_fail(4)) SWIG_fail;
20448 if (arg4 == NULL) {
20449 SWIG_null_ref("wxBitmap");
20450 }
20451 if (SWIG_arg_fail(4)) SWIG_fail;
20452 }
20453 {
20454 PyThreadState* __tstate = wxPyBeginAllowThreads();
20455 result = (bool)(arg1)->TileBitmap((wxRect const &)*arg2,*arg3,*arg4);
20456
20457 wxPyEndAllowThreads(__tstate);
20458 if (PyErr_Occurred()) SWIG_fail;
20459 }
20460 {
20461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20462 }
20463 return resultobj;
20464 fail:
20465 return NULL;
20466 }
20467
20468
20469 static PyObject * Effects_swigregister(PyObject *, PyObject *args) {
20470 PyObject *obj;
20471 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20472 SWIG_TypeClientData(SWIGTYPE_p_wxEffects, obj);
20473 Py_INCREF(obj);
20474 return Py_BuildValue((char *)"");
20475 }
20476 static PyMethodDef SwigMethods[] = {
20477 { (char *)"new_GDIObject", (PyCFunction) _wrap_new_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
20478 { (char *)"delete_GDIObject", (PyCFunction) _wrap_delete_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
20479 { (char *)"GDIObject_GetVisible", (PyCFunction) _wrap_GDIObject_GetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20480 { (char *)"GDIObject_SetVisible", (PyCFunction) _wrap_GDIObject_SetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20481 { (char *)"GDIObject_IsNull", (PyCFunction) _wrap_GDIObject_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
20482 { (char *)"GDIObject_swigregister", GDIObject_swigregister, METH_VARARGS, NULL},
20483 { (char *)"new_Colour", (PyCFunction) _wrap_new_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
20484 { (char *)"new_NamedColour", (PyCFunction) _wrap_new_NamedColour, METH_VARARGS | METH_KEYWORDS, NULL},
20485 { (char *)"new_ColourRGB", (PyCFunction) _wrap_new_ColourRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20486 { (char *)"delete_Colour", (PyCFunction) _wrap_delete_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
20487 { (char *)"Colour_Red", (PyCFunction) _wrap_Colour_Red, METH_VARARGS | METH_KEYWORDS, NULL},
20488 { (char *)"Colour_Green", (PyCFunction) _wrap_Colour_Green, METH_VARARGS | METH_KEYWORDS, NULL},
20489 { (char *)"Colour_Blue", (PyCFunction) _wrap_Colour_Blue, METH_VARARGS | METH_KEYWORDS, NULL},
20490 { (char *)"Colour_Ok", (PyCFunction) _wrap_Colour_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20491 { (char *)"Colour_Set", (PyCFunction) _wrap_Colour_Set, METH_VARARGS | METH_KEYWORDS, NULL},
20492 { (char *)"Colour_SetRGB", (PyCFunction) _wrap_Colour_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20493 { (char *)"Colour_SetFromName", (PyCFunction) _wrap_Colour_SetFromName, METH_VARARGS | METH_KEYWORDS, NULL},
20494 { (char *)"Colour_GetPixel", (PyCFunction) _wrap_Colour_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
20495 { (char *)"Colour___eq__", (PyCFunction) _wrap_Colour___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20496 { (char *)"Colour___ne__", (PyCFunction) _wrap_Colour___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20497 { (char *)"Colour_Get", (PyCFunction) _wrap_Colour_Get, METH_VARARGS | METH_KEYWORDS, NULL},
20498 { (char *)"Colour_GetRGB", (PyCFunction) _wrap_Colour_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20499 { (char *)"Colour_swigregister", Colour_swigregister, METH_VARARGS, NULL},
20500 { (char *)"new_Palette", (PyCFunction) _wrap_new_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
20501 { (char *)"delete_Palette", (PyCFunction) _wrap_delete_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
20502 { (char *)"Palette_GetPixel", (PyCFunction) _wrap_Palette_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
20503 { (char *)"Palette_GetRGB", (PyCFunction) _wrap_Palette_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20504 { (char *)"Palette_GetColoursCount", (PyCFunction) _wrap_Palette_GetColoursCount, METH_VARARGS | METH_KEYWORDS, NULL},
20505 { (char *)"Palette_Ok", (PyCFunction) _wrap_Palette_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20506 { (char *)"Palette_swigregister", Palette_swigregister, METH_VARARGS, NULL},
20507 { (char *)"new_Pen", (PyCFunction) _wrap_new_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
20508 { (char *)"delete_Pen", (PyCFunction) _wrap_delete_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
20509 { (char *)"Pen_GetCap", (PyCFunction) _wrap_Pen_GetCap, METH_VARARGS | METH_KEYWORDS, NULL},
20510 { (char *)"Pen_GetColour", (PyCFunction) _wrap_Pen_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20511 { (char *)"Pen_GetJoin", (PyCFunction) _wrap_Pen_GetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
20512 { (char *)"Pen_GetStyle", (PyCFunction) _wrap_Pen_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20513 { (char *)"Pen_GetWidth", (PyCFunction) _wrap_Pen_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20514 { (char *)"Pen_Ok", (PyCFunction) _wrap_Pen_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20515 { (char *)"Pen_SetCap", (PyCFunction) _wrap_Pen_SetCap, METH_VARARGS | METH_KEYWORDS, NULL},
20516 { (char *)"Pen_SetColour", (PyCFunction) _wrap_Pen_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20517 { (char *)"Pen_SetJoin", (PyCFunction) _wrap_Pen_SetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
20518 { (char *)"Pen_SetStyle", (PyCFunction) _wrap_Pen_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20519 { (char *)"Pen_SetWidth", (PyCFunction) _wrap_Pen_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20520 { (char *)"Pen_SetDashes", (PyCFunction) _wrap_Pen_SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
20521 { (char *)"Pen_GetDashes", (PyCFunction) _wrap_Pen_GetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
20522 { (char *)"Pen__SetDashes", (PyCFunction) _wrap_Pen__SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
20523 { (char *)"Pen_GetDashCount", (PyCFunction) _wrap_Pen_GetDashCount, METH_VARARGS | METH_KEYWORDS, NULL},
20524 { (char *)"Pen___eq__", (PyCFunction) _wrap_Pen___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20525 { (char *)"Pen___ne__", (PyCFunction) _wrap_Pen___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20526 { (char *)"Pen_swigregister", Pen_swigregister, METH_VARARGS, NULL},
20527 { (char *)"new_Brush", (PyCFunction) _wrap_new_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
20528 { (char *)"delete_Brush", (PyCFunction) _wrap_delete_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
20529 { (char *)"Brush_SetColour", (PyCFunction) _wrap_Brush_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20530 { (char *)"Brush_SetStyle", (PyCFunction) _wrap_Brush_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20531 { (char *)"Brush_SetStipple", (PyCFunction) _wrap_Brush_SetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
20532 { (char *)"Brush_GetColour", (PyCFunction) _wrap_Brush_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20533 { (char *)"Brush_GetStyle", (PyCFunction) _wrap_Brush_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20534 { (char *)"Brush_GetStipple", (PyCFunction) _wrap_Brush_GetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
20535 { (char *)"Brush_IsHatch", (PyCFunction) _wrap_Brush_IsHatch, METH_VARARGS | METH_KEYWORDS, NULL},
20536 { (char *)"Brush_Ok", (PyCFunction) _wrap_Brush_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20537 { (char *)"Brush_swigregister", Brush_swigregister, METH_VARARGS, NULL},
20538 { (char *)"new_Bitmap", (PyCFunction) _wrap_new_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20539 { (char *)"delete_Bitmap", (PyCFunction) _wrap_delete_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20540 { (char *)"new_EmptyBitmap", (PyCFunction) _wrap_new_EmptyBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20541 { (char *)"new_BitmapFromIcon", (PyCFunction) _wrap_new_BitmapFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20542 { (char *)"new_BitmapFromImage", (PyCFunction) _wrap_new_BitmapFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
20543 { (char *)"new_BitmapFromXPMData", (PyCFunction) _wrap_new_BitmapFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
20544 { (char *)"new_BitmapFromBits", (PyCFunction) _wrap_new_BitmapFromBits, METH_VARARGS | METH_KEYWORDS, NULL},
20545 { (char *)"Bitmap_Ok", (PyCFunction) _wrap_Bitmap_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20546 { (char *)"Bitmap_GetWidth", (PyCFunction) _wrap_Bitmap_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20547 { (char *)"Bitmap_GetHeight", (PyCFunction) _wrap_Bitmap_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20548 { (char *)"Bitmap_GetDepth", (PyCFunction) _wrap_Bitmap_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20549 { (char *)"Bitmap_GetSize", (PyCFunction) _wrap_Bitmap_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20550 { (char *)"Bitmap_ConvertToImage", (PyCFunction) _wrap_Bitmap_ConvertToImage, METH_VARARGS | METH_KEYWORDS, NULL},
20551 { (char *)"Bitmap_GetMask", (PyCFunction) _wrap_Bitmap_GetMask, METH_VARARGS | METH_KEYWORDS, NULL},
20552 { (char *)"Bitmap_SetMask", (PyCFunction) _wrap_Bitmap_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
20553 { (char *)"Bitmap_SetMaskColour", (PyCFunction) _wrap_Bitmap_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
20554 { (char *)"Bitmap_GetSubBitmap", (PyCFunction) _wrap_Bitmap_GetSubBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20555 { (char *)"Bitmap_SaveFile", (PyCFunction) _wrap_Bitmap_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
20556 { (char *)"Bitmap_LoadFile", (PyCFunction) _wrap_Bitmap_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
20557 { (char *)"Bitmap_GetPalette", (PyCFunction) _wrap_Bitmap_GetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
20558 { (char *)"Bitmap_CopyFromIcon", (PyCFunction) _wrap_Bitmap_CopyFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20559 { (char *)"Bitmap_SetHeight", (PyCFunction) _wrap_Bitmap_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20560 { (char *)"Bitmap_SetWidth", (PyCFunction) _wrap_Bitmap_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20561 { (char *)"Bitmap_SetDepth", (PyCFunction) _wrap_Bitmap_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20562 { (char *)"Bitmap_SetSize", (PyCFunction) _wrap_Bitmap_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20563 { (char *)"Bitmap___eq__", (PyCFunction) _wrap_Bitmap___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20564 { (char *)"Bitmap___ne__", (PyCFunction) _wrap_Bitmap___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20565 { (char *)"Bitmap_swigregister", Bitmap_swigregister, METH_VARARGS, NULL},
20566 { (char *)"new_Mask", (PyCFunction) _wrap_new_Mask, METH_VARARGS | METH_KEYWORDS, NULL},
20567 { (char *)"Mask_swigregister", Mask_swigregister, METH_VARARGS, NULL},
20568 { (char *)"new_Icon", (PyCFunction) _wrap_new_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
20569 { (char *)"delete_Icon", (PyCFunction) _wrap_delete_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
20570 { (char *)"new_EmptyIcon", (PyCFunction) _wrap_new_EmptyIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20571 { (char *)"new_IconFromLocation", (PyCFunction) _wrap_new_IconFromLocation, METH_VARARGS | METH_KEYWORDS, NULL},
20572 { (char *)"new_IconFromBitmap", (PyCFunction) _wrap_new_IconFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20573 { (char *)"new_IconFromXPMData", (PyCFunction) _wrap_new_IconFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
20574 { (char *)"Icon_LoadFile", (PyCFunction) _wrap_Icon_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
20575 { (char *)"Icon_Ok", (PyCFunction) _wrap_Icon_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20576 { (char *)"Icon_GetWidth", (PyCFunction) _wrap_Icon_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20577 { (char *)"Icon_GetHeight", (PyCFunction) _wrap_Icon_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20578 { (char *)"Icon_GetDepth", (PyCFunction) _wrap_Icon_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20579 { (char *)"Icon_SetWidth", (PyCFunction) _wrap_Icon_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20580 { (char *)"Icon_SetHeight", (PyCFunction) _wrap_Icon_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20581 { (char *)"Icon_SetDepth", (PyCFunction) _wrap_Icon_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20582 { (char *)"Icon_CopyFromBitmap", (PyCFunction) _wrap_Icon_CopyFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20583 { (char *)"Icon_swigregister", Icon_swigregister, METH_VARARGS, NULL},
20584 { (char *)"new_IconLocation", (PyCFunction) _wrap_new_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
20585 { (char *)"delete_IconLocation", (PyCFunction) _wrap_delete_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
20586 { (char *)"IconLocation_IsOk", (PyCFunction) _wrap_IconLocation_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
20587 { (char *)"IconLocation_SetFileName", (PyCFunction) _wrap_IconLocation_SetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
20588 { (char *)"IconLocation_GetFileName", (PyCFunction) _wrap_IconLocation_GetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
20589 { (char *)"IconLocation_SetIndex", (PyCFunction) _wrap_IconLocation_SetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
20590 { (char *)"IconLocation_GetIndex", (PyCFunction) _wrap_IconLocation_GetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
20591 { (char *)"IconLocation_swigregister", IconLocation_swigregister, METH_VARARGS, NULL},
20592 { (char *)"new_IconBundle", (PyCFunction) _wrap_new_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
20593 { (char *)"new_IconBundleFromFile", (PyCFunction) _wrap_new_IconBundleFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
20594 { (char *)"new_IconBundleFromIcon", (PyCFunction) _wrap_new_IconBundleFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20595 { (char *)"delete_IconBundle", (PyCFunction) _wrap_delete_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
20596 { (char *)"IconBundle_AddIcon", (PyCFunction) _wrap_IconBundle_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20597 { (char *)"IconBundle_AddIconFromFile", (PyCFunction) _wrap_IconBundle_AddIconFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
20598 { (char *)"IconBundle_GetIcon", (PyCFunction) _wrap_IconBundle_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20599 { (char *)"IconBundle_swigregister", IconBundle_swigregister, METH_VARARGS, NULL},
20600 { (char *)"new_Cursor", (PyCFunction) _wrap_new_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
20601 { (char *)"delete_Cursor", (PyCFunction) _wrap_delete_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
20602 { (char *)"new_StockCursor", (PyCFunction) _wrap_new_StockCursor, METH_VARARGS | METH_KEYWORDS, NULL},
20603 { (char *)"new_CursorFromImage", (PyCFunction) _wrap_new_CursorFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
20604 { (char *)"Cursor_Ok", (PyCFunction) _wrap_Cursor_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20605 { (char *)"Cursor_swigregister", Cursor_swigregister, METH_VARARGS, NULL},
20606 { (char *)"new_Region", (PyCFunction) _wrap_new_Region, METH_VARARGS | METH_KEYWORDS, NULL},
20607 { (char *)"new_RegionFromBitmap", (PyCFunction) _wrap_new_RegionFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20608 { (char *)"new_RegionFromBitmapColour", (PyCFunction) _wrap_new_RegionFromBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
20609 { (char *)"new_RegionFromPoints", (PyCFunction) _wrap_new_RegionFromPoints, METH_VARARGS | METH_KEYWORDS, NULL},
20610 { (char *)"delete_Region", (PyCFunction) _wrap_delete_Region, METH_VARARGS | METH_KEYWORDS, NULL},
20611 { (char *)"Region_Clear", (PyCFunction) _wrap_Region_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
20612 { (char *)"Region_Offset", (PyCFunction) _wrap_Region_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
20613 { (char *)"Region_Contains", (PyCFunction) _wrap_Region_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
20614 { (char *)"Region_ContainsPoint", (PyCFunction) _wrap_Region_ContainsPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20615 { (char *)"Region_ContainsRect", (PyCFunction) _wrap_Region_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
20616 { (char *)"Region_ContainsRectDim", (PyCFunction) _wrap_Region_ContainsRectDim, METH_VARARGS | METH_KEYWORDS, NULL},
20617 { (char *)"Region_GetBox", (PyCFunction) _wrap_Region_GetBox, METH_VARARGS | METH_KEYWORDS, NULL},
20618 { (char *)"Region_Intersect", (PyCFunction) _wrap_Region_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
20619 { (char *)"Region_IntersectRect", (PyCFunction) _wrap_Region_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
20620 { (char *)"Region_IntersectRegion", (PyCFunction) _wrap_Region_IntersectRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20621 { (char *)"Region_IsEmpty", (PyCFunction) _wrap_Region_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
20622 { (char *)"Region_Union", (PyCFunction) _wrap_Region_Union, METH_VARARGS | METH_KEYWORDS, NULL},
20623 { (char *)"Region_UnionRect", (PyCFunction) _wrap_Region_UnionRect, METH_VARARGS | METH_KEYWORDS, NULL},
20624 { (char *)"Region_UnionRegion", (PyCFunction) _wrap_Region_UnionRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20625 { (char *)"Region_Subtract", (PyCFunction) _wrap_Region_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
20626 { (char *)"Region_SubtractRect", (PyCFunction) _wrap_Region_SubtractRect, METH_VARARGS | METH_KEYWORDS, NULL},
20627 { (char *)"Region_SubtractRegion", (PyCFunction) _wrap_Region_SubtractRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20628 { (char *)"Region_Xor", (PyCFunction) _wrap_Region_Xor, METH_VARARGS | METH_KEYWORDS, NULL},
20629 { (char *)"Region_XorRect", (PyCFunction) _wrap_Region_XorRect, METH_VARARGS | METH_KEYWORDS, NULL},
20630 { (char *)"Region_XorRegion", (PyCFunction) _wrap_Region_XorRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20631 { (char *)"Region_ConvertToBitmap", (PyCFunction) _wrap_Region_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20632 { (char *)"Region_UnionBitmap", (PyCFunction) _wrap_Region_UnionBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20633 { (char *)"Region_UnionBitmapColour", (PyCFunction) _wrap_Region_UnionBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
20634 { (char *)"Region_swigregister", Region_swigregister, METH_VARARGS, NULL},
20635 { (char *)"new_RegionIterator", (PyCFunction) _wrap_new_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
20636 { (char *)"delete_RegionIterator", (PyCFunction) _wrap_delete_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
20637 { (char *)"RegionIterator_GetX", (PyCFunction) _wrap_RegionIterator_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
20638 { (char *)"RegionIterator_GetY", (PyCFunction) _wrap_RegionIterator_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
20639 { (char *)"RegionIterator_GetW", (PyCFunction) _wrap_RegionIterator_GetW, METH_VARARGS | METH_KEYWORDS, NULL},
20640 { (char *)"RegionIterator_GetWidth", (PyCFunction) _wrap_RegionIterator_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20641 { (char *)"RegionIterator_GetH", (PyCFunction) _wrap_RegionIterator_GetH, METH_VARARGS | METH_KEYWORDS, NULL},
20642 { (char *)"RegionIterator_GetHeight", (PyCFunction) _wrap_RegionIterator_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20643 { (char *)"RegionIterator_GetRect", (PyCFunction) _wrap_RegionIterator_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
20644 { (char *)"RegionIterator_HaveRects", (PyCFunction) _wrap_RegionIterator_HaveRects, METH_VARARGS | METH_KEYWORDS, NULL},
20645 { (char *)"RegionIterator_Reset", (PyCFunction) _wrap_RegionIterator_Reset, METH_VARARGS | METH_KEYWORDS, NULL},
20646 { (char *)"RegionIterator_Next", (PyCFunction) _wrap_RegionIterator_Next, METH_VARARGS | METH_KEYWORDS, NULL},
20647 { (char *)"RegionIterator___nonzero__", (PyCFunction) _wrap_RegionIterator___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
20648 { (char *)"RegionIterator_swigregister", RegionIterator_swigregister, METH_VARARGS, NULL},
20649 { (char *)"new_NativeFontInfo", (PyCFunction) _wrap_new_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20650 { (char *)"delete_NativeFontInfo", (PyCFunction) _wrap_delete_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20651 { (char *)"NativeFontInfo_Init", (PyCFunction) _wrap_NativeFontInfo_Init, METH_VARARGS | METH_KEYWORDS, NULL},
20652 { (char *)"NativeFontInfo_InitFromFont", (PyCFunction) _wrap_NativeFontInfo_InitFromFont, METH_VARARGS | METH_KEYWORDS, NULL},
20653 { (char *)"NativeFontInfo_GetPointSize", (PyCFunction) _wrap_NativeFontInfo_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20654 { (char *)"NativeFontInfo_GetStyle", (PyCFunction) _wrap_NativeFontInfo_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20655 { (char *)"NativeFontInfo_GetWeight", (PyCFunction) _wrap_NativeFontInfo_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20656 { (char *)"NativeFontInfo_GetUnderlined", (PyCFunction) _wrap_NativeFontInfo_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20657 { (char *)"NativeFontInfo_GetFaceName", (PyCFunction) _wrap_NativeFontInfo_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20658 { (char *)"NativeFontInfo_GetFamily", (PyCFunction) _wrap_NativeFontInfo_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20659 { (char *)"NativeFontInfo_GetEncoding", (PyCFunction) _wrap_NativeFontInfo_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20660 { (char *)"NativeFontInfo_SetPointSize", (PyCFunction) _wrap_NativeFontInfo_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20661 { (char *)"NativeFontInfo_SetStyle", (PyCFunction) _wrap_NativeFontInfo_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20662 { (char *)"NativeFontInfo_SetWeight", (PyCFunction) _wrap_NativeFontInfo_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20663 { (char *)"NativeFontInfo_SetUnderlined", (PyCFunction) _wrap_NativeFontInfo_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20664 { (char *)"NativeFontInfo_SetFaceName", (PyCFunction) _wrap_NativeFontInfo_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20665 { (char *)"NativeFontInfo_SetFamily", (PyCFunction) _wrap_NativeFontInfo_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20666 { (char *)"NativeFontInfo_SetEncoding", (PyCFunction) _wrap_NativeFontInfo_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20667 { (char *)"NativeFontInfo_FromString", (PyCFunction) _wrap_NativeFontInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
20668 { (char *)"NativeFontInfo_ToString", (PyCFunction) _wrap_NativeFontInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
20669 { (char *)"NativeFontInfo___str__", (PyCFunction) _wrap_NativeFontInfo___str__, METH_VARARGS | METH_KEYWORDS, NULL},
20670 { (char *)"NativeFontInfo_FromUserString", (PyCFunction) _wrap_NativeFontInfo_FromUserString, METH_VARARGS | METH_KEYWORDS, NULL},
20671 { (char *)"NativeFontInfo_ToUserString", (PyCFunction) _wrap_NativeFontInfo_ToUserString, METH_VARARGS | METH_KEYWORDS, NULL},
20672 { (char *)"NativeFontInfo_swigregister", NativeFontInfo_swigregister, METH_VARARGS, NULL},
20673 { (char *)"NativeEncodingInfo_facename_set", (PyCFunction) _wrap_NativeEncodingInfo_facename_set, METH_VARARGS | METH_KEYWORDS, NULL},
20674 { (char *)"NativeEncodingInfo_facename_get", (PyCFunction) _wrap_NativeEncodingInfo_facename_get, METH_VARARGS | METH_KEYWORDS, NULL},
20675 { (char *)"NativeEncodingInfo_encoding_set", (PyCFunction) _wrap_NativeEncodingInfo_encoding_set, METH_VARARGS | METH_KEYWORDS, NULL},
20676 { (char *)"NativeEncodingInfo_encoding_get", (PyCFunction) _wrap_NativeEncodingInfo_encoding_get, METH_VARARGS | METH_KEYWORDS, NULL},
20677 { (char *)"new_NativeEncodingInfo", (PyCFunction) _wrap_new_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20678 { (char *)"delete_NativeEncodingInfo", (PyCFunction) _wrap_delete_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20679 { (char *)"NativeEncodingInfo_FromString", (PyCFunction) _wrap_NativeEncodingInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
20680 { (char *)"NativeEncodingInfo_ToString", (PyCFunction) _wrap_NativeEncodingInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
20681 { (char *)"NativeEncodingInfo_swigregister", NativeEncodingInfo_swigregister, METH_VARARGS, NULL},
20682 { (char *)"GetNativeFontEncoding", (PyCFunction) _wrap_GetNativeFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20683 { (char *)"TestFontEncoding", (PyCFunction) _wrap_TestFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20684 { (char *)"new_FontMapper", (PyCFunction) _wrap_new_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
20685 { (char *)"delete_FontMapper", (PyCFunction) _wrap_delete_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
20686 { (char *)"FontMapper_Get", (PyCFunction) _wrap_FontMapper_Get, METH_VARARGS | METH_KEYWORDS, NULL},
20687 { (char *)"FontMapper_Set", (PyCFunction) _wrap_FontMapper_Set, METH_VARARGS | METH_KEYWORDS, NULL},
20688 { (char *)"FontMapper_CharsetToEncoding", (PyCFunction) _wrap_FontMapper_CharsetToEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20689 { (char *)"FontMapper_GetSupportedEncodingsCount", (PyCFunction) _wrap_FontMapper_GetSupportedEncodingsCount, METH_VARARGS | METH_KEYWORDS, NULL},
20690 { (char *)"FontMapper_GetEncoding", (PyCFunction) _wrap_FontMapper_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20691 { (char *)"FontMapper_GetEncodingName", (PyCFunction) _wrap_FontMapper_GetEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
20692 { (char *)"FontMapper_GetEncodingDescription", (PyCFunction) _wrap_FontMapper_GetEncodingDescription, METH_VARARGS | METH_KEYWORDS, NULL},
20693 { (char *)"FontMapper_GetEncodingFromName", (PyCFunction) _wrap_FontMapper_GetEncodingFromName, METH_VARARGS | METH_KEYWORDS, NULL},
20694 { (char *)"FontMapper_SetConfig", (PyCFunction) _wrap_FontMapper_SetConfig, METH_VARARGS | METH_KEYWORDS, NULL},
20695 { (char *)"FontMapper_SetConfigPath", (PyCFunction) _wrap_FontMapper_SetConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
20696 { (char *)"FontMapper_GetDefaultConfigPath", (PyCFunction) _wrap_FontMapper_GetDefaultConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
20697 { (char *)"FontMapper_GetAltForEncoding", (PyCFunction) _wrap_FontMapper_GetAltForEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20698 { (char *)"FontMapper_IsEncodingAvailable", (PyCFunction) _wrap_FontMapper_IsEncodingAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
20699 { (char *)"FontMapper_SetDialogParent", (PyCFunction) _wrap_FontMapper_SetDialogParent, METH_VARARGS | METH_KEYWORDS, NULL},
20700 { (char *)"FontMapper_SetDialogTitle", (PyCFunction) _wrap_FontMapper_SetDialogTitle, METH_VARARGS | METH_KEYWORDS, NULL},
20701 { (char *)"FontMapper_swigregister", FontMapper_swigregister, METH_VARARGS, NULL},
20702 { (char *)"new_Font", (PyCFunction) _wrap_new_Font, METH_VARARGS | METH_KEYWORDS, NULL},
20703 { (char *)"delete_Font", (PyCFunction) _wrap_delete_Font, METH_VARARGS | METH_KEYWORDS, NULL},
20704 { (char *)"new_FontFromNativeInfo", (PyCFunction) _wrap_new_FontFromNativeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20705 { (char *)"new_FontFromNativeInfoString", (PyCFunction) _wrap_new_FontFromNativeInfoString, METH_VARARGS | METH_KEYWORDS, NULL},
20706 { (char *)"new_Font2", (PyCFunction) _wrap_new_Font2, METH_VARARGS | METH_KEYWORDS, NULL},
20707 { (char *)"new_FontFromPixelSize", (PyCFunction) _wrap_new_FontFromPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20708 { (char *)"Font_Ok", (PyCFunction) _wrap_Font_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20709 { (char *)"Font___eq__", (PyCFunction) _wrap_Font___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20710 { (char *)"Font___ne__", (PyCFunction) _wrap_Font___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20711 { (char *)"Font_GetPointSize", (PyCFunction) _wrap_Font_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20712 { (char *)"Font_GetPixelSize", (PyCFunction) _wrap_Font_GetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20713 { (char *)"Font_IsUsingSizeInPixels", (PyCFunction) _wrap_Font_IsUsingSizeInPixels, METH_VARARGS | METH_KEYWORDS, NULL},
20714 { (char *)"Font_GetFamily", (PyCFunction) _wrap_Font_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20715 { (char *)"Font_GetStyle", (PyCFunction) _wrap_Font_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20716 { (char *)"Font_GetWeight", (PyCFunction) _wrap_Font_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20717 { (char *)"Font_GetUnderlined", (PyCFunction) _wrap_Font_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20718 { (char *)"Font_GetFaceName", (PyCFunction) _wrap_Font_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20719 { (char *)"Font_GetEncoding", (PyCFunction) _wrap_Font_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20720 { (char *)"Font_GetNativeFontInfo", (PyCFunction) _wrap_Font_GetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20721 { (char *)"Font_IsFixedWidth", (PyCFunction) _wrap_Font_IsFixedWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20722 { (char *)"Font_GetNativeFontInfoDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoDesc, METH_VARARGS | METH_KEYWORDS, NULL},
20723 { (char *)"Font_GetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
20724 { (char *)"Font_SetPointSize", (PyCFunction) _wrap_Font_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20725 { (char *)"Font_SetPixelSize", (PyCFunction) _wrap_Font_SetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20726 { (char *)"Font_SetFamily", (PyCFunction) _wrap_Font_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20727 { (char *)"Font_SetStyle", (PyCFunction) _wrap_Font_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20728 { (char *)"Font_SetWeight", (PyCFunction) _wrap_Font_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20729 { (char *)"Font_SetFaceName", (PyCFunction) _wrap_Font_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20730 { (char *)"Font_SetUnderlined", (PyCFunction) _wrap_Font_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20731 { (char *)"Font_SetEncoding", (PyCFunction) _wrap_Font_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20732 { (char *)"Font_SetNativeFontInfo", (PyCFunction) _wrap_Font_SetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20733 { (char *)"Font_SetNativeFontInfoFromString", (PyCFunction) _wrap_Font_SetNativeFontInfoFromString, METH_VARARGS | METH_KEYWORDS, NULL},
20734 { (char *)"Font_SetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_SetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
20735 { (char *)"Font_GetFamilyString", (PyCFunction) _wrap_Font_GetFamilyString, METH_VARARGS | METH_KEYWORDS, NULL},
20736 { (char *)"Font_GetStyleString", (PyCFunction) _wrap_Font_GetStyleString, METH_VARARGS | METH_KEYWORDS, NULL},
20737 { (char *)"Font_GetWeightString", (PyCFunction) _wrap_Font_GetWeightString, METH_VARARGS | METH_KEYWORDS, NULL},
20738 { (char *)"Font_SetNoAntiAliasing", (PyCFunction) _wrap_Font_SetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
20739 { (char *)"Font_GetNoAntiAliasing", (PyCFunction) _wrap_Font_GetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
20740 { (char *)"Font_GetDefaultEncoding", (PyCFunction) _wrap_Font_GetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20741 { (char *)"Font_SetDefaultEncoding", (PyCFunction) _wrap_Font_SetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20742 { (char *)"Font_swigregister", Font_swigregister, METH_VARARGS, NULL},
20743 { (char *)"new_FontEnumerator", (PyCFunction) _wrap_new_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
20744 { (char *)"delete_FontEnumerator", (PyCFunction) _wrap_delete_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
20745 { (char *)"FontEnumerator__setCallbackInfo", (PyCFunction) _wrap_FontEnumerator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20746 { (char *)"FontEnumerator_EnumerateFacenames", (PyCFunction) _wrap_FontEnumerator_EnumerateFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
20747 { (char *)"FontEnumerator_EnumerateEncodings", (PyCFunction) _wrap_FontEnumerator_EnumerateEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
20748 { (char *)"FontEnumerator_GetEncodings", (PyCFunction) _wrap_FontEnumerator_GetEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
20749 { (char *)"FontEnumerator_GetFacenames", (PyCFunction) _wrap_FontEnumerator_GetFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
20750 { (char *)"FontEnumerator_swigregister", FontEnumerator_swigregister, METH_VARARGS, NULL},
20751 { (char *)"LanguageInfo_Language_set", (PyCFunction) _wrap_LanguageInfo_Language_set, METH_VARARGS | METH_KEYWORDS, NULL},
20752 { (char *)"LanguageInfo_Language_get", (PyCFunction) _wrap_LanguageInfo_Language_get, METH_VARARGS | METH_KEYWORDS, NULL},
20753 { (char *)"LanguageInfo_CanonicalName_set", (PyCFunction) _wrap_LanguageInfo_CanonicalName_set, METH_VARARGS | METH_KEYWORDS, NULL},
20754 { (char *)"LanguageInfo_CanonicalName_get", (PyCFunction) _wrap_LanguageInfo_CanonicalName_get, METH_VARARGS | METH_KEYWORDS, NULL},
20755 { (char *)"LanguageInfo_Description_set", (PyCFunction) _wrap_LanguageInfo_Description_set, METH_VARARGS | METH_KEYWORDS, NULL},
20756 { (char *)"LanguageInfo_Description_get", (PyCFunction) _wrap_LanguageInfo_Description_get, METH_VARARGS | METH_KEYWORDS, NULL},
20757 { (char *)"LanguageInfo_swigregister", LanguageInfo_swigregister, METH_VARARGS, NULL},
20758 { (char *)"new_Locale", (PyCFunction) _wrap_new_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
20759 { (char *)"delete_Locale", (PyCFunction) _wrap_delete_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
20760 { (char *)"Locale_Init1", (PyCFunction) _wrap_Locale_Init1, METH_VARARGS | METH_KEYWORDS, NULL},
20761 { (char *)"Locale_Init2", (PyCFunction) _wrap_Locale_Init2, METH_VARARGS | METH_KEYWORDS, NULL},
20762 { (char *)"Locale_GetSystemLanguage", (PyCFunction) _wrap_Locale_GetSystemLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
20763 { (char *)"Locale_GetSystemEncoding", (PyCFunction) _wrap_Locale_GetSystemEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20764 { (char *)"Locale_GetSystemEncodingName", (PyCFunction) _wrap_Locale_GetSystemEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
20765 { (char *)"Locale_IsOk", (PyCFunction) _wrap_Locale_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
20766 { (char *)"Locale_GetLocale", (PyCFunction) _wrap_Locale_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
20767 { (char *)"Locale_GetLanguage", (PyCFunction) _wrap_Locale_GetLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
20768 { (char *)"Locale_GetSysName", (PyCFunction) _wrap_Locale_GetSysName, METH_VARARGS | METH_KEYWORDS, NULL},
20769 { (char *)"Locale_GetCanonicalName", (PyCFunction) _wrap_Locale_GetCanonicalName, METH_VARARGS | METH_KEYWORDS, NULL},
20770 { (char *)"Locale_AddCatalogLookupPathPrefix", (PyCFunction) _wrap_Locale_AddCatalogLookupPathPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
20771 { (char *)"Locale_AddCatalog", (PyCFunction) _wrap_Locale_AddCatalog, METH_VARARGS | METH_KEYWORDS, NULL},
20772 { (char *)"Locale_IsLoaded", (PyCFunction) _wrap_Locale_IsLoaded, METH_VARARGS | METH_KEYWORDS, NULL},
20773 { (char *)"Locale_GetLanguageInfo", (PyCFunction) _wrap_Locale_GetLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20774 { (char *)"Locale_GetLanguageName", (PyCFunction) _wrap_Locale_GetLanguageName, METH_VARARGS | METH_KEYWORDS, NULL},
20775 { (char *)"Locale_FindLanguageInfo", (PyCFunction) _wrap_Locale_FindLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20776 { (char *)"Locale_AddLanguage", (PyCFunction) _wrap_Locale_AddLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
20777 { (char *)"Locale_GetString", (PyCFunction) _wrap_Locale_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
20778 { (char *)"Locale_GetName", (PyCFunction) _wrap_Locale_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
20779 { (char *)"Locale_swigregister", Locale_swigregister, METH_VARARGS, NULL},
20780 { (char *)"GetLocale", (PyCFunction) _wrap_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
20781 { (char *)"GetTranslation", _wrap_GetTranslation, METH_VARARGS, NULL},
20782 { (char *)"new_EncodingConverter", (PyCFunction) _wrap_new_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
20783 { (char *)"delete_EncodingConverter", (PyCFunction) _wrap_delete_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
20784 { (char *)"EncodingConverter_Init", (PyCFunction) _wrap_EncodingConverter_Init, METH_VARARGS | METH_KEYWORDS, NULL},
20785 { (char *)"EncodingConverter_Convert", (PyCFunction) _wrap_EncodingConverter_Convert, METH_VARARGS | METH_KEYWORDS, NULL},
20786 { (char *)"EncodingConverter_GetPlatformEquivalents", (PyCFunction) _wrap_EncodingConverter_GetPlatformEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
20787 { (char *)"EncodingConverter_GetAllEquivalents", (PyCFunction) _wrap_EncodingConverter_GetAllEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
20788 { (char *)"EncodingConverter_CanConvert", (PyCFunction) _wrap_EncodingConverter_CanConvert, METH_VARARGS | METH_KEYWORDS, NULL},
20789 { (char *)"EncodingConverter_swigregister", EncodingConverter_swigregister, METH_VARARGS, NULL},
20790 { (char *)"delete_DC", (PyCFunction) _wrap_delete_DC, METH_VARARGS | METH_KEYWORDS, NULL},
20791 { (char *)"DC_BeginDrawing", (PyCFunction) _wrap_DC_BeginDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
20792 { (char *)"DC_EndDrawing", (PyCFunction) _wrap_DC_EndDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
20793 { (char *)"DC_FloodFill", (PyCFunction) _wrap_DC_FloodFill, METH_VARARGS | METH_KEYWORDS, NULL},
20794 { (char *)"DC_FloodFillPoint", (PyCFunction) _wrap_DC_FloodFillPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20795 { (char *)"DC_GetPixel", (PyCFunction) _wrap_DC_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
20796 { (char *)"DC_GetPixelPoint", (PyCFunction) _wrap_DC_GetPixelPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20797 { (char *)"DC_DrawLine", (PyCFunction) _wrap_DC_DrawLine, METH_VARARGS | METH_KEYWORDS, NULL},
20798 { (char *)"DC_DrawLinePoint", (PyCFunction) _wrap_DC_DrawLinePoint, METH_VARARGS | METH_KEYWORDS, NULL},
20799 { (char *)"DC_CrossHair", (PyCFunction) _wrap_DC_CrossHair, METH_VARARGS | METH_KEYWORDS, NULL},
20800 { (char *)"DC_CrossHairPoint", (PyCFunction) _wrap_DC_CrossHairPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20801 { (char *)"DC_DrawArc", (PyCFunction) _wrap_DC_DrawArc, METH_VARARGS | METH_KEYWORDS, NULL},
20802 { (char *)"DC_DrawArcPoint", (PyCFunction) _wrap_DC_DrawArcPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20803 { (char *)"DC_DrawCheckMark", (PyCFunction) _wrap_DC_DrawCheckMark, METH_VARARGS | METH_KEYWORDS, NULL},
20804 { (char *)"DC_DrawCheckMarkRect", (PyCFunction) _wrap_DC_DrawCheckMarkRect, METH_VARARGS | METH_KEYWORDS, NULL},
20805 { (char *)"DC_DrawEllipticArc", (PyCFunction) _wrap_DC_DrawEllipticArc, METH_VARARGS | METH_KEYWORDS, NULL},
20806 { (char *)"DC_DrawEllipticArcPointSize", (PyCFunction) _wrap_DC_DrawEllipticArcPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20807 { (char *)"DC_DrawPoint", (PyCFunction) _wrap_DC_DrawPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20808 { (char *)"DC_DrawPointPoint", (PyCFunction) _wrap_DC_DrawPointPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20809 { (char *)"DC_DrawRectangle", (PyCFunction) _wrap_DC_DrawRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
20810 { (char *)"DC_DrawRectangleRect", (PyCFunction) _wrap_DC_DrawRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
20811 { (char *)"DC_DrawRectanglePointSize", (PyCFunction) _wrap_DC_DrawRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20812 { (char *)"DC_DrawRoundedRectangle", (PyCFunction) _wrap_DC_DrawRoundedRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
20813 { (char *)"DC_DrawRoundedRectangleRect", (PyCFunction) _wrap_DC_DrawRoundedRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
20814 { (char *)"DC_DrawRoundedRectanglePointSize", (PyCFunction) _wrap_DC_DrawRoundedRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20815 { (char *)"DC_DrawCircle", (PyCFunction) _wrap_DC_DrawCircle, METH_VARARGS | METH_KEYWORDS, NULL},
20816 { (char *)"DC_DrawCirclePoint", (PyCFunction) _wrap_DC_DrawCirclePoint, METH_VARARGS | METH_KEYWORDS, NULL},
20817 { (char *)"DC_DrawEllipse", (PyCFunction) _wrap_DC_DrawEllipse, METH_VARARGS | METH_KEYWORDS, NULL},
20818 { (char *)"DC_DrawEllipseRect", (PyCFunction) _wrap_DC_DrawEllipseRect, METH_VARARGS | METH_KEYWORDS, NULL},
20819 { (char *)"DC_DrawEllipsePointSize", (PyCFunction) _wrap_DC_DrawEllipsePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20820 { (char *)"DC_DrawIcon", (PyCFunction) _wrap_DC_DrawIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20821 { (char *)"DC_DrawIconPoint", (PyCFunction) _wrap_DC_DrawIconPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20822 { (char *)"DC_DrawBitmap", (PyCFunction) _wrap_DC_DrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20823 { (char *)"DC_DrawBitmapPoint", (PyCFunction) _wrap_DC_DrawBitmapPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20824 { (char *)"DC_DrawText", (PyCFunction) _wrap_DC_DrawText, METH_VARARGS | METH_KEYWORDS, NULL},
20825 { (char *)"DC_DrawTextPoint", (PyCFunction) _wrap_DC_DrawTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20826 { (char *)"DC_DrawRotatedText", (PyCFunction) _wrap_DC_DrawRotatedText, METH_VARARGS | METH_KEYWORDS, NULL},
20827 { (char *)"DC_DrawRotatedTextPoint", (PyCFunction) _wrap_DC_DrawRotatedTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20828 { (char *)"DC_Blit", (PyCFunction) _wrap_DC_Blit, METH_VARARGS | METH_KEYWORDS, NULL},
20829 { (char *)"DC_BlitPointSize", (PyCFunction) _wrap_DC_BlitPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20830 { (char *)"DC_SetClippingRegion", (PyCFunction) _wrap_DC_SetClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20831 { (char *)"DC_SetClippingRegionPointSize", (PyCFunction) _wrap_DC_SetClippingRegionPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20832 { (char *)"DC_SetClippingRegionAsRegion", (PyCFunction) _wrap_DC_SetClippingRegionAsRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20833 { (char *)"DC_SetClippingRect", (PyCFunction) _wrap_DC_SetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
20834 { (char *)"DC_DrawLines", (PyCFunction) _wrap_DC_DrawLines, METH_VARARGS | METH_KEYWORDS, NULL},
20835 { (char *)"DC_DrawPolygon", (PyCFunction) _wrap_DC_DrawPolygon, METH_VARARGS | METH_KEYWORDS, NULL},
20836 { (char *)"DC_DrawLabel", (PyCFunction) _wrap_DC_DrawLabel, METH_VARARGS | METH_KEYWORDS, NULL},
20837 { (char *)"DC_DrawImageLabel", (PyCFunction) _wrap_DC_DrawImageLabel, METH_VARARGS | METH_KEYWORDS, NULL},
20838 { (char *)"DC_DrawSpline", (PyCFunction) _wrap_DC_DrawSpline, METH_VARARGS | METH_KEYWORDS, NULL},
20839 { (char *)"DC_Clear", (PyCFunction) _wrap_DC_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
20840 { (char *)"DC_StartDoc", (PyCFunction) _wrap_DC_StartDoc, METH_VARARGS | METH_KEYWORDS, NULL},
20841 { (char *)"DC_EndDoc", (PyCFunction) _wrap_DC_EndDoc, METH_VARARGS | METH_KEYWORDS, NULL},
20842 { (char *)"DC_StartPage", (PyCFunction) _wrap_DC_StartPage, METH_VARARGS | METH_KEYWORDS, NULL},
20843 { (char *)"DC_EndPage", (PyCFunction) _wrap_DC_EndPage, METH_VARARGS | METH_KEYWORDS, NULL},
20844 { (char *)"DC_SetFont", (PyCFunction) _wrap_DC_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
20845 { (char *)"DC_SetPen", (PyCFunction) _wrap_DC_SetPen, METH_VARARGS | METH_KEYWORDS, NULL},
20846 { (char *)"DC_SetBrush", (PyCFunction) _wrap_DC_SetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
20847 { (char *)"DC_SetBackground", (PyCFunction) _wrap_DC_SetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20848 { (char *)"DC_SetBackgroundMode", (PyCFunction) _wrap_DC_SetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
20849 { (char *)"DC_SetPalette", (PyCFunction) _wrap_DC_SetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
20850 { (char *)"DC_DestroyClippingRegion", (PyCFunction) _wrap_DC_DestroyClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20851 { (char *)"DC_GetClippingBox", (PyCFunction) _wrap_DC_GetClippingBox, METH_VARARGS | METH_KEYWORDS, NULL},
20852 { (char *)"DC_GetClippingRect", (PyCFunction) _wrap_DC_GetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
20853 { (char *)"DC_GetCharHeight", (PyCFunction) _wrap_DC_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20854 { (char *)"DC_GetCharWidth", (PyCFunction) _wrap_DC_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20855 { (char *)"DC_GetTextExtent", (PyCFunction) _wrap_DC_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
20856 { (char *)"DC_GetFullTextExtent", (PyCFunction) _wrap_DC_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
20857 { (char *)"DC_GetMultiLineTextExtent", (PyCFunction) _wrap_DC_GetMultiLineTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
20858 { (char *)"DC_GetPartialTextExtents", (PyCFunction) _wrap_DC_GetPartialTextExtents, METH_VARARGS | METH_KEYWORDS, NULL},
20859 { (char *)"DC_GetSize", (PyCFunction) _wrap_DC_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20860 { (char *)"DC_GetSizeTuple", (PyCFunction) _wrap_DC_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
20861 { (char *)"DC_GetSizeMM", (PyCFunction) _wrap_DC_GetSizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
20862 { (char *)"DC_GetSizeMMTuple", (PyCFunction) _wrap_DC_GetSizeMMTuple, METH_VARARGS | METH_KEYWORDS, NULL},
20863 { (char *)"DC_DeviceToLogicalX", (PyCFunction) _wrap_DC_DeviceToLogicalX, METH_VARARGS | METH_KEYWORDS, NULL},
20864 { (char *)"DC_DeviceToLogicalY", (PyCFunction) _wrap_DC_DeviceToLogicalY, METH_VARARGS | METH_KEYWORDS, NULL},
20865 { (char *)"DC_DeviceToLogicalXRel", (PyCFunction) _wrap_DC_DeviceToLogicalXRel, METH_VARARGS | METH_KEYWORDS, NULL},
20866 { (char *)"DC_DeviceToLogicalYRel", (PyCFunction) _wrap_DC_DeviceToLogicalYRel, METH_VARARGS | METH_KEYWORDS, NULL},
20867 { (char *)"DC_LogicalToDeviceX", (PyCFunction) _wrap_DC_LogicalToDeviceX, METH_VARARGS | METH_KEYWORDS, NULL},
20868 { (char *)"DC_LogicalToDeviceY", (PyCFunction) _wrap_DC_LogicalToDeviceY, METH_VARARGS | METH_KEYWORDS, NULL},
20869 { (char *)"DC_LogicalToDeviceXRel", (PyCFunction) _wrap_DC_LogicalToDeviceXRel, METH_VARARGS | METH_KEYWORDS, NULL},
20870 { (char *)"DC_LogicalToDeviceYRel", (PyCFunction) _wrap_DC_LogicalToDeviceYRel, METH_VARARGS | METH_KEYWORDS, NULL},
20871 { (char *)"DC_CanDrawBitmap", (PyCFunction) _wrap_DC_CanDrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20872 { (char *)"DC_CanGetTextExtent", (PyCFunction) _wrap_DC_CanGetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
20873 { (char *)"DC_GetDepth", (PyCFunction) _wrap_DC_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20874 { (char *)"DC_GetPPI", (PyCFunction) _wrap_DC_GetPPI, METH_VARARGS | METH_KEYWORDS, NULL},
20875 { (char *)"DC_Ok", (PyCFunction) _wrap_DC_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20876 { (char *)"DC_GetBackgroundMode", (PyCFunction) _wrap_DC_GetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
20877 { (char *)"DC_GetBackground", (PyCFunction) _wrap_DC_GetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20878 { (char *)"DC_GetBrush", (PyCFunction) _wrap_DC_GetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
20879 { (char *)"DC_GetFont", (PyCFunction) _wrap_DC_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
20880 { (char *)"DC_GetPen", (PyCFunction) _wrap_DC_GetPen, METH_VARARGS | METH_KEYWORDS, NULL},
20881 { (char *)"DC_GetTextBackground", (PyCFunction) _wrap_DC_GetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20882 { (char *)"DC_GetTextForeground", (PyCFunction) _wrap_DC_GetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
20883 { (char *)"DC_SetTextForeground", (PyCFunction) _wrap_DC_SetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
20884 { (char *)"DC_SetTextBackground", (PyCFunction) _wrap_DC_SetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20885 { (char *)"DC_GetMapMode", (PyCFunction) _wrap_DC_GetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
20886 { (char *)"DC_SetMapMode", (PyCFunction) _wrap_DC_SetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
20887 { (char *)"DC_GetUserScale", (PyCFunction) _wrap_DC_GetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
20888 { (char *)"DC_SetUserScale", (PyCFunction) _wrap_DC_SetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
20889 { (char *)"DC_GetLogicalScale", (PyCFunction) _wrap_DC_GetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
20890 { (char *)"DC_SetLogicalScale", (PyCFunction) _wrap_DC_SetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
20891 { (char *)"DC_GetLogicalOrigin", (PyCFunction) _wrap_DC_GetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
20892 { (char *)"DC_GetLogicalOriginTuple", (PyCFunction) _wrap_DC_GetLogicalOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
20893 { (char *)"DC_SetLogicalOrigin", (PyCFunction) _wrap_DC_SetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
20894 { (char *)"DC_SetLogicalOriginPoint", (PyCFunction) _wrap_DC_SetLogicalOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20895 { (char *)"DC_GetDeviceOrigin", (PyCFunction) _wrap_DC_GetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
20896 { (char *)"DC_GetDeviceOriginTuple", (PyCFunction) _wrap_DC_GetDeviceOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
20897 { (char *)"DC_SetDeviceOrigin", (PyCFunction) _wrap_DC_SetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
20898 { (char *)"DC_SetDeviceOriginPoint", (PyCFunction) _wrap_DC_SetDeviceOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20899 { (char *)"DC_SetAxisOrientation", (PyCFunction) _wrap_DC_SetAxisOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
20900 { (char *)"DC_GetLogicalFunction", (PyCFunction) _wrap_DC_GetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
20901 { (char *)"DC_SetLogicalFunction", (PyCFunction) _wrap_DC_SetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
20902 { (char *)"DC_ComputeScaleAndOrigin", (PyCFunction) _wrap_DC_ComputeScaleAndOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
20903 { (char *)"DC_CalcBoundingBox", (PyCFunction) _wrap_DC_CalcBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
20904 { (char *)"DC_CalcBoundingBoxPoint", (PyCFunction) _wrap_DC_CalcBoundingBoxPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20905 { (char *)"DC_ResetBoundingBox", (PyCFunction) _wrap_DC_ResetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
20906 { (char *)"DC_MinX", (PyCFunction) _wrap_DC_MinX, METH_VARARGS | METH_KEYWORDS, NULL},
20907 { (char *)"DC_MaxX", (PyCFunction) _wrap_DC_MaxX, METH_VARARGS | METH_KEYWORDS, NULL},
20908 { (char *)"DC_MinY", (PyCFunction) _wrap_DC_MinY, METH_VARARGS | METH_KEYWORDS, NULL},
20909 { (char *)"DC_MaxY", (PyCFunction) _wrap_DC_MaxY, METH_VARARGS | METH_KEYWORDS, NULL},
20910 { (char *)"DC_GetBoundingBox", (PyCFunction) _wrap_DC_GetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
20911 { (char *)"DC__DrawPointList", (PyCFunction) _wrap_DC__DrawPointList, METH_VARARGS | METH_KEYWORDS, NULL},
20912 { (char *)"DC__DrawLineList", (PyCFunction) _wrap_DC__DrawLineList, METH_VARARGS | METH_KEYWORDS, NULL},
20913 { (char *)"DC__DrawRectangleList", (PyCFunction) _wrap_DC__DrawRectangleList, METH_VARARGS | METH_KEYWORDS, NULL},
20914 { (char *)"DC__DrawEllipseList", (PyCFunction) _wrap_DC__DrawEllipseList, METH_VARARGS | METH_KEYWORDS, NULL},
20915 { (char *)"DC__DrawPolygonList", (PyCFunction) _wrap_DC__DrawPolygonList, METH_VARARGS | METH_KEYWORDS, NULL},
20916 { (char *)"DC__DrawTextList", (PyCFunction) _wrap_DC__DrawTextList, METH_VARARGS | METH_KEYWORDS, NULL},
20917 { (char *)"DC_swigregister", DC_swigregister, METH_VARARGS, NULL},
20918 { (char *)"new_MemoryDC", (PyCFunction) _wrap_new_MemoryDC, METH_VARARGS | METH_KEYWORDS, NULL},
20919 { (char *)"new_MemoryDCFromDC", (PyCFunction) _wrap_new_MemoryDCFromDC, METH_VARARGS | METH_KEYWORDS, NULL},
20920 { (char *)"MemoryDC_SelectObject", (PyCFunction) _wrap_MemoryDC_SelectObject, METH_VARARGS | METH_KEYWORDS, NULL},
20921 { (char *)"MemoryDC_swigregister", MemoryDC_swigregister, METH_VARARGS, NULL},
20922 { (char *)"new_BufferedDC", _wrap_new_BufferedDC, METH_VARARGS, NULL},
20923 { (char *)"delete_BufferedDC", (PyCFunction) _wrap_delete_BufferedDC, METH_VARARGS | METH_KEYWORDS, NULL},
20924 { (char *)"BufferedDC_UnMask", (PyCFunction) _wrap_BufferedDC_UnMask, METH_VARARGS | METH_KEYWORDS, NULL},
20925 { (char *)"BufferedDC_swigregister", BufferedDC_swigregister, METH_VARARGS, NULL},
20926 { (char *)"new_BufferedPaintDC", (PyCFunction) _wrap_new_BufferedPaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
20927 { (char *)"BufferedPaintDC_swigregister", BufferedPaintDC_swigregister, METH_VARARGS, NULL},
20928 { (char *)"new_ScreenDC", (PyCFunction) _wrap_new_ScreenDC, METH_VARARGS | METH_KEYWORDS, NULL},
20929 { (char *)"ScreenDC_StartDrawingOnTopWin", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTopWin, METH_VARARGS | METH_KEYWORDS, NULL},
20930 { (char *)"ScreenDC_StartDrawingOnTop", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
20931 { (char *)"ScreenDC_EndDrawingOnTop", (PyCFunction) _wrap_ScreenDC_EndDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
20932 { (char *)"ScreenDC_swigregister", ScreenDC_swigregister, METH_VARARGS, NULL},
20933 { (char *)"new_ClientDC", (PyCFunction) _wrap_new_ClientDC, METH_VARARGS | METH_KEYWORDS, NULL},
20934 { (char *)"ClientDC_swigregister", ClientDC_swigregister, METH_VARARGS, NULL},
20935 { (char *)"new_PaintDC", (PyCFunction) _wrap_new_PaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
20936 { (char *)"PaintDC_swigregister", PaintDC_swigregister, METH_VARARGS, NULL},
20937 { (char *)"new_WindowDC", (PyCFunction) _wrap_new_WindowDC, METH_VARARGS | METH_KEYWORDS, NULL},
20938 { (char *)"WindowDC_swigregister", WindowDC_swigregister, METH_VARARGS, NULL},
20939 { (char *)"new_MirrorDC", (PyCFunction) _wrap_new_MirrorDC, METH_VARARGS | METH_KEYWORDS, NULL},
20940 { (char *)"MirrorDC_swigregister", MirrorDC_swigregister, METH_VARARGS, NULL},
20941 { (char *)"new_PostScriptDC", (PyCFunction) _wrap_new_PostScriptDC, METH_VARARGS | METH_KEYWORDS, NULL},
20942 { (char *)"PostScriptDC_GetPrintData", (PyCFunction) _wrap_PostScriptDC_GetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
20943 { (char *)"PostScriptDC_SetPrintData", (PyCFunction) _wrap_PostScriptDC_SetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
20944 { (char *)"PostScriptDC_SetResolution", (PyCFunction) _wrap_PostScriptDC_SetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
20945 { (char *)"PostScriptDC_GetResolution", (PyCFunction) _wrap_PostScriptDC_GetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
20946 { (char *)"PostScriptDC_swigregister", PostScriptDC_swigregister, METH_VARARGS, NULL},
20947 { (char *)"new_MetaFile", (PyCFunction) _wrap_new_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
20948 { (char *)"MetaFile_swigregister", MetaFile_swigregister, METH_VARARGS, NULL},
20949 { (char *)"new_MetaFileDC", (PyCFunction) _wrap_new_MetaFileDC, METH_VARARGS | METH_KEYWORDS, NULL},
20950 { (char *)"MetaFileDC_swigregister", MetaFileDC_swigregister, METH_VARARGS, NULL},
20951 { (char *)"new_PrinterDC", (PyCFunction) _wrap_new_PrinterDC, METH_VARARGS | METH_KEYWORDS, NULL},
20952 { (char *)"PrinterDC_swigregister", PrinterDC_swigregister, METH_VARARGS, NULL},
20953 { (char *)"new_ImageList", (PyCFunction) _wrap_new_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
20954 { (char *)"delete_ImageList", (PyCFunction) _wrap_delete_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
20955 { (char *)"ImageList_Add", (PyCFunction) _wrap_ImageList_Add, METH_VARARGS | METH_KEYWORDS, NULL},
20956 { (char *)"ImageList_AddWithColourMask", (PyCFunction) _wrap_ImageList_AddWithColourMask, METH_VARARGS | METH_KEYWORDS, NULL},
20957 { (char *)"ImageList_AddIcon", (PyCFunction) _wrap_ImageList_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20958 { (char *)"ImageList_GetBitmap", (PyCFunction) _wrap_ImageList_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20959 { (char *)"ImageList_GetIcon", (PyCFunction) _wrap_ImageList_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20960 { (char *)"ImageList_Replace", (PyCFunction) _wrap_ImageList_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
20961 { (char *)"ImageList_Draw", (PyCFunction) _wrap_ImageList_Draw, METH_VARARGS | METH_KEYWORDS, NULL},
20962 { (char *)"ImageList_GetImageCount", (PyCFunction) _wrap_ImageList_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
20963 { (char *)"ImageList_Remove", (PyCFunction) _wrap_ImageList_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
20964 { (char *)"ImageList_RemoveAll", (PyCFunction) _wrap_ImageList_RemoveAll, METH_VARARGS | METH_KEYWORDS, NULL},
20965 { (char *)"ImageList_GetSize", (PyCFunction) _wrap_ImageList_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20966 { (char *)"ImageList_swigregister", ImageList_swigregister, METH_VARARGS, NULL},
20967 { (char *)"PenList_AddPen", (PyCFunction) _wrap_PenList_AddPen, METH_VARARGS | METH_KEYWORDS, NULL},
20968 { (char *)"PenList_FindOrCreatePen", (PyCFunction) _wrap_PenList_FindOrCreatePen, METH_VARARGS | METH_KEYWORDS, NULL},
20969 { (char *)"PenList_RemovePen", (PyCFunction) _wrap_PenList_RemovePen, METH_VARARGS | METH_KEYWORDS, NULL},
20970 { (char *)"PenList_GetCount", (PyCFunction) _wrap_PenList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
20971 { (char *)"PenList_swigregister", PenList_swigregister, METH_VARARGS, NULL},
20972 { (char *)"BrushList_AddBrush", (PyCFunction) _wrap_BrushList_AddBrush, METH_VARARGS | METH_KEYWORDS, NULL},
20973 { (char *)"BrushList_FindOrCreateBrush", (PyCFunction) _wrap_BrushList_FindOrCreateBrush, METH_VARARGS | METH_KEYWORDS, NULL},
20974 { (char *)"BrushList_RemoveBrush", (PyCFunction) _wrap_BrushList_RemoveBrush, METH_VARARGS | METH_KEYWORDS, NULL},
20975 { (char *)"BrushList_GetCount", (PyCFunction) _wrap_BrushList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
20976 { (char *)"BrushList_swigregister", BrushList_swigregister, METH_VARARGS, NULL},
20977 { (char *)"new_ColourDatabase", (PyCFunction) _wrap_new_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
20978 { (char *)"delete_ColourDatabase", (PyCFunction) _wrap_delete_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
20979 { (char *)"ColourDatabase_Find", (PyCFunction) _wrap_ColourDatabase_Find, METH_VARARGS | METH_KEYWORDS, NULL},
20980 { (char *)"ColourDatabase_FindName", (PyCFunction) _wrap_ColourDatabase_FindName, METH_VARARGS | METH_KEYWORDS, NULL},
20981 { (char *)"ColourDatabase_AddColour", (PyCFunction) _wrap_ColourDatabase_AddColour, METH_VARARGS | METH_KEYWORDS, NULL},
20982 { (char *)"ColourDatabase_Append", (PyCFunction) _wrap_ColourDatabase_Append, METH_VARARGS | METH_KEYWORDS, NULL},
20983 { (char *)"ColourDatabase_swigregister", ColourDatabase_swigregister, METH_VARARGS, NULL},
20984 { (char *)"FontList_AddFont", (PyCFunction) _wrap_FontList_AddFont, METH_VARARGS | METH_KEYWORDS, NULL},
20985 { (char *)"FontList_FindOrCreateFont", (PyCFunction) _wrap_FontList_FindOrCreateFont, METH_VARARGS | METH_KEYWORDS, NULL},
20986 { (char *)"FontList_RemoveFont", (PyCFunction) _wrap_FontList_RemoveFont, METH_VARARGS | METH_KEYWORDS, NULL},
20987 { (char *)"FontList_GetCount", (PyCFunction) _wrap_FontList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
20988 { (char *)"FontList_swigregister", FontList_swigregister, METH_VARARGS, NULL},
20989 { (char *)"new_Effects", (PyCFunction) _wrap_new_Effects, METH_VARARGS | METH_KEYWORDS, NULL},
20990 { (char *)"Effects_GetHighlightColour", (PyCFunction) _wrap_Effects_GetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
20991 { (char *)"Effects_GetLightShadow", (PyCFunction) _wrap_Effects_GetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
20992 { (char *)"Effects_GetFaceColour", (PyCFunction) _wrap_Effects_GetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
20993 { (char *)"Effects_GetMediumShadow", (PyCFunction) _wrap_Effects_GetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
20994 { (char *)"Effects_GetDarkShadow", (PyCFunction) _wrap_Effects_GetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
20995 { (char *)"Effects_SetHighlightColour", (PyCFunction) _wrap_Effects_SetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
20996 { (char *)"Effects_SetLightShadow", (PyCFunction) _wrap_Effects_SetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
20997 { (char *)"Effects_SetFaceColour", (PyCFunction) _wrap_Effects_SetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
20998 { (char *)"Effects_SetMediumShadow", (PyCFunction) _wrap_Effects_SetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
20999 { (char *)"Effects_SetDarkShadow", (PyCFunction) _wrap_Effects_SetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21000 { (char *)"Effects_Set", (PyCFunction) _wrap_Effects_Set, METH_VARARGS | METH_KEYWORDS, NULL},
21001 { (char *)"Effects_DrawSunkenEdge", (PyCFunction) _wrap_Effects_DrawSunkenEdge, METH_VARARGS | METH_KEYWORDS, NULL},
21002 { (char *)"Effects_TileBitmap", (PyCFunction) _wrap_Effects_TileBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21003 { (char *)"Effects_swigregister", Effects_swigregister, METH_VARARGS, NULL},
21004 { NULL, NULL, 0, NULL }
21005 };
21006
21007
21008 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
21009
21010 static void *_p_wxBufferedDCTo_p_wxMemoryDC(void *x) {
21011 return (void *)((wxMemoryDC *) ((wxBufferedDC *) x));
21012 }
21013 static void *_p_wxBufferedPaintDCTo_p_wxMemoryDC(void *x) {
21014 return (void *)((wxMemoryDC *) (wxBufferedDC *) ((wxBufferedPaintDC *) x));
21015 }
21016 static void *_p_wxIconTo_p_wxGDIObject(void *x) {
21017 return (void *)((wxGDIObject *) ((wxIcon *) x));
21018 }
21019 static void *_p_wxPaletteTo_p_wxGDIObject(void *x) {
21020 return (void *)((wxGDIObject *) ((wxPalette *) x));
21021 }
21022 static void *_p_wxPenTo_p_wxGDIObject(void *x) {
21023 return (void *)((wxGDIObject *) ((wxPen *) x));
21024 }
21025 static void *_p_wxFontTo_p_wxGDIObject(void *x) {
21026 return (void *)((wxGDIObject *) ((wxFont *) x));
21027 }
21028 static void *_p_wxCursorTo_p_wxGDIObject(void *x) {
21029 return (void *)((wxGDIObject *) ((wxCursor *) x));
21030 }
21031 static void *_p_wxBitmapTo_p_wxGDIObject(void *x) {
21032 return (void *)((wxGDIObject *) ((wxBitmap *) x));
21033 }
21034 static void *_p_wxRegionTo_p_wxGDIObject(void *x) {
21035 return (void *)((wxGDIObject *) ((wxRegion *) x));
21036 }
21037 static void *_p_wxBrushTo_p_wxGDIObject(void *x) {
21038 return (void *)((wxGDIObject *) ((wxBrush *) x));
21039 }
21040 static void *_p_wxBufferedDCTo_p_wxDC(void *x) {
21041 return (void *)((wxDC *) (wxMemoryDC *) ((wxBufferedDC *) x));
21042 }
21043 static void *_p_wxScreenDCTo_p_wxDC(void *x) {
21044 return (void *)((wxDC *) ((wxScreenDC *) x));
21045 }
21046 static void *_p_wxMirrorDCTo_p_wxDC(void *x) {
21047 return (void *)((wxDC *) ((wxMirrorDC *) x));
21048 }
21049 static void *_p_wxMemoryDCTo_p_wxDC(void *x) {
21050 return (void *)((wxDC *) ((wxMemoryDC *) x));
21051 }
21052 static void *_p_wxWindowDCTo_p_wxDC(void *x) {
21053 return (void *)((wxDC *) ((wxWindowDC *) x));
21054 }
21055 static void *_p_wxMetaFileDCTo_p_wxDC(void *x) {
21056 return (void *)((wxDC *) ((wxMetaFileDC *) x));
21057 }
21058 static void *_p_wxBufferedPaintDCTo_p_wxDC(void *x) {
21059 return (void *)((wxDC *) (wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
21060 }
21061 static void *_p_wxClientDCTo_p_wxDC(void *x) {
21062 return (void *)((wxDC *) ((wxClientDC *) x));
21063 }
21064 static void *_p_wxPaintDCTo_p_wxDC(void *x) {
21065 return (void *)((wxDC *) ((wxPaintDC *) x));
21066 }
21067 static void *_p_wxPostScriptDCTo_p_wxDC(void *x) {
21068 return (void *)((wxDC *) ((wxPostScriptDC *) x));
21069 }
21070 static void *_p_wxPrinterDCTo_p_wxDC(void *x) {
21071 return (void *)((wxDC *) ((wxPrinterDC *) x));
21072 }
21073 static void *_p_wxBufferedPaintDCTo_p_wxBufferedDC(void *x) {
21074 return (void *)((wxBufferedDC *) ((wxBufferedPaintDC *) x));
21075 }
21076 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
21077 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
21078 }
21079 static void *_p_wxPenTo_p_wxObject(void *x) {
21080 return (void *)((wxObject *) (wxGDIObject *) ((wxPen *) x));
21081 }
21082 static void *_p_wxRegionIteratorTo_p_wxObject(void *x) {
21083 return (void *)((wxObject *) ((wxRegionIterator *) x));
21084 }
21085 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
21086 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
21087 }
21088 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
21089 return (void *)((wxObject *) ((wxSizerItem *) x));
21090 }
21091 static void *_p_wxColourDatabaseTo_p_wxObject(void *x) {
21092 return (void *)((wxObject *) ((wxColourDatabase *) x));
21093 }
21094 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
21095 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
21096 }
21097 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
21098 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
21099 }
21100 static void *_p_wxIconTo_p_wxObject(void *x) {
21101 return (void *)((wxObject *) (wxGDIObject *) ((wxIcon *) x));
21102 }
21103 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
21104 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
21105 }
21106 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
21107 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
21108 }
21109 static void *_p_wxSizerTo_p_wxObject(void *x) {
21110 return (void *)((wxObject *) ((wxSizer *) x));
21111 }
21112 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
21113 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
21114 }
21115 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
21116 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
21117 }
21118 static void *_p_wxPenListTo_p_wxObject(void *x) {
21119 return (void *)((wxObject *) ((wxPenList *) x));
21120 }
21121 static void *_p_wxEventTo_p_wxObject(void *x) {
21122 return (void *)((wxObject *) ((wxEvent *) x));
21123 }
21124 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
21125 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
21126 }
21127 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
21128 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
21129 }
21130 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
21131 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
21132 }
21133 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
21134 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
21135 }
21136 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
21137 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
21138 }
21139 static void *_p_wxDCTo_p_wxObject(void *x) {
21140 return (void *)((wxObject *) ((wxDC *) x));
21141 }
21142 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
21143 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
21144 }
21145 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
21146 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
21147 }
21148 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
21149 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
21150 }
21151 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
21152 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
21153 }
21154 static void *_p_wxControlTo_p_wxObject(void *x) {
21155 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
21156 }
21157 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
21158 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
21159 }
21160 static void *_p_wxClientDCTo_p_wxObject(void *x) {
21161 return (void *)((wxObject *) (wxDC *) ((wxClientDC *) x));
21162 }
21163 static void *_p_wxFSFileTo_p_wxObject(void *x) {
21164 return (void *)((wxObject *) ((wxFSFile *) x));
21165 }
21166 static void *_p_wxMemoryDCTo_p_wxObject(void *x) {
21167 return (void *)((wxObject *) (wxDC *) ((wxMemoryDC *) x));
21168 }
21169 static void *_p_wxRegionTo_p_wxObject(void *x) {
21170 return (void *)((wxObject *) (wxGDIObject *) ((wxRegion *) x));
21171 }
21172 static void *_p_wxPySizerTo_p_wxObject(void *x) {
21173 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
21174 }
21175 static void *_p_wxWindowDCTo_p_wxObject(void *x) {
21176 return (void *)((wxObject *) (wxDC *) ((wxWindowDC *) x));
21177 }
21178 static void *_p_wxGDIObjectTo_p_wxObject(void *x) {
21179 return (void *)((wxObject *) ((wxGDIObject *) x));
21180 }
21181 static void *_p_wxEffectsTo_p_wxObject(void *x) {
21182 return (void *)((wxObject *) ((wxEffects *) x));
21183 }
21184 static void *_p_wxPyEventTo_p_wxObject(void *x) {
21185 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
21186 }
21187 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
21188 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
21189 }
21190 static void *_p_wxPostScriptDCTo_p_wxObject(void *x) {
21191 return (void *)((wxObject *) (wxDC *) ((wxPostScriptDC *) x));
21192 }
21193 static void *_p_wxShowEventTo_p_wxObject(void *x) {
21194 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
21195 }
21196 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
21197 return (void *)((wxObject *) ((wxMenuItem *) x));
21198 }
21199 static void *_p_wxDateEventTo_p_wxObject(void *x) {
21200 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
21201 }
21202 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
21203 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
21204 }
21205 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
21206 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
21207 }
21208 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
21209 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
21210 }
21211 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
21212 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
21213 }
21214 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
21215 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
21216 }
21217 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
21218 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
21219 }
21220 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
21221 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
21222 }
21223 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
21224 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
21225 }
21226 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
21227 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
21228 }
21229 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
21230 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
21231 }
21232 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
21233 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
21234 }
21235 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
21236 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
21237 }
21238 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
21239 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
21240 }
21241 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
21242 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
21243 }
21244 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
21245 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
21246 }
21247 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
21248 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
21249 }
21250 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
21251 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
21252 }
21253 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
21254 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
21255 }
21256 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
21257 return (void *)((wxObject *) ((wxImageHandler *) x));
21258 }
21259 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
21260 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
21261 }
21262 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
21263 return (void *)((wxObject *) ((wxEvtHandler *) x));
21264 }
21265 static void *_p_wxBufferedPaintDCTo_p_wxObject(void *x) {
21266 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
21267 }
21268 static void *_p_wxPaintDCTo_p_wxObject(void *x) {
21269 return (void *)((wxObject *) (wxDC *) ((wxPaintDC *) x));
21270 }
21271 static void *_p_wxPrinterDCTo_p_wxObject(void *x) {
21272 return (void *)((wxObject *) (wxDC *) ((wxPrinterDC *) x));
21273 }
21274 static void *_p_wxScreenDCTo_p_wxObject(void *x) {
21275 return (void *)((wxObject *) (wxDC *) ((wxScreenDC *) x));
21276 }
21277 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
21278 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
21279 }
21280 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
21281 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
21282 }
21283 static void *_p_wxImageTo_p_wxObject(void *x) {
21284 return (void *)((wxObject *) ((wxImage *) x));
21285 }
21286 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
21287 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
21288 }
21289 static void *_p_wxPaletteTo_p_wxObject(void *x) {
21290 return (void *)((wxObject *) (wxGDIObject *) ((wxPalette *) x));
21291 }
21292 static void *_p_wxBufferedDCTo_p_wxObject(void *x) {
21293 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *) ((wxBufferedDC *) x));
21294 }
21295 static void *_p_wxImageListTo_p_wxObject(void *x) {
21296 return (void *)((wxObject *) ((wxImageList *) x));
21297 }
21298 static void *_p_wxCursorTo_p_wxObject(void *x) {
21299 return (void *)((wxObject *) (wxGDIObject *) ((wxCursor *) x));
21300 }
21301 static void *_p_wxEncodingConverterTo_p_wxObject(void *x) {
21302 return (void *)((wxObject *) ((wxEncodingConverter *) x));
21303 }
21304 static void *_p_wxMirrorDCTo_p_wxObject(void *x) {
21305 return (void *)((wxObject *) (wxDC *) ((wxMirrorDC *) x));
21306 }
21307 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
21308 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21309 }
21310 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
21311 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
21312 }
21313 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
21314 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
21315 }
21316 static void *_p_wxWindowTo_p_wxObject(void *x) {
21317 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
21318 }
21319 static void *_p_wxMenuTo_p_wxObject(void *x) {
21320 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
21321 }
21322 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
21323 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
21324 }
21325 static void *_p_wxMetaFileDCTo_p_wxObject(void *x) {
21326 return (void *)((wxObject *) (wxDC *) ((wxMetaFileDC *) x));
21327 }
21328 static void *_p_wxBrushListTo_p_wxObject(void *x) {
21329 return (void *)((wxObject *) ((wxBrushList *) x));
21330 }
21331 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
21332 return (void *)((wxObject *) ((wxFileSystem *) x));
21333 }
21334 static void *_p_wxBitmapTo_p_wxObject(void *x) {
21335 return (void *)((wxObject *) (wxGDIObject *) ((wxBitmap *) x));
21336 }
21337 static void *_p_wxMaskTo_p_wxObject(void *x) {
21338 return (void *)((wxObject *) ((wxMask *) x));
21339 }
21340 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
21341 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
21342 }
21343 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
21344 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
21345 }
21346 static void *_p_wxPyAppTo_p_wxObject(void *x) {
21347 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
21348 }
21349 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
21350 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
21351 }
21352 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
21353 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
21354 }
21355 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
21356 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
21357 }
21358 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
21359 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
21360 }
21361 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
21362 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
21363 }
21364 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
21365 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
21366 }
21367 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
21368 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
21369 }
21370 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
21371 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
21372 }
21373 static void *_p_wxFontTo_p_wxObject(void *x) {
21374 return (void *)((wxObject *) (wxGDIObject *) ((wxFont *) x));
21375 }
21376 static void *_p_wxBrushTo_p_wxObject(void *x) {
21377 return (void *)((wxObject *) (wxGDIObject *) ((wxBrush *) x));
21378 }
21379 static void *_p_wxMetaFileTo_p_wxObject(void *x) {
21380 return (void *)((wxObject *) ((wxMetaFile *) x));
21381 }
21382 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
21383 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
21384 }
21385 static void *_p_wxColourTo_p_wxObject(void *x) {
21386 return (void *)((wxObject *) ((wxColour *) x));
21387 }
21388 static void *_p_wxFontListTo_p_wxObject(void *x) {
21389 return (void *)((wxObject *) ((wxFontList *) x));
21390 }
21391 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
21392 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
21393 }
21394 static void *_p_wxValidatorTo_p_wxObject(void *x) {
21395 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
21396 }
21397 static void *_p_wxControlTo_p_wxWindow(void *x) {
21398 return (void *)((wxWindow *) ((wxControl *) x));
21399 }
21400 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
21401 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
21402 }
21403 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
21404 return (void *)((wxWindow *) ((wxMenuBar *) x));
21405 }
21406 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}};
21407 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}};
21408 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}};
21409 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}};
21410 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}};
21411 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}};
21412 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}};
21413 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}};
21414 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}};
21415 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}};
21416 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}};
21417 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}};
21418 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}};
21419 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}};
21420 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}};
21421 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}};
21422 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}};
21423 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}};
21424 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}};
21425 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}};
21426 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}};
21427 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}};
21428 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}};
21429 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}};
21430 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}};
21431 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}};
21432 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}};
21433 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}};
21434 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}};
21435 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}};
21436 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}};
21437 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}};
21438 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}};
21439 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}};
21440 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}};
21441 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}};
21442 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}};
21443 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}};
21444 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}};
21445 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}};
21446 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}};
21447 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}};
21448 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}};
21449 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}};
21450 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}};
21451 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}};
21452 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}};
21453 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}};
21454 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}};
21455 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}};
21456 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}};
21457 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}};
21458 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}};
21459 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}};
21460 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}};
21461 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}};
21462 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}};
21463 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}};
21464 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}};
21465 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}};
21466 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}};
21467 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}};
21468
21469 static swig_type_info *swig_types_initial[] = {
21470 _swigt__p_wxPostScriptDC,
21471 _swigt__p_wxBrush,
21472 _swigt__p_wxColour,
21473 _swigt__p_wxDC,
21474 _swigt__p_wxMirrorDC,
21475 _swigt__p_form_ops_t,
21476 _swigt__p_wxDuplexMode,
21477 _swigt__p_wxPyFontEnumerator,
21478 _swigt__p_char,
21479 _swigt__p_wxIconLocation,
21480 _swigt__p_wxImage,
21481 _swigt__p_wxMetaFileDC,
21482 _swigt__p_wxMask,
21483 _swigt__p_wxSize,
21484 _swigt__p_wxFont,
21485 _swigt__p_wxWindow,
21486 _swigt__p_double,
21487 _swigt__p_wxMemoryDC,
21488 _swigt__p_wxFontMapper,
21489 _swigt__p_wxEffects,
21490 _swigt__p_wxNativeEncodingInfo,
21491 _swigt__p_wxPalette,
21492 _swigt__p_wxBitmap,
21493 _swigt__p_wxObject,
21494 _swigt__p_wxRegionIterator,
21495 _swigt__p_wxRect,
21496 _swigt__p_wxPaperSize,
21497 _swigt__p_wxString,
21498 _swigt__unsigned_int,
21499 _swigt__p_unsigned_int,
21500 _swigt__p_wxPrinterDC,
21501 _swigt__p_wxIconBundle,
21502 _swigt__p_wxPoint,
21503 _swigt__p_wxDash,
21504 _swigt__p_wxScreenDC,
21505 _swigt__p_wxCursor,
21506 _swigt__p_wxClientDC,
21507 _swigt__p_wxBufferedDC,
21508 _swigt__p_wxImageList,
21509 _swigt__p_unsigned_char,
21510 _swigt__p_wxGDIObject,
21511 _swigt__p_wxIcon,
21512 _swigt__p_wxLocale,
21513 _swigt__ptrdiff_t,
21514 _swigt__std__ptrdiff_t,
21515 _swigt__p_wxRegion,
21516 _swigt__p_wxConfigBase,
21517 _swigt__p_wxLanguageInfo,
21518 _swigt__p_wxWindowDC,
21519 _swigt__p_wxPrintData,
21520 _swigt__p_wxBrushList,
21521 _swigt__p_wxFontList,
21522 _swigt__p_wxPen,
21523 _swigt__p_wxBufferedPaintDC,
21524 _swigt__p_wxPaintDC,
21525 _swigt__p_wxPenList,
21526 _swigt__p_int,
21527 _swigt__p_wxMetaFile,
21528 _swigt__p_unsigned_long,
21529 _swigt__p_wxNativeFontInfo,
21530 _swigt__p_wxEncodingConverter,
21531 _swigt__p_wxColourDatabase,
21532 0
21533 };
21534
21535
21536 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
21537
21538 static swig_const_info swig_const_table[] = {
21539 {0, 0, 0, 0.0, 0, 0}};
21540
21541 #ifdef __cplusplus
21542 }
21543 #endif
21544
21545
21546 #ifdef __cplusplus
21547 extern "C" {
21548 #endif
21549
21550 /* Python-specific SWIG API */
21551 #define SWIG_newvarlink() SWIG_Python_newvarlink()
21552 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
21553 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
21554
21555 /* -----------------------------------------------------------------------------
21556 * global variable support code.
21557 * ----------------------------------------------------------------------------- */
21558
21559 typedef struct swig_globalvar {
21560 char *name; /* Name of global variable */
21561 PyObject *(*get_attr)(); /* Return the current value */
21562 int (*set_attr)(PyObject *); /* Set the value */
21563 struct swig_globalvar *next;
21564 } swig_globalvar;
21565
21566 typedef struct swig_varlinkobject {
21567 PyObject_HEAD
21568 swig_globalvar *vars;
21569 } swig_varlinkobject;
21570
21571 static PyObject *
21572 swig_varlink_repr(swig_varlinkobject *v) {
21573 v = v;
21574 return PyString_FromString("<Swig global variables>");
21575 }
21576
21577 static int
21578 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
21579 swig_globalvar *var;
21580 flags = flags;
21581 fprintf(fp,"Swig global variables { ");
21582 for (var = v->vars; var; var=var->next) {
21583 fprintf(fp,"%s", var->name);
21584 if (var->next) fprintf(fp,", ");
21585 }
21586 fprintf(fp," }\n");
21587 return 0;
21588 }
21589
21590 static PyObject *
21591 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
21592 swig_globalvar *var = v->vars;
21593 while (var) {
21594 if (strcmp(var->name,n) == 0) {
21595 return (*var->get_attr)();
21596 }
21597 var = var->next;
21598 }
21599 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
21600 return NULL;
21601 }
21602
21603 static int
21604 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
21605 swig_globalvar *var = v->vars;
21606 while (var) {
21607 if (strcmp(var->name,n) == 0) {
21608 return (*var->set_attr)(p);
21609 }
21610 var = var->next;
21611 }
21612 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
21613 return 1;
21614 }
21615
21616 static PyTypeObject varlinktype = {
21617 PyObject_HEAD_INIT(0)
21618 0, /* Number of items in variable part (ob_size) */
21619 (char *)"swigvarlink", /* Type name (tp_name) */
21620 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
21621 0, /* Itemsize (tp_itemsize) */
21622 0, /* Deallocator (tp_dealloc) */
21623 (printfunc) swig_varlink_print, /* Print (tp_print) */
21624 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
21625 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
21626 0, /* tp_compare */
21627 (reprfunc) swig_varlink_repr, /* tp_repr */
21628 0, /* tp_as_number */
21629 0, /* tp_as_sequence */
21630 0, /* tp_as_mapping */
21631 0, /* tp_hash */
21632 0, /* tp_call */
21633 0, /* tp_str */
21634 0, /* tp_getattro */
21635 0, /* tp_setattro */
21636 0, /* tp_as_buffer */
21637 0, /* tp_flags */
21638 0, /* tp_doc */
21639 #if PY_VERSION_HEX >= 0x02000000
21640 0, /* tp_traverse */
21641 0, /* tp_clear */
21642 #endif
21643 #if PY_VERSION_HEX >= 0x02010000
21644 0, /* tp_richcompare */
21645 0, /* tp_weaklistoffset */
21646 #endif
21647 #if PY_VERSION_HEX >= 0x02020000
21648 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
21649 #endif
21650 #if PY_VERSION_HEX >= 0x02030000
21651 0, /* tp_del */
21652 #endif
21653 #ifdef COUNT_ALLOCS
21654 0,0,0,0 /* tp_alloc -> tp_next */
21655 #endif
21656 };
21657
21658 /* Create a variable linking object for use later */
21659 static PyObject *
21660 SWIG_Python_newvarlink(void) {
21661 swig_varlinkobject *result = 0;
21662 result = PyMem_NEW(swig_varlinkobject,1);
21663 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
21664 result->ob_type = &varlinktype;
21665 result->vars = 0;
21666 result->ob_refcnt = 0;
21667 Py_XINCREF((PyObject *) result);
21668 return ((PyObject*) result);
21669 }
21670
21671 static void
21672 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
21673 swig_varlinkobject *v;
21674 swig_globalvar *gv;
21675 v= (swig_varlinkobject *) p;
21676 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
21677 gv->name = (char *) malloc(strlen(name)+1);
21678 strcpy(gv->name,name);
21679 gv->get_attr = get_attr;
21680 gv->set_attr = set_attr;
21681 gv->next = v->vars;
21682 v->vars = gv;
21683 }
21684
21685 /* -----------------------------------------------------------------------------
21686 * constants/methods manipulation
21687 * ----------------------------------------------------------------------------- */
21688
21689 /* Install Constants */
21690 static void
21691 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
21692 PyObject *obj = 0;
21693 size_t i;
21694 for (i = 0; constants[i].type; i++) {
21695 switch(constants[i].type) {
21696 case SWIG_PY_INT:
21697 obj = PyInt_FromLong(constants[i].lvalue);
21698 break;
21699 case SWIG_PY_FLOAT:
21700 obj = PyFloat_FromDouble(constants[i].dvalue);
21701 break;
21702 case SWIG_PY_STRING:
21703 if (constants[i].pvalue) {
21704 obj = PyString_FromString((char *) constants[i].pvalue);
21705 } else {
21706 Py_INCREF(Py_None);
21707 obj = Py_None;
21708 }
21709 break;
21710 case SWIG_PY_POINTER:
21711 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
21712 break;
21713 case SWIG_PY_BINARY:
21714 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
21715 break;
21716 default:
21717 obj = 0;
21718 break;
21719 }
21720 if (obj) {
21721 PyDict_SetItemString(d,constants[i].name,obj);
21722 Py_DECREF(obj);
21723 }
21724 }
21725 }
21726
21727 /* -----------------------------------------------------------------------------*/
21728 /* Fix SwigMethods to carry the callback ptrs when needed */
21729 /* -----------------------------------------------------------------------------*/
21730
21731 static void
21732 SWIG_Python_FixMethods(PyMethodDef *methods,
21733 swig_const_info *const_table,
21734 swig_type_info **types,
21735 swig_type_info **types_initial) {
21736 size_t i;
21737 for (i = 0; methods[i].ml_name; ++i) {
21738 char *c = methods[i].ml_doc;
21739 if (c && (c = strstr(c, "swig_ptr: "))) {
21740 int j;
21741 swig_const_info *ci = 0;
21742 char *name = c + 10;
21743 for (j = 0; const_table[j].type; j++) {
21744 if (strncmp(const_table[j].name, name,
21745 strlen(const_table[j].name)) == 0) {
21746 ci = &(const_table[j]);
21747 break;
21748 }
21749 }
21750 if (ci) {
21751 size_t shift = (ci->ptype) - types;
21752 swig_type_info *ty = types_initial[shift];
21753 size_t ldoc = (c - methods[i].ml_doc);
21754 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
21755 char *ndoc = (char*)malloc(ldoc + lptr + 10);
21756 char *buff = ndoc;
21757 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
21758 strncpy(buff, methods[i].ml_doc, ldoc);
21759 buff += ldoc;
21760 strncpy(buff, "swig_ptr: ", 10);
21761 buff += 10;
21762 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
21763 methods[i].ml_doc = ndoc;
21764 }
21765 }
21766 }
21767 }
21768
21769 /* -----------------------------------------------------------------------------*
21770 * Initialize type list
21771 * -----------------------------------------------------------------------------*/
21772
21773 #if PY_MAJOR_VERSION < 2
21774 /* PyModule_AddObject function was introduced in Python 2.0. The following function
21775 is copied out of Python/modsupport.c in python version 2.3.4 */
21776 static int
21777 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
21778 {
21779 PyObject *dict;
21780 if (!PyModule_Check(m)) {
21781 PyErr_SetString(PyExc_TypeError,
21782 "PyModule_AddObject() needs module as first arg");
21783 return -1;
21784 }
21785 if (!o) {
21786 PyErr_SetString(PyExc_TypeError,
21787 "PyModule_AddObject() needs non-NULL value");
21788 return -1;
21789 }
21790
21791 dict = PyModule_GetDict(m);
21792 if (dict == NULL) {
21793 /* Internal error -- modules must have a dict! */
21794 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
21795 PyModule_GetName(m));
21796 return -1;
21797 }
21798 if (PyDict_SetItemString(dict, name, o))
21799 return -1;
21800 Py_DECREF(o);
21801 return 0;
21802 }
21803 #endif
21804
21805 static swig_type_info **
21806 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
21807 static PyMethodDef swig_empty_runtime_method_table[] = {
21808 {
21809 NULL, NULL, 0, NULL
21810 }
21811 };/* Sentinel */
21812
21813 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
21814 swig_empty_runtime_method_table);
21815 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
21816 if (pointer && module) {
21817 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
21818 }
21819 return type_list_handle;
21820 }
21821
21822 static swig_type_info **
21823 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
21824 swig_type_info **type_pointer;
21825
21826 /* first check if module already created */
21827 type_pointer = SWIG_Python_GetTypeListHandle();
21828 if (type_pointer) {
21829 return type_pointer;
21830 } else {
21831 /* create a new module and variable */
21832 return SWIG_Python_SetTypeListHandle(type_list_handle);
21833 }
21834 }
21835
21836 #ifdef __cplusplus
21837 }
21838 #endif
21839
21840 /* -----------------------------------------------------------------------------*
21841 * Partial Init method
21842 * -----------------------------------------------------------------------------*/
21843
21844 #ifdef SWIG_LINK_RUNTIME
21845 #ifdef __cplusplus
21846 extern "C"
21847 #endif
21848 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
21849 #endif
21850
21851 #ifdef __cplusplus
21852 extern "C"
21853 #endif
21854 SWIGEXPORT(void) SWIG_init(void) {
21855 static PyObject *SWIG_globals = 0;
21856 static int typeinit = 0;
21857 PyObject *m, *d;
21858 int i;
21859 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
21860
21861 /* Fix SwigMethods to carry the callback ptrs when needed */
21862 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
21863
21864 m = Py_InitModule((char *) SWIG_name, SwigMethods);
21865 d = PyModule_GetDict(m);
21866
21867 if (!typeinit) {
21868 #ifdef SWIG_LINK_RUNTIME
21869 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
21870 #else
21871 # ifndef SWIG_STATIC_RUNTIME
21872 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
21873 # endif
21874 #endif
21875 for (i = 0; swig_types_initial[i]; i++) {
21876 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
21877 }
21878 typeinit = 1;
21879 }
21880 SWIG_InstallConstants(d,swig_const_table);
21881
21882 {
21883 PyDict_SetItemString(d,"OutRegion", SWIG_From_int((int)(wxOutRegion)));
21884 }
21885 {
21886 PyDict_SetItemString(d,"PartRegion", SWIG_From_int((int)(wxPartRegion)));
21887 }
21888 {
21889 PyDict_SetItemString(d,"InRegion", SWIG_From_int((int)(wxInRegion)));
21890 }
21891 {
21892 PyDict_SetItemString(d,"FONTFAMILY_DEFAULT", SWIG_From_int((int)(wxFONTFAMILY_DEFAULT)));
21893 }
21894 {
21895 PyDict_SetItemString(d,"FONTFAMILY_DECORATIVE", SWIG_From_int((int)(wxFONTFAMILY_DECORATIVE)));
21896 }
21897 {
21898 PyDict_SetItemString(d,"FONTFAMILY_ROMAN", SWIG_From_int((int)(wxFONTFAMILY_ROMAN)));
21899 }
21900 {
21901 PyDict_SetItemString(d,"FONTFAMILY_SCRIPT", SWIG_From_int((int)(wxFONTFAMILY_SCRIPT)));
21902 }
21903 {
21904 PyDict_SetItemString(d,"FONTFAMILY_SWISS", SWIG_From_int((int)(wxFONTFAMILY_SWISS)));
21905 }
21906 {
21907 PyDict_SetItemString(d,"FONTFAMILY_MODERN", SWIG_From_int((int)(wxFONTFAMILY_MODERN)));
21908 }
21909 {
21910 PyDict_SetItemString(d,"FONTFAMILY_TELETYPE", SWIG_From_int((int)(wxFONTFAMILY_TELETYPE)));
21911 }
21912 {
21913 PyDict_SetItemString(d,"FONTFAMILY_MAX", SWIG_From_int((int)(wxFONTFAMILY_MAX)));
21914 }
21915 {
21916 PyDict_SetItemString(d,"FONTFAMILY_UNKNOWN", SWIG_From_int((int)(wxFONTFAMILY_UNKNOWN)));
21917 }
21918 {
21919 PyDict_SetItemString(d,"FONTSTYLE_NORMAL", SWIG_From_int((int)(wxFONTSTYLE_NORMAL)));
21920 }
21921 {
21922 PyDict_SetItemString(d,"FONTSTYLE_ITALIC", SWIG_From_int((int)(wxFONTSTYLE_ITALIC)));
21923 }
21924 {
21925 PyDict_SetItemString(d,"FONTSTYLE_SLANT", SWIG_From_int((int)(wxFONTSTYLE_SLANT)));
21926 }
21927 {
21928 PyDict_SetItemString(d,"FONTSTYLE_MAX", SWIG_From_int((int)(wxFONTSTYLE_MAX)));
21929 }
21930 {
21931 PyDict_SetItemString(d,"FONTWEIGHT_NORMAL", SWIG_From_int((int)(wxFONTWEIGHT_NORMAL)));
21932 }
21933 {
21934 PyDict_SetItemString(d,"FONTWEIGHT_LIGHT", SWIG_From_int((int)(wxFONTWEIGHT_LIGHT)));
21935 }
21936 {
21937 PyDict_SetItemString(d,"FONTWEIGHT_BOLD", SWIG_From_int((int)(wxFONTWEIGHT_BOLD)));
21938 }
21939 {
21940 PyDict_SetItemString(d,"FONTWEIGHT_MAX", SWIG_From_int((int)(wxFONTWEIGHT_MAX)));
21941 }
21942 {
21943 PyDict_SetItemString(d,"FONTFLAG_DEFAULT", SWIG_From_int((int)(wxFONTFLAG_DEFAULT)));
21944 }
21945 {
21946 PyDict_SetItemString(d,"FONTFLAG_ITALIC", SWIG_From_int((int)(wxFONTFLAG_ITALIC)));
21947 }
21948 {
21949 PyDict_SetItemString(d,"FONTFLAG_SLANT", SWIG_From_int((int)(wxFONTFLAG_SLANT)));
21950 }
21951 {
21952 PyDict_SetItemString(d,"FONTFLAG_LIGHT", SWIG_From_int((int)(wxFONTFLAG_LIGHT)));
21953 }
21954 {
21955 PyDict_SetItemString(d,"FONTFLAG_BOLD", SWIG_From_int((int)(wxFONTFLAG_BOLD)));
21956 }
21957 {
21958 PyDict_SetItemString(d,"FONTFLAG_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_ANTIALIASED)));
21959 }
21960 {
21961 PyDict_SetItemString(d,"FONTFLAG_NOT_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_NOT_ANTIALIASED)));
21962 }
21963 {
21964 PyDict_SetItemString(d,"FONTFLAG_UNDERLINED", SWIG_From_int((int)(wxFONTFLAG_UNDERLINED)));
21965 }
21966 {
21967 PyDict_SetItemString(d,"FONTFLAG_STRIKETHROUGH", SWIG_From_int((int)(wxFONTFLAG_STRIKETHROUGH)));
21968 }
21969 {
21970 PyDict_SetItemString(d,"FONTFLAG_MASK", SWIG_From_int((int)(wxFONTFLAG_MASK)));
21971 }
21972 {
21973 PyDict_SetItemString(d,"FONTENCODING_SYSTEM", SWIG_From_int((int)(wxFONTENCODING_SYSTEM)));
21974 }
21975 {
21976 PyDict_SetItemString(d,"FONTENCODING_DEFAULT", SWIG_From_int((int)(wxFONTENCODING_DEFAULT)));
21977 }
21978 {
21979 PyDict_SetItemString(d,"FONTENCODING_ISO8859_1", SWIG_From_int((int)(wxFONTENCODING_ISO8859_1)));
21980 }
21981 {
21982 PyDict_SetItemString(d,"FONTENCODING_ISO8859_2", SWIG_From_int((int)(wxFONTENCODING_ISO8859_2)));
21983 }
21984 {
21985 PyDict_SetItemString(d,"FONTENCODING_ISO8859_3", SWIG_From_int((int)(wxFONTENCODING_ISO8859_3)));
21986 }
21987 {
21988 PyDict_SetItemString(d,"FONTENCODING_ISO8859_4", SWIG_From_int((int)(wxFONTENCODING_ISO8859_4)));
21989 }
21990 {
21991 PyDict_SetItemString(d,"FONTENCODING_ISO8859_5", SWIG_From_int((int)(wxFONTENCODING_ISO8859_5)));
21992 }
21993 {
21994 PyDict_SetItemString(d,"FONTENCODING_ISO8859_6", SWIG_From_int((int)(wxFONTENCODING_ISO8859_6)));
21995 }
21996 {
21997 PyDict_SetItemString(d,"FONTENCODING_ISO8859_7", SWIG_From_int((int)(wxFONTENCODING_ISO8859_7)));
21998 }
21999 {
22000 PyDict_SetItemString(d,"FONTENCODING_ISO8859_8", SWIG_From_int((int)(wxFONTENCODING_ISO8859_8)));
22001 }
22002 {
22003 PyDict_SetItemString(d,"FONTENCODING_ISO8859_9", SWIG_From_int((int)(wxFONTENCODING_ISO8859_9)));
22004 }
22005 {
22006 PyDict_SetItemString(d,"FONTENCODING_ISO8859_10", SWIG_From_int((int)(wxFONTENCODING_ISO8859_10)));
22007 }
22008 {
22009 PyDict_SetItemString(d,"FONTENCODING_ISO8859_11", SWIG_From_int((int)(wxFONTENCODING_ISO8859_11)));
22010 }
22011 {
22012 PyDict_SetItemString(d,"FONTENCODING_ISO8859_12", SWIG_From_int((int)(wxFONTENCODING_ISO8859_12)));
22013 }
22014 {
22015 PyDict_SetItemString(d,"FONTENCODING_ISO8859_13", SWIG_From_int((int)(wxFONTENCODING_ISO8859_13)));
22016 }
22017 {
22018 PyDict_SetItemString(d,"FONTENCODING_ISO8859_14", SWIG_From_int((int)(wxFONTENCODING_ISO8859_14)));
22019 }
22020 {
22021 PyDict_SetItemString(d,"FONTENCODING_ISO8859_15", SWIG_From_int((int)(wxFONTENCODING_ISO8859_15)));
22022 }
22023 {
22024 PyDict_SetItemString(d,"FONTENCODING_ISO8859_MAX", SWIG_From_int((int)(wxFONTENCODING_ISO8859_MAX)));
22025 }
22026 {
22027 PyDict_SetItemString(d,"FONTENCODING_KOI8", SWIG_From_int((int)(wxFONTENCODING_KOI8)));
22028 }
22029 {
22030 PyDict_SetItemString(d,"FONTENCODING_KOI8_U", SWIG_From_int((int)(wxFONTENCODING_KOI8_U)));
22031 }
22032 {
22033 PyDict_SetItemString(d,"FONTENCODING_ALTERNATIVE", SWIG_From_int((int)(wxFONTENCODING_ALTERNATIVE)));
22034 }
22035 {
22036 PyDict_SetItemString(d,"FONTENCODING_BULGARIAN", SWIG_From_int((int)(wxFONTENCODING_BULGARIAN)));
22037 }
22038 {
22039 PyDict_SetItemString(d,"FONTENCODING_CP437", SWIG_From_int((int)(wxFONTENCODING_CP437)));
22040 }
22041 {
22042 PyDict_SetItemString(d,"FONTENCODING_CP850", SWIG_From_int((int)(wxFONTENCODING_CP850)));
22043 }
22044 {
22045 PyDict_SetItemString(d,"FONTENCODING_CP852", SWIG_From_int((int)(wxFONTENCODING_CP852)));
22046 }
22047 {
22048 PyDict_SetItemString(d,"FONTENCODING_CP855", SWIG_From_int((int)(wxFONTENCODING_CP855)));
22049 }
22050 {
22051 PyDict_SetItemString(d,"FONTENCODING_CP866", SWIG_From_int((int)(wxFONTENCODING_CP866)));
22052 }
22053 {
22054 PyDict_SetItemString(d,"FONTENCODING_CP874", SWIG_From_int((int)(wxFONTENCODING_CP874)));
22055 }
22056 {
22057 PyDict_SetItemString(d,"FONTENCODING_CP932", SWIG_From_int((int)(wxFONTENCODING_CP932)));
22058 }
22059 {
22060 PyDict_SetItemString(d,"FONTENCODING_CP936", SWIG_From_int((int)(wxFONTENCODING_CP936)));
22061 }
22062 {
22063 PyDict_SetItemString(d,"FONTENCODING_CP949", SWIG_From_int((int)(wxFONTENCODING_CP949)));
22064 }
22065 {
22066 PyDict_SetItemString(d,"FONTENCODING_CP950", SWIG_From_int((int)(wxFONTENCODING_CP950)));
22067 }
22068 {
22069 PyDict_SetItemString(d,"FONTENCODING_CP1250", SWIG_From_int((int)(wxFONTENCODING_CP1250)));
22070 }
22071 {
22072 PyDict_SetItemString(d,"FONTENCODING_CP1251", SWIG_From_int((int)(wxFONTENCODING_CP1251)));
22073 }
22074 {
22075 PyDict_SetItemString(d,"FONTENCODING_CP1252", SWIG_From_int((int)(wxFONTENCODING_CP1252)));
22076 }
22077 {
22078 PyDict_SetItemString(d,"FONTENCODING_CP1253", SWIG_From_int((int)(wxFONTENCODING_CP1253)));
22079 }
22080 {
22081 PyDict_SetItemString(d,"FONTENCODING_CP1254", SWIG_From_int((int)(wxFONTENCODING_CP1254)));
22082 }
22083 {
22084 PyDict_SetItemString(d,"FONTENCODING_CP1255", SWIG_From_int((int)(wxFONTENCODING_CP1255)));
22085 }
22086 {
22087 PyDict_SetItemString(d,"FONTENCODING_CP1256", SWIG_From_int((int)(wxFONTENCODING_CP1256)));
22088 }
22089 {
22090 PyDict_SetItemString(d,"FONTENCODING_CP1257", SWIG_From_int((int)(wxFONTENCODING_CP1257)));
22091 }
22092 {
22093 PyDict_SetItemString(d,"FONTENCODING_CP12_MAX", SWIG_From_int((int)(wxFONTENCODING_CP12_MAX)));
22094 }
22095 {
22096 PyDict_SetItemString(d,"FONTENCODING_UTF7", SWIG_From_int((int)(wxFONTENCODING_UTF7)));
22097 }
22098 {
22099 PyDict_SetItemString(d,"FONTENCODING_UTF8", SWIG_From_int((int)(wxFONTENCODING_UTF8)));
22100 }
22101 {
22102 PyDict_SetItemString(d,"FONTENCODING_EUC_JP", SWIG_From_int((int)(wxFONTENCODING_EUC_JP)));
22103 }
22104 {
22105 PyDict_SetItemString(d,"FONTENCODING_UTF16BE", SWIG_From_int((int)(wxFONTENCODING_UTF16BE)));
22106 }
22107 {
22108 PyDict_SetItemString(d,"FONTENCODING_UTF16LE", SWIG_From_int((int)(wxFONTENCODING_UTF16LE)));
22109 }
22110 {
22111 PyDict_SetItemString(d,"FONTENCODING_UTF32BE", SWIG_From_int((int)(wxFONTENCODING_UTF32BE)));
22112 }
22113 {
22114 PyDict_SetItemString(d,"FONTENCODING_UTF32LE", SWIG_From_int((int)(wxFONTENCODING_UTF32LE)));
22115 }
22116 {
22117 PyDict_SetItemString(d,"FONTENCODING_MACROMAN", SWIG_From_int((int)(wxFONTENCODING_MACROMAN)));
22118 }
22119 {
22120 PyDict_SetItemString(d,"FONTENCODING_MACJAPANESE", SWIG_From_int((int)(wxFONTENCODING_MACJAPANESE)));
22121 }
22122 {
22123 PyDict_SetItemString(d,"FONTENCODING_MACCHINESETRAD", SWIG_From_int((int)(wxFONTENCODING_MACCHINESETRAD)));
22124 }
22125 {
22126 PyDict_SetItemString(d,"FONTENCODING_MACKOREAN", SWIG_From_int((int)(wxFONTENCODING_MACKOREAN)));
22127 }
22128 {
22129 PyDict_SetItemString(d,"FONTENCODING_MACARABIC", SWIG_From_int((int)(wxFONTENCODING_MACARABIC)));
22130 }
22131 {
22132 PyDict_SetItemString(d,"FONTENCODING_MACHEBREW", SWIG_From_int((int)(wxFONTENCODING_MACHEBREW)));
22133 }
22134 {
22135 PyDict_SetItemString(d,"FONTENCODING_MACGREEK", SWIG_From_int((int)(wxFONTENCODING_MACGREEK)));
22136 }
22137 {
22138 PyDict_SetItemString(d,"FONTENCODING_MACCYRILLIC", SWIG_From_int((int)(wxFONTENCODING_MACCYRILLIC)));
22139 }
22140 {
22141 PyDict_SetItemString(d,"FONTENCODING_MACDEVANAGARI", SWIG_From_int((int)(wxFONTENCODING_MACDEVANAGARI)));
22142 }
22143 {
22144 PyDict_SetItemString(d,"FONTENCODING_MACGURMUKHI", SWIG_From_int((int)(wxFONTENCODING_MACGURMUKHI)));
22145 }
22146 {
22147 PyDict_SetItemString(d,"FONTENCODING_MACGUJARATI", SWIG_From_int((int)(wxFONTENCODING_MACGUJARATI)));
22148 }
22149 {
22150 PyDict_SetItemString(d,"FONTENCODING_MACORIYA", SWIG_From_int((int)(wxFONTENCODING_MACORIYA)));
22151 }
22152 {
22153 PyDict_SetItemString(d,"FONTENCODING_MACBENGALI", SWIG_From_int((int)(wxFONTENCODING_MACBENGALI)));
22154 }
22155 {
22156 PyDict_SetItemString(d,"FONTENCODING_MACTAMIL", SWIG_From_int((int)(wxFONTENCODING_MACTAMIL)));
22157 }
22158 {
22159 PyDict_SetItemString(d,"FONTENCODING_MACTELUGU", SWIG_From_int((int)(wxFONTENCODING_MACTELUGU)));
22160 }
22161 {
22162 PyDict_SetItemString(d,"FONTENCODING_MACKANNADA", SWIG_From_int((int)(wxFONTENCODING_MACKANNADA)));
22163 }
22164 {
22165 PyDict_SetItemString(d,"FONTENCODING_MACMALAJALAM", SWIG_From_int((int)(wxFONTENCODING_MACMALAJALAM)));
22166 }
22167 {
22168 PyDict_SetItemString(d,"FONTENCODING_MACSINHALESE", SWIG_From_int((int)(wxFONTENCODING_MACSINHALESE)));
22169 }
22170 {
22171 PyDict_SetItemString(d,"FONTENCODING_MACBURMESE", SWIG_From_int((int)(wxFONTENCODING_MACBURMESE)));
22172 }
22173 {
22174 PyDict_SetItemString(d,"FONTENCODING_MACKHMER", SWIG_From_int((int)(wxFONTENCODING_MACKHMER)));
22175 }
22176 {
22177 PyDict_SetItemString(d,"FONTENCODING_MACTHAI", SWIG_From_int((int)(wxFONTENCODING_MACTHAI)));
22178 }
22179 {
22180 PyDict_SetItemString(d,"FONTENCODING_MACLAOTIAN", SWIG_From_int((int)(wxFONTENCODING_MACLAOTIAN)));
22181 }
22182 {
22183 PyDict_SetItemString(d,"FONTENCODING_MACGEORGIAN", SWIG_From_int((int)(wxFONTENCODING_MACGEORGIAN)));
22184 }
22185 {
22186 PyDict_SetItemString(d,"FONTENCODING_MACARMENIAN", SWIG_From_int((int)(wxFONTENCODING_MACARMENIAN)));
22187 }
22188 {
22189 PyDict_SetItemString(d,"FONTENCODING_MACCHINESESIMP", SWIG_From_int((int)(wxFONTENCODING_MACCHINESESIMP)));
22190 }
22191 {
22192 PyDict_SetItemString(d,"FONTENCODING_MACTIBETAN", SWIG_From_int((int)(wxFONTENCODING_MACTIBETAN)));
22193 }
22194 {
22195 PyDict_SetItemString(d,"FONTENCODING_MACMONGOLIAN", SWIG_From_int((int)(wxFONTENCODING_MACMONGOLIAN)));
22196 }
22197 {
22198 PyDict_SetItemString(d,"FONTENCODING_MACETHIOPIC", SWIG_From_int((int)(wxFONTENCODING_MACETHIOPIC)));
22199 }
22200 {
22201 PyDict_SetItemString(d,"FONTENCODING_MACCENTRALEUR", SWIG_From_int((int)(wxFONTENCODING_MACCENTRALEUR)));
22202 }
22203 {
22204 PyDict_SetItemString(d,"FONTENCODING_MACVIATNAMESE", SWIG_From_int((int)(wxFONTENCODING_MACVIATNAMESE)));
22205 }
22206 {
22207 PyDict_SetItemString(d,"FONTENCODING_MACARABICEXT", SWIG_From_int((int)(wxFONTENCODING_MACARABICEXT)));
22208 }
22209 {
22210 PyDict_SetItemString(d,"FONTENCODING_MACSYMBOL", SWIG_From_int((int)(wxFONTENCODING_MACSYMBOL)));
22211 }
22212 {
22213 PyDict_SetItemString(d,"FONTENCODING_MACDINGBATS", SWIG_From_int((int)(wxFONTENCODING_MACDINGBATS)));
22214 }
22215 {
22216 PyDict_SetItemString(d,"FONTENCODING_MACTURKISH", SWIG_From_int((int)(wxFONTENCODING_MACTURKISH)));
22217 }
22218 {
22219 PyDict_SetItemString(d,"FONTENCODING_MACCROATIAN", SWIG_From_int((int)(wxFONTENCODING_MACCROATIAN)));
22220 }
22221 {
22222 PyDict_SetItemString(d,"FONTENCODING_MACICELANDIC", SWIG_From_int((int)(wxFONTENCODING_MACICELANDIC)));
22223 }
22224 {
22225 PyDict_SetItemString(d,"FONTENCODING_MACROMANIAN", SWIG_From_int((int)(wxFONTENCODING_MACROMANIAN)));
22226 }
22227 {
22228 PyDict_SetItemString(d,"FONTENCODING_MACCELTIC", SWIG_From_int((int)(wxFONTENCODING_MACCELTIC)));
22229 }
22230 {
22231 PyDict_SetItemString(d,"FONTENCODING_MACGAELIC", SWIG_From_int((int)(wxFONTENCODING_MACGAELIC)));
22232 }
22233 {
22234 PyDict_SetItemString(d,"FONTENCODING_MACKEYBOARD", SWIG_From_int((int)(wxFONTENCODING_MACKEYBOARD)));
22235 }
22236 {
22237 PyDict_SetItemString(d,"FONTENCODING_MACMIN", SWIG_From_int((int)(wxFONTENCODING_MACMIN)));
22238 }
22239 {
22240 PyDict_SetItemString(d,"FONTENCODING_MACMAX", SWIG_From_int((int)(wxFONTENCODING_MACMAX)));
22241 }
22242 {
22243 PyDict_SetItemString(d,"FONTENCODING_MAX", SWIG_From_int((int)(wxFONTENCODING_MAX)));
22244 }
22245 {
22246 PyDict_SetItemString(d,"FONTENCODING_UTF16", SWIG_From_int((int)(wxFONTENCODING_UTF16)));
22247 }
22248 {
22249 PyDict_SetItemString(d,"FONTENCODING_UTF32", SWIG_From_int((int)(wxFONTENCODING_UTF32)));
22250 }
22251 {
22252 PyDict_SetItemString(d,"FONTENCODING_UNICODE", SWIG_From_int((int)(wxFONTENCODING_UNICODE)));
22253 }
22254 {
22255 PyDict_SetItemString(d,"FONTENCODING_GB2312", SWIG_From_int((int)(wxFONTENCODING_GB2312)));
22256 }
22257 {
22258 PyDict_SetItemString(d,"FONTENCODING_BIG5", SWIG_From_int((int)(wxFONTENCODING_BIG5)));
22259 }
22260 {
22261 PyDict_SetItemString(d,"FONTENCODING_SHIFT_JIS", SWIG_From_int((int)(wxFONTENCODING_SHIFT_JIS)));
22262 }
22263
22264 wxPyPtrTypeMap_Add("wxFontEnumerator", "wxPyFontEnumerator");
22265
22266 {
22267 PyDict_SetItemString(d,"LANGUAGE_DEFAULT", SWIG_From_int((int)(wxLANGUAGE_DEFAULT)));
22268 }
22269 {
22270 PyDict_SetItemString(d,"LANGUAGE_UNKNOWN", SWIG_From_int((int)(wxLANGUAGE_UNKNOWN)));
22271 }
22272 {
22273 PyDict_SetItemString(d,"LANGUAGE_ABKHAZIAN", SWIG_From_int((int)(wxLANGUAGE_ABKHAZIAN)));
22274 }
22275 {
22276 PyDict_SetItemString(d,"LANGUAGE_AFAR", SWIG_From_int((int)(wxLANGUAGE_AFAR)));
22277 }
22278 {
22279 PyDict_SetItemString(d,"LANGUAGE_AFRIKAANS", SWIG_From_int((int)(wxLANGUAGE_AFRIKAANS)));
22280 }
22281 {
22282 PyDict_SetItemString(d,"LANGUAGE_ALBANIAN", SWIG_From_int((int)(wxLANGUAGE_ALBANIAN)));
22283 }
22284 {
22285 PyDict_SetItemString(d,"LANGUAGE_AMHARIC", SWIG_From_int((int)(wxLANGUAGE_AMHARIC)));
22286 }
22287 {
22288 PyDict_SetItemString(d,"LANGUAGE_ARABIC", SWIG_From_int((int)(wxLANGUAGE_ARABIC)));
22289 }
22290 {
22291 PyDict_SetItemString(d,"LANGUAGE_ARABIC_ALGERIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_ALGERIA)));
22292 }
22293 {
22294 PyDict_SetItemString(d,"LANGUAGE_ARABIC_BAHRAIN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_BAHRAIN)));
22295 }
22296 {
22297 PyDict_SetItemString(d,"LANGUAGE_ARABIC_EGYPT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_EGYPT)));
22298 }
22299 {
22300 PyDict_SetItemString(d,"LANGUAGE_ARABIC_IRAQ", SWIG_From_int((int)(wxLANGUAGE_ARABIC_IRAQ)));
22301 }
22302 {
22303 PyDict_SetItemString(d,"LANGUAGE_ARABIC_JORDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_JORDAN)));
22304 }
22305 {
22306 PyDict_SetItemString(d,"LANGUAGE_ARABIC_KUWAIT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_KUWAIT)));
22307 }
22308 {
22309 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LEBANON", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LEBANON)));
22310 }
22311 {
22312 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LIBYA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LIBYA)));
22313 }
22314 {
22315 PyDict_SetItemString(d,"LANGUAGE_ARABIC_MOROCCO", SWIG_From_int((int)(wxLANGUAGE_ARABIC_MOROCCO)));
22316 }
22317 {
22318 PyDict_SetItemString(d,"LANGUAGE_ARABIC_OMAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_OMAN)));
22319 }
22320 {
22321 PyDict_SetItemString(d,"LANGUAGE_ARABIC_QATAR", SWIG_From_int((int)(wxLANGUAGE_ARABIC_QATAR)));
22322 }
22323 {
22324 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SAUDI_ARABIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SAUDI_ARABIA)));
22325 }
22326 {
22327 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SUDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SUDAN)));
22328 }
22329 {
22330 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SYRIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SYRIA)));
22331 }
22332 {
22333 PyDict_SetItemString(d,"LANGUAGE_ARABIC_TUNISIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_TUNISIA)));
22334 }
22335 {
22336 PyDict_SetItemString(d,"LANGUAGE_ARABIC_UAE", SWIG_From_int((int)(wxLANGUAGE_ARABIC_UAE)));
22337 }
22338 {
22339 PyDict_SetItemString(d,"LANGUAGE_ARABIC_YEMEN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_YEMEN)));
22340 }
22341 {
22342 PyDict_SetItemString(d,"LANGUAGE_ARMENIAN", SWIG_From_int((int)(wxLANGUAGE_ARMENIAN)));
22343 }
22344 {
22345 PyDict_SetItemString(d,"LANGUAGE_ASSAMESE", SWIG_From_int((int)(wxLANGUAGE_ASSAMESE)));
22346 }
22347 {
22348 PyDict_SetItemString(d,"LANGUAGE_AYMARA", SWIG_From_int((int)(wxLANGUAGE_AYMARA)));
22349 }
22350 {
22351 PyDict_SetItemString(d,"LANGUAGE_AZERI", SWIG_From_int((int)(wxLANGUAGE_AZERI)));
22352 }
22353 {
22354 PyDict_SetItemString(d,"LANGUAGE_AZERI_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_AZERI_CYRILLIC)));
22355 }
22356 {
22357 PyDict_SetItemString(d,"LANGUAGE_AZERI_LATIN", SWIG_From_int((int)(wxLANGUAGE_AZERI_LATIN)));
22358 }
22359 {
22360 PyDict_SetItemString(d,"LANGUAGE_BASHKIR", SWIG_From_int((int)(wxLANGUAGE_BASHKIR)));
22361 }
22362 {
22363 PyDict_SetItemString(d,"LANGUAGE_BASQUE", SWIG_From_int((int)(wxLANGUAGE_BASQUE)));
22364 }
22365 {
22366 PyDict_SetItemString(d,"LANGUAGE_BELARUSIAN", SWIG_From_int((int)(wxLANGUAGE_BELARUSIAN)));
22367 }
22368 {
22369 PyDict_SetItemString(d,"LANGUAGE_BENGALI", SWIG_From_int((int)(wxLANGUAGE_BENGALI)));
22370 }
22371 {
22372 PyDict_SetItemString(d,"LANGUAGE_BHUTANI", SWIG_From_int((int)(wxLANGUAGE_BHUTANI)));
22373 }
22374 {
22375 PyDict_SetItemString(d,"LANGUAGE_BIHARI", SWIG_From_int((int)(wxLANGUAGE_BIHARI)));
22376 }
22377 {
22378 PyDict_SetItemString(d,"LANGUAGE_BISLAMA", SWIG_From_int((int)(wxLANGUAGE_BISLAMA)));
22379 }
22380 {
22381 PyDict_SetItemString(d,"LANGUAGE_BRETON", SWIG_From_int((int)(wxLANGUAGE_BRETON)));
22382 }
22383 {
22384 PyDict_SetItemString(d,"LANGUAGE_BULGARIAN", SWIG_From_int((int)(wxLANGUAGE_BULGARIAN)));
22385 }
22386 {
22387 PyDict_SetItemString(d,"LANGUAGE_BURMESE", SWIG_From_int((int)(wxLANGUAGE_BURMESE)));
22388 }
22389 {
22390 PyDict_SetItemString(d,"LANGUAGE_CAMBODIAN", SWIG_From_int((int)(wxLANGUAGE_CAMBODIAN)));
22391 }
22392 {
22393 PyDict_SetItemString(d,"LANGUAGE_CATALAN", SWIG_From_int((int)(wxLANGUAGE_CATALAN)));
22394 }
22395 {
22396 PyDict_SetItemString(d,"LANGUAGE_CHINESE", SWIG_From_int((int)(wxLANGUAGE_CHINESE)));
22397 }
22398 {
22399 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SIMPLIFIED", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SIMPLIFIED)));
22400 }
22401 {
22402 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TRADITIONAL", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TRADITIONAL)));
22403 }
22404 {
22405 PyDict_SetItemString(d,"LANGUAGE_CHINESE_HONGKONG", SWIG_From_int((int)(wxLANGUAGE_CHINESE_HONGKONG)));
22406 }
22407 {
22408 PyDict_SetItemString(d,"LANGUAGE_CHINESE_MACAU", SWIG_From_int((int)(wxLANGUAGE_CHINESE_MACAU)));
22409 }
22410 {
22411 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SINGAPORE", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SINGAPORE)));
22412 }
22413 {
22414 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TAIWAN", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TAIWAN)));
22415 }
22416 {
22417 PyDict_SetItemString(d,"LANGUAGE_CORSICAN", SWIG_From_int((int)(wxLANGUAGE_CORSICAN)));
22418 }
22419 {
22420 PyDict_SetItemString(d,"LANGUAGE_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_CROATIAN)));
22421 }
22422 {
22423 PyDict_SetItemString(d,"LANGUAGE_CZECH", SWIG_From_int((int)(wxLANGUAGE_CZECH)));
22424 }
22425 {
22426 PyDict_SetItemString(d,"LANGUAGE_DANISH", SWIG_From_int((int)(wxLANGUAGE_DANISH)));
22427 }
22428 {
22429 PyDict_SetItemString(d,"LANGUAGE_DUTCH", SWIG_From_int((int)(wxLANGUAGE_DUTCH)));
22430 }
22431 {
22432 PyDict_SetItemString(d,"LANGUAGE_DUTCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_DUTCH_BELGIAN)));
22433 }
22434 {
22435 PyDict_SetItemString(d,"LANGUAGE_ENGLISH", SWIG_From_int((int)(wxLANGUAGE_ENGLISH)));
22436 }
22437 {
22438 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_UK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_UK)));
22439 }
22440 {
22441 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_US", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_US)));
22442 }
22443 {
22444 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_AUSTRALIA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_AUSTRALIA)));
22445 }
22446 {
22447 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BELIZE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BELIZE)));
22448 }
22449 {
22450 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BOTSWANA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BOTSWANA)));
22451 }
22452 {
22453 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CANADA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CANADA)));
22454 }
22455 {
22456 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CARIBBEAN", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CARIBBEAN)));
22457 }
22458 {
22459 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_DENMARK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_DENMARK)));
22460 }
22461 {
22462 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_EIRE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_EIRE)));
22463 }
22464 {
22465 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_JAMAICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_JAMAICA)));
22466 }
22467 {
22468 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_NEW_ZEALAND", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_NEW_ZEALAND)));
22469 }
22470 {
22471 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_PHILIPPINES", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_PHILIPPINES)));
22472 }
22473 {
22474 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_SOUTH_AFRICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_SOUTH_AFRICA)));
22475 }
22476 {
22477 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_TRINIDAD", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_TRINIDAD)));
22478 }
22479 {
22480 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_ZIMBABWE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_ZIMBABWE)));
22481 }
22482 {
22483 PyDict_SetItemString(d,"LANGUAGE_ESPERANTO", SWIG_From_int((int)(wxLANGUAGE_ESPERANTO)));
22484 }
22485 {
22486 PyDict_SetItemString(d,"LANGUAGE_ESTONIAN", SWIG_From_int((int)(wxLANGUAGE_ESTONIAN)));
22487 }
22488 {
22489 PyDict_SetItemString(d,"LANGUAGE_FAEROESE", SWIG_From_int((int)(wxLANGUAGE_FAEROESE)));
22490 }
22491 {
22492 PyDict_SetItemString(d,"LANGUAGE_FARSI", SWIG_From_int((int)(wxLANGUAGE_FARSI)));
22493 }
22494 {
22495 PyDict_SetItemString(d,"LANGUAGE_FIJI", SWIG_From_int((int)(wxLANGUAGE_FIJI)));
22496 }
22497 {
22498 PyDict_SetItemString(d,"LANGUAGE_FINNISH", SWIG_From_int((int)(wxLANGUAGE_FINNISH)));
22499 }
22500 {
22501 PyDict_SetItemString(d,"LANGUAGE_FRENCH", SWIG_From_int((int)(wxLANGUAGE_FRENCH)));
22502 }
22503 {
22504 PyDict_SetItemString(d,"LANGUAGE_FRENCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_BELGIAN)));
22505 }
22506 {
22507 PyDict_SetItemString(d,"LANGUAGE_FRENCH_CANADIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_CANADIAN)));
22508 }
22509 {
22510 PyDict_SetItemString(d,"LANGUAGE_FRENCH_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_FRENCH_LUXEMBOURG)));
22511 }
22512 {
22513 PyDict_SetItemString(d,"LANGUAGE_FRENCH_MONACO", SWIG_From_int((int)(wxLANGUAGE_FRENCH_MONACO)));
22514 }
22515 {
22516 PyDict_SetItemString(d,"LANGUAGE_FRENCH_SWISS", SWIG_From_int((int)(wxLANGUAGE_FRENCH_SWISS)));
22517 }
22518 {
22519 PyDict_SetItemString(d,"LANGUAGE_FRISIAN", SWIG_From_int((int)(wxLANGUAGE_FRISIAN)));
22520 }
22521 {
22522 PyDict_SetItemString(d,"LANGUAGE_GALICIAN", SWIG_From_int((int)(wxLANGUAGE_GALICIAN)));
22523 }
22524 {
22525 PyDict_SetItemString(d,"LANGUAGE_GEORGIAN", SWIG_From_int((int)(wxLANGUAGE_GEORGIAN)));
22526 }
22527 {
22528 PyDict_SetItemString(d,"LANGUAGE_GERMAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN)));
22529 }
22530 {
22531 PyDict_SetItemString(d,"LANGUAGE_GERMAN_AUSTRIAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_AUSTRIAN)));
22532 }
22533 {
22534 PyDict_SetItemString(d,"LANGUAGE_GERMAN_BELGIUM", SWIG_From_int((int)(wxLANGUAGE_GERMAN_BELGIUM)));
22535 }
22536 {
22537 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LIECHTENSTEIN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LIECHTENSTEIN)));
22538 }
22539 {
22540 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LUXEMBOURG)));
22541 }
22542 {
22543 PyDict_SetItemString(d,"LANGUAGE_GERMAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_GERMAN_SWISS)));
22544 }
22545 {
22546 PyDict_SetItemString(d,"LANGUAGE_GREEK", SWIG_From_int((int)(wxLANGUAGE_GREEK)));
22547 }
22548 {
22549 PyDict_SetItemString(d,"LANGUAGE_GREENLANDIC", SWIG_From_int((int)(wxLANGUAGE_GREENLANDIC)));
22550 }
22551 {
22552 PyDict_SetItemString(d,"LANGUAGE_GUARANI", SWIG_From_int((int)(wxLANGUAGE_GUARANI)));
22553 }
22554 {
22555 PyDict_SetItemString(d,"LANGUAGE_GUJARATI", SWIG_From_int((int)(wxLANGUAGE_GUJARATI)));
22556 }
22557 {
22558 PyDict_SetItemString(d,"LANGUAGE_HAUSA", SWIG_From_int((int)(wxLANGUAGE_HAUSA)));
22559 }
22560 {
22561 PyDict_SetItemString(d,"LANGUAGE_HEBREW", SWIG_From_int((int)(wxLANGUAGE_HEBREW)));
22562 }
22563 {
22564 PyDict_SetItemString(d,"LANGUAGE_HINDI", SWIG_From_int((int)(wxLANGUAGE_HINDI)));
22565 }
22566 {
22567 PyDict_SetItemString(d,"LANGUAGE_HUNGARIAN", SWIG_From_int((int)(wxLANGUAGE_HUNGARIAN)));
22568 }
22569 {
22570 PyDict_SetItemString(d,"LANGUAGE_ICELANDIC", SWIG_From_int((int)(wxLANGUAGE_ICELANDIC)));
22571 }
22572 {
22573 PyDict_SetItemString(d,"LANGUAGE_INDONESIAN", SWIG_From_int((int)(wxLANGUAGE_INDONESIAN)));
22574 }
22575 {
22576 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUA", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUA)));
22577 }
22578 {
22579 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUE", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUE)));
22580 }
22581 {
22582 PyDict_SetItemString(d,"LANGUAGE_INUKTITUT", SWIG_From_int((int)(wxLANGUAGE_INUKTITUT)));
22583 }
22584 {
22585 PyDict_SetItemString(d,"LANGUAGE_INUPIAK", SWIG_From_int((int)(wxLANGUAGE_INUPIAK)));
22586 }
22587 {
22588 PyDict_SetItemString(d,"LANGUAGE_IRISH", SWIG_From_int((int)(wxLANGUAGE_IRISH)));
22589 }
22590 {
22591 PyDict_SetItemString(d,"LANGUAGE_ITALIAN", SWIG_From_int((int)(wxLANGUAGE_ITALIAN)));
22592 }
22593 {
22594 PyDict_SetItemString(d,"LANGUAGE_ITALIAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_ITALIAN_SWISS)));
22595 }
22596 {
22597 PyDict_SetItemString(d,"LANGUAGE_JAPANESE", SWIG_From_int((int)(wxLANGUAGE_JAPANESE)));
22598 }
22599 {
22600 PyDict_SetItemString(d,"LANGUAGE_JAVANESE", SWIG_From_int((int)(wxLANGUAGE_JAVANESE)));
22601 }
22602 {
22603 PyDict_SetItemString(d,"LANGUAGE_KANNADA", SWIG_From_int((int)(wxLANGUAGE_KANNADA)));
22604 }
22605 {
22606 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI)));
22607 }
22608 {
22609 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI_INDIA", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI_INDIA)));
22610 }
22611 {
22612 PyDict_SetItemString(d,"LANGUAGE_KAZAKH", SWIG_From_int((int)(wxLANGUAGE_KAZAKH)));
22613 }
22614 {
22615 PyDict_SetItemString(d,"LANGUAGE_KERNEWEK", SWIG_From_int((int)(wxLANGUAGE_KERNEWEK)));
22616 }
22617 {
22618 PyDict_SetItemString(d,"LANGUAGE_KINYARWANDA", SWIG_From_int((int)(wxLANGUAGE_KINYARWANDA)));
22619 }
22620 {
22621 PyDict_SetItemString(d,"LANGUAGE_KIRGHIZ", SWIG_From_int((int)(wxLANGUAGE_KIRGHIZ)));
22622 }
22623 {
22624 PyDict_SetItemString(d,"LANGUAGE_KIRUNDI", SWIG_From_int((int)(wxLANGUAGE_KIRUNDI)));
22625 }
22626 {
22627 PyDict_SetItemString(d,"LANGUAGE_KONKANI", SWIG_From_int((int)(wxLANGUAGE_KONKANI)));
22628 }
22629 {
22630 PyDict_SetItemString(d,"LANGUAGE_KOREAN", SWIG_From_int((int)(wxLANGUAGE_KOREAN)));
22631 }
22632 {
22633 PyDict_SetItemString(d,"LANGUAGE_KURDISH", SWIG_From_int((int)(wxLANGUAGE_KURDISH)));
22634 }
22635 {
22636 PyDict_SetItemString(d,"LANGUAGE_LAOTHIAN", SWIG_From_int((int)(wxLANGUAGE_LAOTHIAN)));
22637 }
22638 {
22639 PyDict_SetItemString(d,"LANGUAGE_LATIN", SWIG_From_int((int)(wxLANGUAGE_LATIN)));
22640 }
22641 {
22642 PyDict_SetItemString(d,"LANGUAGE_LATVIAN", SWIG_From_int((int)(wxLANGUAGE_LATVIAN)));
22643 }
22644 {
22645 PyDict_SetItemString(d,"LANGUAGE_LINGALA", SWIG_From_int((int)(wxLANGUAGE_LINGALA)));
22646 }
22647 {
22648 PyDict_SetItemString(d,"LANGUAGE_LITHUANIAN", SWIG_From_int((int)(wxLANGUAGE_LITHUANIAN)));
22649 }
22650 {
22651 PyDict_SetItemString(d,"LANGUAGE_MACEDONIAN", SWIG_From_int((int)(wxLANGUAGE_MACEDONIAN)));
22652 }
22653 {
22654 PyDict_SetItemString(d,"LANGUAGE_MALAGASY", SWIG_From_int((int)(wxLANGUAGE_MALAGASY)));
22655 }
22656 {
22657 PyDict_SetItemString(d,"LANGUAGE_MALAY", SWIG_From_int((int)(wxLANGUAGE_MALAY)));
22658 }
22659 {
22660 PyDict_SetItemString(d,"LANGUAGE_MALAYALAM", SWIG_From_int((int)(wxLANGUAGE_MALAYALAM)));
22661 }
22662 {
22663 PyDict_SetItemString(d,"LANGUAGE_MALAY_BRUNEI_DARUSSALAM", SWIG_From_int((int)(wxLANGUAGE_MALAY_BRUNEI_DARUSSALAM)));
22664 }
22665 {
22666 PyDict_SetItemString(d,"LANGUAGE_MALAY_MALAYSIA", SWIG_From_int((int)(wxLANGUAGE_MALAY_MALAYSIA)));
22667 }
22668 {
22669 PyDict_SetItemString(d,"LANGUAGE_MALTESE", SWIG_From_int((int)(wxLANGUAGE_MALTESE)));
22670 }
22671 {
22672 PyDict_SetItemString(d,"LANGUAGE_MANIPURI", SWIG_From_int((int)(wxLANGUAGE_MANIPURI)));
22673 }
22674 {
22675 PyDict_SetItemString(d,"LANGUAGE_MAORI", SWIG_From_int((int)(wxLANGUAGE_MAORI)));
22676 }
22677 {
22678 PyDict_SetItemString(d,"LANGUAGE_MARATHI", SWIG_From_int((int)(wxLANGUAGE_MARATHI)));
22679 }
22680 {
22681 PyDict_SetItemString(d,"LANGUAGE_MOLDAVIAN", SWIG_From_int((int)(wxLANGUAGE_MOLDAVIAN)));
22682 }
22683 {
22684 PyDict_SetItemString(d,"LANGUAGE_MONGOLIAN", SWIG_From_int((int)(wxLANGUAGE_MONGOLIAN)));
22685 }
22686 {
22687 PyDict_SetItemString(d,"LANGUAGE_NAURU", SWIG_From_int((int)(wxLANGUAGE_NAURU)));
22688 }
22689 {
22690 PyDict_SetItemString(d,"LANGUAGE_NEPALI", SWIG_From_int((int)(wxLANGUAGE_NEPALI)));
22691 }
22692 {
22693 PyDict_SetItemString(d,"LANGUAGE_NEPALI_INDIA", SWIG_From_int((int)(wxLANGUAGE_NEPALI_INDIA)));
22694 }
22695 {
22696 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_BOKMAL", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_BOKMAL)));
22697 }
22698 {
22699 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_NYNORSK", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_NYNORSK)));
22700 }
22701 {
22702 PyDict_SetItemString(d,"LANGUAGE_OCCITAN", SWIG_From_int((int)(wxLANGUAGE_OCCITAN)));
22703 }
22704 {
22705 PyDict_SetItemString(d,"LANGUAGE_ORIYA", SWIG_From_int((int)(wxLANGUAGE_ORIYA)));
22706 }
22707 {
22708 PyDict_SetItemString(d,"LANGUAGE_OROMO", SWIG_From_int((int)(wxLANGUAGE_OROMO)));
22709 }
22710 {
22711 PyDict_SetItemString(d,"LANGUAGE_PASHTO", SWIG_From_int((int)(wxLANGUAGE_PASHTO)));
22712 }
22713 {
22714 PyDict_SetItemString(d,"LANGUAGE_POLISH", SWIG_From_int((int)(wxLANGUAGE_POLISH)));
22715 }
22716 {
22717 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE)));
22718 }
22719 {
22720 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE_BRAZILIAN", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE_BRAZILIAN)));
22721 }
22722 {
22723 PyDict_SetItemString(d,"LANGUAGE_PUNJABI", SWIG_From_int((int)(wxLANGUAGE_PUNJABI)));
22724 }
22725 {
22726 PyDict_SetItemString(d,"LANGUAGE_QUECHUA", SWIG_From_int((int)(wxLANGUAGE_QUECHUA)));
22727 }
22728 {
22729 PyDict_SetItemString(d,"LANGUAGE_RHAETO_ROMANCE", SWIG_From_int((int)(wxLANGUAGE_RHAETO_ROMANCE)));
22730 }
22731 {
22732 PyDict_SetItemString(d,"LANGUAGE_ROMANIAN", SWIG_From_int((int)(wxLANGUAGE_ROMANIAN)));
22733 }
22734 {
22735 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN)));
22736 }
22737 {
22738 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN_UKRAINE", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN_UKRAINE)));
22739 }
22740 {
22741 PyDict_SetItemString(d,"LANGUAGE_SAMOAN", SWIG_From_int((int)(wxLANGUAGE_SAMOAN)));
22742 }
22743 {
22744 PyDict_SetItemString(d,"LANGUAGE_SANGHO", SWIG_From_int((int)(wxLANGUAGE_SANGHO)));
22745 }
22746 {
22747 PyDict_SetItemString(d,"LANGUAGE_SANSKRIT", SWIG_From_int((int)(wxLANGUAGE_SANSKRIT)));
22748 }
22749 {
22750 PyDict_SetItemString(d,"LANGUAGE_SCOTS_GAELIC", SWIG_From_int((int)(wxLANGUAGE_SCOTS_GAELIC)));
22751 }
22752 {
22753 PyDict_SetItemString(d,"LANGUAGE_SERBIAN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN)));
22754 }
22755 {
22756 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_CYRILLIC)));
22757 }
22758 {
22759 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_LATIN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_LATIN)));
22760 }
22761 {
22762 PyDict_SetItemString(d,"LANGUAGE_SERBO_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_SERBO_CROATIAN)));
22763 }
22764 {
22765 PyDict_SetItemString(d,"LANGUAGE_SESOTHO", SWIG_From_int((int)(wxLANGUAGE_SESOTHO)));
22766 }
22767 {
22768 PyDict_SetItemString(d,"LANGUAGE_SETSWANA", SWIG_From_int((int)(wxLANGUAGE_SETSWANA)));
22769 }
22770 {
22771 PyDict_SetItemString(d,"LANGUAGE_SHONA", SWIG_From_int((int)(wxLANGUAGE_SHONA)));
22772 }
22773 {
22774 PyDict_SetItemString(d,"LANGUAGE_SINDHI", SWIG_From_int((int)(wxLANGUAGE_SINDHI)));
22775 }
22776 {
22777 PyDict_SetItemString(d,"LANGUAGE_SINHALESE", SWIG_From_int((int)(wxLANGUAGE_SINHALESE)));
22778 }
22779 {
22780 PyDict_SetItemString(d,"LANGUAGE_SISWATI", SWIG_From_int((int)(wxLANGUAGE_SISWATI)));
22781 }
22782 {
22783 PyDict_SetItemString(d,"LANGUAGE_SLOVAK", SWIG_From_int((int)(wxLANGUAGE_SLOVAK)));
22784 }
22785 {
22786 PyDict_SetItemString(d,"LANGUAGE_SLOVENIAN", SWIG_From_int((int)(wxLANGUAGE_SLOVENIAN)));
22787 }
22788 {
22789 PyDict_SetItemString(d,"LANGUAGE_SOMALI", SWIG_From_int((int)(wxLANGUAGE_SOMALI)));
22790 }
22791 {
22792 PyDict_SetItemString(d,"LANGUAGE_SPANISH", SWIG_From_int((int)(wxLANGUAGE_SPANISH)));
22793 }
22794 {
22795 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ARGENTINA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ARGENTINA)));
22796 }
22797 {
22798 PyDict_SetItemString(d,"LANGUAGE_SPANISH_BOLIVIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_BOLIVIA)));
22799 }
22800 {
22801 PyDict_SetItemString(d,"LANGUAGE_SPANISH_CHILE", SWIG_From_int((int)(wxLANGUAGE_SPANISH_CHILE)));
22802 }
22803 {
22804 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COLOMBIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COLOMBIA)));
22805 }
22806 {
22807 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COSTA_RICA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COSTA_RICA)));
22808 }
22809 {
22810 PyDict_SetItemString(d,"LANGUAGE_SPANISH_DOMINICAN_REPUBLIC", SWIG_From_int((int)(wxLANGUAGE_SPANISH_DOMINICAN_REPUBLIC)));
22811 }
22812 {
22813 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ECUADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ECUADOR)));
22814 }
22815 {
22816 PyDict_SetItemString(d,"LANGUAGE_SPANISH_EL_SALVADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_EL_SALVADOR)));
22817 }
22818 {
22819 PyDict_SetItemString(d,"LANGUAGE_SPANISH_GUATEMALA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_GUATEMALA)));
22820 }
22821 {
22822 PyDict_SetItemString(d,"LANGUAGE_SPANISH_HONDURAS", SWIG_From_int((int)(wxLANGUAGE_SPANISH_HONDURAS)));
22823 }
22824 {
22825 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MEXICAN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MEXICAN)));
22826 }
22827 {
22828 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MODERN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MODERN)));
22829 }
22830 {
22831 PyDict_SetItemString(d,"LANGUAGE_SPANISH_NICARAGUA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_NICARAGUA)));
22832 }
22833 {
22834 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PANAMA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PANAMA)));
22835 }
22836 {
22837 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PARAGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PARAGUAY)));
22838 }
22839 {
22840 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PERU", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PERU)));
22841 }
22842 {
22843 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PUERTO_RICO", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PUERTO_RICO)));
22844 }
22845 {
22846 PyDict_SetItemString(d,"LANGUAGE_SPANISH_URUGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_URUGUAY)));
22847 }
22848 {
22849 PyDict_SetItemString(d,"LANGUAGE_SPANISH_US", SWIG_From_int((int)(wxLANGUAGE_SPANISH_US)));
22850 }
22851 {
22852 PyDict_SetItemString(d,"LANGUAGE_SPANISH_VENEZUELA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_VENEZUELA)));
22853 }
22854 {
22855 PyDict_SetItemString(d,"LANGUAGE_SUNDANESE", SWIG_From_int((int)(wxLANGUAGE_SUNDANESE)));
22856 }
22857 {
22858 PyDict_SetItemString(d,"LANGUAGE_SWAHILI", SWIG_From_int((int)(wxLANGUAGE_SWAHILI)));
22859 }
22860 {
22861 PyDict_SetItemString(d,"LANGUAGE_SWEDISH", SWIG_From_int((int)(wxLANGUAGE_SWEDISH)));
22862 }
22863 {
22864 PyDict_SetItemString(d,"LANGUAGE_SWEDISH_FINLAND", SWIG_From_int((int)(wxLANGUAGE_SWEDISH_FINLAND)));
22865 }
22866 {
22867 PyDict_SetItemString(d,"LANGUAGE_TAGALOG", SWIG_From_int((int)(wxLANGUAGE_TAGALOG)));
22868 }
22869 {
22870 PyDict_SetItemString(d,"LANGUAGE_TAJIK", SWIG_From_int((int)(wxLANGUAGE_TAJIK)));
22871 }
22872 {
22873 PyDict_SetItemString(d,"LANGUAGE_TAMIL", SWIG_From_int((int)(wxLANGUAGE_TAMIL)));
22874 }
22875 {
22876 PyDict_SetItemString(d,"LANGUAGE_TATAR", SWIG_From_int((int)(wxLANGUAGE_TATAR)));
22877 }
22878 {
22879 PyDict_SetItemString(d,"LANGUAGE_TELUGU", SWIG_From_int((int)(wxLANGUAGE_TELUGU)));
22880 }
22881 {
22882 PyDict_SetItemString(d,"LANGUAGE_THAI", SWIG_From_int((int)(wxLANGUAGE_THAI)));
22883 }
22884 {
22885 PyDict_SetItemString(d,"LANGUAGE_TIBETAN", SWIG_From_int((int)(wxLANGUAGE_TIBETAN)));
22886 }
22887 {
22888 PyDict_SetItemString(d,"LANGUAGE_TIGRINYA", SWIG_From_int((int)(wxLANGUAGE_TIGRINYA)));
22889 }
22890 {
22891 PyDict_SetItemString(d,"LANGUAGE_TONGA", SWIG_From_int((int)(wxLANGUAGE_TONGA)));
22892 }
22893 {
22894 PyDict_SetItemString(d,"LANGUAGE_TSONGA", SWIG_From_int((int)(wxLANGUAGE_TSONGA)));
22895 }
22896 {
22897 PyDict_SetItemString(d,"LANGUAGE_TURKISH", SWIG_From_int((int)(wxLANGUAGE_TURKISH)));
22898 }
22899 {
22900 PyDict_SetItemString(d,"LANGUAGE_TURKMEN", SWIG_From_int((int)(wxLANGUAGE_TURKMEN)));
22901 }
22902 {
22903 PyDict_SetItemString(d,"LANGUAGE_TWI", SWIG_From_int((int)(wxLANGUAGE_TWI)));
22904 }
22905 {
22906 PyDict_SetItemString(d,"LANGUAGE_UIGHUR", SWIG_From_int((int)(wxLANGUAGE_UIGHUR)));
22907 }
22908 {
22909 PyDict_SetItemString(d,"LANGUAGE_UKRAINIAN", SWIG_From_int((int)(wxLANGUAGE_UKRAINIAN)));
22910 }
22911 {
22912 PyDict_SetItemString(d,"LANGUAGE_URDU", SWIG_From_int((int)(wxLANGUAGE_URDU)));
22913 }
22914 {
22915 PyDict_SetItemString(d,"LANGUAGE_URDU_INDIA", SWIG_From_int((int)(wxLANGUAGE_URDU_INDIA)));
22916 }
22917 {
22918 PyDict_SetItemString(d,"LANGUAGE_URDU_PAKISTAN", SWIG_From_int((int)(wxLANGUAGE_URDU_PAKISTAN)));
22919 }
22920 {
22921 PyDict_SetItemString(d,"LANGUAGE_UZBEK", SWIG_From_int((int)(wxLANGUAGE_UZBEK)));
22922 }
22923 {
22924 PyDict_SetItemString(d,"LANGUAGE_UZBEK_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_UZBEK_CYRILLIC)));
22925 }
22926 {
22927 PyDict_SetItemString(d,"LANGUAGE_UZBEK_LATIN", SWIG_From_int((int)(wxLANGUAGE_UZBEK_LATIN)));
22928 }
22929 {
22930 PyDict_SetItemString(d,"LANGUAGE_VIETNAMESE", SWIG_From_int((int)(wxLANGUAGE_VIETNAMESE)));
22931 }
22932 {
22933 PyDict_SetItemString(d,"LANGUAGE_VOLAPUK", SWIG_From_int((int)(wxLANGUAGE_VOLAPUK)));
22934 }
22935 {
22936 PyDict_SetItemString(d,"LANGUAGE_WELSH", SWIG_From_int((int)(wxLANGUAGE_WELSH)));
22937 }
22938 {
22939 PyDict_SetItemString(d,"LANGUAGE_WOLOF", SWIG_From_int((int)(wxLANGUAGE_WOLOF)));
22940 }
22941 {
22942 PyDict_SetItemString(d,"LANGUAGE_XHOSA", SWIG_From_int((int)(wxLANGUAGE_XHOSA)));
22943 }
22944 {
22945 PyDict_SetItemString(d,"LANGUAGE_YIDDISH", SWIG_From_int((int)(wxLANGUAGE_YIDDISH)));
22946 }
22947 {
22948 PyDict_SetItemString(d,"LANGUAGE_YORUBA", SWIG_From_int((int)(wxLANGUAGE_YORUBA)));
22949 }
22950 {
22951 PyDict_SetItemString(d,"LANGUAGE_ZHUANG", SWIG_From_int((int)(wxLANGUAGE_ZHUANG)));
22952 }
22953 {
22954 PyDict_SetItemString(d,"LANGUAGE_ZULU", SWIG_From_int((int)(wxLANGUAGE_ZULU)));
22955 }
22956 {
22957 PyDict_SetItemString(d,"LANGUAGE_USER_DEFINED", SWIG_From_int((int)(wxLANGUAGE_USER_DEFINED)));
22958 }
22959 {
22960 PyDict_SetItemString(d,"LOCALE_CAT_NUMBER", SWIG_From_int((int)(wxLOCALE_CAT_NUMBER)));
22961 }
22962 {
22963 PyDict_SetItemString(d,"LOCALE_CAT_DATE", SWIG_From_int((int)(wxLOCALE_CAT_DATE)));
22964 }
22965 {
22966 PyDict_SetItemString(d,"LOCALE_CAT_MONEY", SWIG_From_int((int)(wxLOCALE_CAT_MONEY)));
22967 }
22968 {
22969 PyDict_SetItemString(d,"LOCALE_CAT_MAX", SWIG_From_int((int)(wxLOCALE_CAT_MAX)));
22970 }
22971 {
22972 PyDict_SetItemString(d,"LOCALE_THOUSANDS_SEP", SWIG_From_int((int)(wxLOCALE_THOUSANDS_SEP)));
22973 }
22974 {
22975 PyDict_SetItemString(d,"LOCALE_DECIMAL_POINT", SWIG_From_int((int)(wxLOCALE_DECIMAL_POINT)));
22976 }
22977 {
22978 PyDict_SetItemString(d,"LOCALE_LOAD_DEFAULT", SWIG_From_int((int)(wxLOCALE_LOAD_DEFAULT)));
22979 }
22980 {
22981 PyDict_SetItemString(d,"LOCALE_CONV_ENCODING", SWIG_From_int((int)(wxLOCALE_CONV_ENCODING)));
22982 }
22983 {
22984 PyDict_SetItemString(d,"CONVERT_STRICT", SWIG_From_int((int)(wxCONVERT_STRICT)));
22985 }
22986 {
22987 PyDict_SetItemString(d,"CONVERT_SUBSTITUTE", SWIG_From_int((int)(wxCONVERT_SUBSTITUTE)));
22988 }
22989 {
22990 PyDict_SetItemString(d,"PLATFORM_CURRENT", SWIG_From_int((int)(wxPLATFORM_CURRENT)));
22991 }
22992 {
22993 PyDict_SetItemString(d,"PLATFORM_UNIX", SWIG_From_int((int)(wxPLATFORM_UNIX)));
22994 }
22995 {
22996 PyDict_SetItemString(d,"PLATFORM_WINDOWS", SWIG_From_int((int)(wxPLATFORM_WINDOWS)));
22997 }
22998 {
22999 PyDict_SetItemString(d,"PLATFORM_OS2", SWIG_From_int((int)(wxPLATFORM_OS2)));
23000 }
23001 {
23002 PyDict_SetItemString(d,"PLATFORM_MAC", SWIG_From_int((int)(wxPLATFORM_MAC)));
23003 }
23004 {
23005 PyDict_SetItemString(d,"BUFFER_VIRTUAL_AREA", SWIG_From_int((int)(wxBUFFER_VIRTUAL_AREA)));
23006 }
23007 {
23008 PyDict_SetItemString(d,"BUFFER_CLIENT_AREA", SWIG_From_int((int)(wxBUFFER_CLIENT_AREA)));
23009 }
23010 {
23011 PyDict_SetItemString(d,"IMAGELIST_DRAW_NORMAL", SWIG_From_int((int)(wxIMAGELIST_DRAW_NORMAL)));
23012 }
23013 {
23014 PyDict_SetItemString(d,"IMAGELIST_DRAW_TRANSPARENT", SWIG_From_int((int)(wxIMAGELIST_DRAW_TRANSPARENT)));
23015 }
23016 {
23017 PyDict_SetItemString(d,"IMAGELIST_DRAW_SELECTED", SWIG_From_int((int)(wxIMAGELIST_DRAW_SELECTED)));
23018 }
23019 {
23020 PyDict_SetItemString(d,"IMAGELIST_DRAW_FOCUSED", SWIG_From_int((int)(wxIMAGELIST_DRAW_FOCUSED)));
23021 }
23022 {
23023 PyDict_SetItemString(d,"IMAGE_LIST_NORMAL", SWIG_From_int((int)(wxIMAGE_LIST_NORMAL)));
23024 }
23025 {
23026 PyDict_SetItemString(d,"IMAGE_LIST_SMALL", SWIG_From_int((int)(wxIMAGE_LIST_SMALL)));
23027 }
23028 {
23029 PyDict_SetItemString(d,"IMAGE_LIST_STATE", SWIG_From_int((int)(wxIMAGE_LIST_STATE)));
23030 }
23031 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
23032 SWIG_addvarlink(SWIG_globals,(char*)"NORMAL_FONT",_wrap_NORMAL_FONT_get, _wrap_NORMAL_FONT_set);
23033 SWIG_addvarlink(SWIG_globals,(char*)"SMALL_FONT",_wrap_SMALL_FONT_get, _wrap_SMALL_FONT_set);
23034 SWIG_addvarlink(SWIG_globals,(char*)"ITALIC_FONT",_wrap_ITALIC_FONT_get, _wrap_ITALIC_FONT_set);
23035 SWIG_addvarlink(SWIG_globals,(char*)"SWISS_FONT",_wrap_SWISS_FONT_get, _wrap_SWISS_FONT_set);
23036 SWIG_addvarlink(SWIG_globals,(char*)"RED_PEN",_wrap_RED_PEN_get, _wrap_RED_PEN_set);
23037 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_PEN",_wrap_CYAN_PEN_get, _wrap_CYAN_PEN_set);
23038 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_PEN",_wrap_GREEN_PEN_get, _wrap_GREEN_PEN_set);
23039 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_PEN",_wrap_BLACK_PEN_get, _wrap_BLACK_PEN_set);
23040 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_PEN",_wrap_WHITE_PEN_get, _wrap_WHITE_PEN_set);
23041 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_PEN",_wrap_TRANSPARENT_PEN_get, _wrap_TRANSPARENT_PEN_set);
23042 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_DASHED_PEN",_wrap_BLACK_DASHED_PEN_get, _wrap_BLACK_DASHED_PEN_set);
23043 SWIG_addvarlink(SWIG_globals,(char*)"GREY_PEN",_wrap_GREY_PEN_get, _wrap_GREY_PEN_set);
23044 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_PEN",_wrap_MEDIUM_GREY_PEN_get, _wrap_MEDIUM_GREY_PEN_set);
23045 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_PEN",_wrap_LIGHT_GREY_PEN_get, _wrap_LIGHT_GREY_PEN_set);
23046 SWIG_addvarlink(SWIG_globals,(char*)"BLUE_BRUSH",_wrap_BLUE_BRUSH_get, _wrap_BLUE_BRUSH_set);
23047 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_BRUSH",_wrap_GREEN_BRUSH_get, _wrap_GREEN_BRUSH_set);
23048 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_BRUSH",_wrap_WHITE_BRUSH_get, _wrap_WHITE_BRUSH_set);
23049 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_BRUSH",_wrap_BLACK_BRUSH_get, _wrap_BLACK_BRUSH_set);
23050 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_BRUSH",_wrap_TRANSPARENT_BRUSH_get, _wrap_TRANSPARENT_BRUSH_set);
23051 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_BRUSH",_wrap_CYAN_BRUSH_get, _wrap_CYAN_BRUSH_set);
23052 SWIG_addvarlink(SWIG_globals,(char*)"RED_BRUSH",_wrap_RED_BRUSH_get, _wrap_RED_BRUSH_set);
23053 SWIG_addvarlink(SWIG_globals,(char*)"GREY_BRUSH",_wrap_GREY_BRUSH_get, _wrap_GREY_BRUSH_set);
23054 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_BRUSH",_wrap_MEDIUM_GREY_BRUSH_get, _wrap_MEDIUM_GREY_BRUSH_set);
23055 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_BRUSH",_wrap_LIGHT_GREY_BRUSH_get, _wrap_LIGHT_GREY_BRUSH_set);
23056 SWIG_addvarlink(SWIG_globals,(char*)"BLACK",_wrap_BLACK_get, _wrap_BLACK_set);
23057 SWIG_addvarlink(SWIG_globals,(char*)"WHITE",_wrap_WHITE_get, _wrap_WHITE_set);
23058 SWIG_addvarlink(SWIG_globals,(char*)"RED",_wrap_RED_get, _wrap_RED_set);
23059 SWIG_addvarlink(SWIG_globals,(char*)"BLUE",_wrap_BLUE_get, _wrap_BLUE_set);
23060 SWIG_addvarlink(SWIG_globals,(char*)"GREEN",_wrap_GREEN_get, _wrap_GREEN_set);
23061 SWIG_addvarlink(SWIG_globals,(char*)"CYAN",_wrap_CYAN_get, _wrap_CYAN_set);
23062 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY",_wrap_LIGHT_GREY_get, _wrap_LIGHT_GREY_set);
23063 SWIG_addvarlink(SWIG_globals,(char*)"STANDARD_CURSOR",_wrap_STANDARD_CURSOR_get, _wrap_STANDARD_CURSOR_set);
23064 SWIG_addvarlink(SWIG_globals,(char*)"HOURGLASS_CURSOR",_wrap_HOURGLASS_CURSOR_get, _wrap_HOURGLASS_CURSOR_set);
23065 SWIG_addvarlink(SWIG_globals,(char*)"CROSS_CURSOR",_wrap_CROSS_CURSOR_get, _wrap_CROSS_CURSOR_set);
23066 SWIG_addvarlink(SWIG_globals,(char*)"NullBitmap",_wrap_NullBitmap_get, _wrap_NullBitmap_set);
23067 SWIG_addvarlink(SWIG_globals,(char*)"NullIcon",_wrap_NullIcon_get, _wrap_NullIcon_set);
23068 SWIG_addvarlink(SWIG_globals,(char*)"NullCursor",_wrap_NullCursor_get, _wrap_NullCursor_set);
23069 SWIG_addvarlink(SWIG_globals,(char*)"NullPen",_wrap_NullPen_get, _wrap_NullPen_set);
23070 SWIG_addvarlink(SWIG_globals,(char*)"NullBrush",_wrap_NullBrush_get, _wrap_NullBrush_set);
23071 SWIG_addvarlink(SWIG_globals,(char*)"NullPalette",_wrap_NullPalette_get, _wrap_NullPalette_set);
23072 SWIG_addvarlink(SWIG_globals,(char*)"NullFont",_wrap_NullFont_get, _wrap_NullFont_set);
23073 SWIG_addvarlink(SWIG_globals,(char*)"NullColour",_wrap_NullColour_get, _wrap_NullColour_set);
23074 SWIG_addvarlink(SWIG_globals,(char*)"TheFontList",_wrap_TheFontList_get, _wrap_TheFontList_set);
23075 SWIG_addvarlink(SWIG_globals,(char*)"ThePenList",_wrap_ThePenList_get, _wrap_ThePenList_set);
23076 SWIG_addvarlink(SWIG_globals,(char*)"TheBrushList",_wrap_TheBrushList_get, _wrap_TheBrushList_set);
23077 SWIG_addvarlink(SWIG_globals,(char*)"TheColourDatabase",_wrap_TheColourDatabase_get, _wrap_TheColourDatabase_set);
23078
23079 // Work around a chicken/egg problem in drawlist.cpp
23080 wxPyDrawList_SetAPIPtr();
23081
23082 }
23083
wxWidgets (Impactor)