]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_gdi_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
reSWIGged
[wxWidgets.git] / wxPython / src / msw / _gdi_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 if (str)
1041 Py_DECREF(str);
1042 return;
1043 }
1044 }
1045 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1046 } else {
1047 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1048 }
1049 }
1050
1051 SWIGRUNTIMEINLINE void
1052 SWIG_Python_NullRef(const char *type)
1053 {
1054 if (type) {
1055 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1056 } else {
1057 PyErr_Format(PyExc_TypeError, "null reference was received");
1058 }
1059 }
1060
1061 SWIGRUNTIME int
1062 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1063 {
1064 if (PyErr_Occurred()) {
1065 PyObject *type = 0;
1066 PyObject *value = 0;
1067 PyObject *traceback = 0;
1068 PyErr_Fetch(&type, &value, &traceback);
1069 if (value) {
1070 PyObject *old_str = PyObject_Str(value);
1071 Py_XINCREF(type);
1072 PyErr_Clear();
1073 if (infront) {
1074 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1075 } else {
1076 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1077 }
1078 Py_DECREF(old_str);
1079 }
1080 return 1;
1081 } else {
1082 return 0;
1083 }
1084 }
1085
1086 SWIGRUNTIME int
1087 SWIG_Python_ArgFail(int argnum)
1088 {
1089 if (PyErr_Occurred()) {
1090 /* add information about failing argument */
1091 char mesg[256];
1092 sprintf(mesg, "argument number %d:", argnum);
1093 return SWIG_Python_AddErrMesg(mesg, 1);
1094 } else {
1095 return 0;
1096 }
1097 }
1098
1099
1100 /* -----------------------------------------------------------------------------
1101 * pointers/data manipulation
1102 * ----------------------------------------------------------------------------- */
1103
1104 /* Convert a pointer value */
1105 SWIGRUNTIME int
1106 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1107 swig_type_info *tc;
1108 const char *c = 0;
1109 static PyObject *SWIG_this = 0;
1110 int newref = 0;
1111 PyObject *pyobj = 0;
1112 void *vptr;
1113
1114 if (!obj) return 0;
1115 if (obj == Py_None) {
1116 *ptr = 0;
1117 return 0;
1118 }
1119
1120 #ifdef SWIG_COBJECT_TYPES
1121 if (!(PySwigObject_Check(obj))) {
1122 if (!SWIG_this)
1123 SWIG_this = PyString_FromString("this");
1124 pyobj = obj;
1125 obj = PyObject_GetAttr(obj,SWIG_this);
1126 newref = 1;
1127 if (!obj) goto type_error;
1128 if (!PySwigObject_Check(obj)) {
1129 Py_DECREF(obj);
1130 goto type_error;
1131 }
1132 }
1133 vptr = PySwigObject_AsVoidPtr(obj);
1134 c = (const char *) PySwigObject_GetDesc(obj);
1135 if (newref) { Py_DECREF(obj); }
1136 goto type_check;
1137 #else
1138 if (!(PyString_Check(obj))) {
1139 if (!SWIG_this)
1140 SWIG_this = PyString_FromString("this");
1141 pyobj = obj;
1142 obj = PyObject_GetAttr(obj,SWIG_this);
1143 newref = 1;
1144 if (!obj) goto type_error;
1145 if (!PyString_Check(obj)) {
1146 Py_DECREF(obj);
1147 goto type_error;
1148 }
1149 }
1150 c = PyString_AS_STRING(obj);
1151 /* Pointer values must start with leading underscore */
1152 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1153 if (newref) { Py_DECREF(obj); }
1154 if (!c) goto type_error;
1155 #endif
1156
1157 type_check:
1158
1159 if (ty) {
1160 tc = SWIG_TypeCheck(c,ty);
1161 if (!tc) goto type_error;
1162 *ptr = SWIG_TypeCast(tc,vptr);
1163 } else {
1164 *ptr = vptr;
1165 }
1166
1167 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1168 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1169 }
1170 return 0;
1171
1172 type_error:
1173 PyErr_Clear();
1174 if (pyobj && !obj) {
1175 obj = pyobj;
1176 if (PyCFunction_Check(obj)) {
1177 /* here we get the method pointer for callbacks */
1178 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1179 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1180 if (c) {
1181 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1182 if (!c) goto type_error;
1183 goto type_check;
1184 }
1185 }
1186 }
1187 if (flags & SWIG_POINTER_EXCEPTION) {
1188 if (ty) {
1189 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1190 } else {
1191 SWIG_Python_TypeError("C/C++ pointer", obj);
1192 }
1193 }
1194 return -1;
1195 }
1196
1197 /* Convert a pointer value, signal an exception on a type mismatch */
1198 SWIGRUNTIME void *
1199 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1200 void *result;
1201 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1202 PyErr_Clear();
1203 if (flags & SWIG_POINTER_EXCEPTION) {
1204 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1205 SWIG_Python_ArgFail(argnum);
1206 }
1207 }
1208 return result;
1209 }
1210
1211 /* Convert a packed value value */
1212 SWIGRUNTIME int
1213 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1214 swig_type_info *tc;
1215 const char *c = 0;
1216
1217 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1218 c = PySwigPacked_UnpackData(obj, ptr, sz);
1219 #else
1220 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1221 c = PyString_AS_STRING(obj);
1222 /* Pointer values must start with leading underscore */
1223 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1224 #endif
1225 if (!c) goto type_error;
1226 if (ty) {
1227 tc = SWIG_TypeCheck(c,ty);
1228 if (!tc) goto type_error;
1229 }
1230 return 0;
1231
1232 type_error:
1233 PyErr_Clear();
1234 if (flags & SWIG_POINTER_EXCEPTION) {
1235 if (ty) {
1236 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1237 } else {
1238 SWIG_Python_TypeError("C/C++ packed data", obj);
1239 }
1240 }
1241 return -1;
1242 }
1243
1244 /* Create a new array object */
1245 SWIGRUNTIME PyObject *
1246 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1247 PyObject *robj = 0;
1248 if (!ptr) {
1249 Py_INCREF(Py_None);
1250 return Py_None;
1251 }
1252 #ifdef SWIG_COBJECT_TYPES
1253 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1254 #else
1255 {
1256 char result[SWIG_BUFFER_SIZE];
1257 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1258 PyString_FromString(result) : 0;
1259 }
1260 #endif
1261 if (!robj || (robj == Py_None)) return robj;
1262 if (type->clientdata) {
1263 PyObject *inst;
1264 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1265 Py_DECREF(robj);
1266 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1267 Py_DECREF(args);
1268 if (inst) {
1269 if (own) {
1270 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1271 }
1272 robj = inst;
1273 }
1274 }
1275 return robj;
1276 }
1277
1278 SWIGRUNTIME PyObject *
1279 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1280 PyObject *robj = 0;
1281 if (!ptr) {
1282 Py_INCREF(Py_None);
1283 return Py_None;
1284 }
1285 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1286 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1287 #else
1288 {
1289 char result[SWIG_BUFFER_SIZE];
1290 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1291 PyString_FromString(result) : 0;
1292 }
1293 #endif
1294 return robj;
1295 }
1296
1297 /* -----------------------------------------------------------------------------*
1298 * Get type list
1299 * -----------------------------------------------------------------------------*/
1300
1301 #ifdef SWIG_LINK_RUNTIME
1302 void *SWIG_ReturnGlobalTypeList(void *);
1303 #endif
1304
1305 SWIGRUNTIME swig_type_info **
1306 SWIG_Python_GetTypeListHandle() {
1307 static void *type_pointer = (void *)0;
1308 /* first check if module already created */
1309 if (!type_pointer) {
1310 #ifdef SWIG_LINK_RUNTIME
1311 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1312 #else
1313 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1314 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1315 if (PyErr_Occurred()) {
1316 PyErr_Clear();
1317 type_pointer = (void *)0;
1318 }
1319 }
1320 #endif
1321 return (swig_type_info **) type_pointer;
1322 }
1323
1324 /*
1325 Search for a swig_type_info structure
1326 */
1327 SWIGRUNTIMEINLINE swig_type_info *
1328 SWIG_Python_GetTypeList() {
1329 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1330 return tlh ? *tlh : (swig_type_info*)0;
1331 }
1332
1333 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1334
1335 #ifdef __cplusplus
1336 }
1337 #endif
1338
1339
1340 /* -------- TYPES TABLE (BEGIN) -------- */
1341
1342 #define SWIGTYPE_p_wxPostScriptDC swig_types[0]
1343 #define SWIGTYPE_p_wxBrush swig_types[1]
1344 #define SWIGTYPE_p_wxColour swig_types[2]
1345 #define SWIGTYPE_p_wxDC swig_types[3]
1346 #define SWIGTYPE_p_wxMirrorDC swig_types[4]
1347 #define SWIGTYPE_p_form_ops_t swig_types[5]
1348 #define SWIGTYPE_p_wxRendererVersion swig_types[6]
1349 #define SWIGTYPE_p_wxDuplexMode swig_types[7]
1350 #define SWIGTYPE_p_wxPyFontEnumerator swig_types[8]
1351 #define SWIGTYPE_p_char swig_types[9]
1352 #define SWIGTYPE_p_wxIconLocation swig_types[10]
1353 #define SWIGTYPE_p_wxImage swig_types[11]
1354 #define SWIGTYPE_p_wxMetaFileDC swig_types[12]
1355 #define SWIGTYPE_p_wxMask swig_types[13]
1356 #define SWIGTYPE_p_wxSize swig_types[14]
1357 #define SWIGTYPE_p_wxFont swig_types[15]
1358 #define SWIGTYPE_p_wxWindow swig_types[16]
1359 #define SWIGTYPE_p_double swig_types[17]
1360 #define SWIGTYPE_p_wxMemoryDC swig_types[18]
1361 #define SWIGTYPE_p_wxFontMapper swig_types[19]
1362 #define SWIGTYPE_p_wxEffects swig_types[20]
1363 #define SWIGTYPE_p_wxNativeEncodingInfo swig_types[21]
1364 #define SWIGTYPE_p_wxPalette swig_types[22]
1365 #define SWIGTYPE_p_wxBitmap swig_types[23]
1366 #define SWIGTYPE_p_wxObject swig_types[24]
1367 #define SWIGTYPE_p_wxRegionIterator swig_types[25]
1368 #define SWIGTYPE_p_wxRect swig_types[26]
1369 #define SWIGTYPE_p_wxPaperSize swig_types[27]
1370 #define SWIGTYPE_p_wxString swig_types[28]
1371 #define SWIGTYPE_unsigned_int swig_types[29]
1372 #define SWIGTYPE_p_unsigned_int swig_types[30]
1373 #define SWIGTYPE_p_wxPrinterDC swig_types[31]
1374 #define SWIGTYPE_p_wxIconBundle swig_types[32]
1375 #define SWIGTYPE_p_wxPoint swig_types[33]
1376 #define SWIGTYPE_p_wxDash swig_types[34]
1377 #define SWIGTYPE_p_wxScreenDC swig_types[35]
1378 #define SWIGTYPE_p_wxCursor swig_types[36]
1379 #define SWIGTYPE_p_wxClientDC swig_types[37]
1380 #define SWIGTYPE_p_wxBufferedDC swig_types[38]
1381 #define SWIGTYPE_p_wxImageList swig_types[39]
1382 #define SWIGTYPE_p_unsigned_char swig_types[40]
1383 #define SWIGTYPE_p_wxGDIObject swig_types[41]
1384 #define SWIGTYPE_p_wxIcon swig_types[42]
1385 #define SWIGTYPE_p_wxLocale swig_types[43]
1386 #define SWIGTYPE_ptrdiff_t swig_types[44]
1387 #define SWIGTYPE_std__ptrdiff_t swig_types[45]
1388 #define SWIGTYPE_p_wxRegion swig_types[46]
1389 #define SWIGTYPE_p_wxConfigBase swig_types[47]
1390 #define SWIGTYPE_p_wxLanguageInfo swig_types[48]
1391 #define SWIGTYPE_p_wxWindowDC swig_types[49]
1392 #define SWIGTYPE_p_wxPrintData swig_types[50]
1393 #define SWIGTYPE_p_wxBrushList swig_types[51]
1394 #define SWIGTYPE_p_wxFontList swig_types[52]
1395 #define SWIGTYPE_p_wxPen swig_types[53]
1396 #define SWIGTYPE_p_wxBufferedPaintDC swig_types[54]
1397 #define SWIGTYPE_p_wxPaintDC swig_types[55]
1398 #define SWIGTYPE_p_wxPenList swig_types[56]
1399 #define SWIGTYPE_p_int swig_types[57]
1400 #define SWIGTYPE_p_wxMetaFile swig_types[58]
1401 #define SWIGTYPE_p_wxRendererNative swig_types[59]
1402 #define SWIGTYPE_p_unsigned_long swig_types[60]
1403 #define SWIGTYPE_p_wxNativeFontInfo swig_types[61]
1404 #define SWIGTYPE_p_wxEncodingConverter swig_types[62]
1405 #define SWIGTYPE_p_wxSplitterRenderParams swig_types[63]
1406 #define SWIGTYPE_p_wxColourDatabase swig_types[64]
1407 static swig_type_info *swig_types[66];
1408
1409 /* -------- TYPES TABLE (END) -------- */
1410
1411
1412 /*-----------------------------------------------
1413 @(target):= _gdi_.so
1414 ------------------------------------------------*/
1415 #define SWIG_init init_gdi_
1416
1417 #define SWIG_name "_gdi_"
1418
1419 #include "wx/wxPython/wxPython.h"
1420 #include "wx/wxPython/pyclasses.h"
1421
1422
1423 static const wxString wxPyEmptyString(wxEmptyString);
1424
1425 #include <limits.h>
1426
1427
1428 SWIGINTERN int
1429 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1430 const char *errmsg)
1431 {
1432 if (value < min_value) {
1433 if (errmsg) {
1434 PyErr_Format(PyExc_OverflowError,
1435 "value %ld is less than '%s' minimum %ld",
1436 value, errmsg, min_value);
1437 }
1438 return 0;
1439 } else if (value > max_value) {
1440 if (errmsg) {
1441 PyErr_Format(PyExc_OverflowError,
1442 "value %ld is greater than '%s' maximum %ld",
1443 value, errmsg, max_value);
1444 }
1445 return 0;
1446 }
1447 return 1;
1448 }
1449
1450
1451 SWIGINTERN int
1452 SWIG_AsVal_long(PyObject* obj, long* val)
1453 {
1454 if (PyNumber_Check(obj)) {
1455 if (val) *val = PyInt_AsLong(obj);
1456 return 1;
1457 }
1458 else {
1459 SWIG_type_error("number", obj);
1460 }
1461 return 0;
1462 }
1463
1464
1465 #if INT_MAX != LONG_MAX
1466 SWIGINTERN int
1467 SWIG_AsVal_int(PyObject *obj, int *val)
1468 {
1469 const char* errmsg = val ? "int" : (char*)0;
1470 long v;
1471 if (SWIG_AsVal_long(obj, &v)) {
1472 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1473 if (val) *val = (int)(v);
1474 return 1;
1475 } else {
1476 return 0;
1477 }
1478 } else {
1479 PyErr_Clear();
1480 }
1481 if (val) {
1482 SWIG_type_error(errmsg, obj);
1483 }
1484 return 0;
1485 }
1486 #else
1487 SWIGINTERNSHORT int
1488 SWIG_AsVal_int(PyObject *obj, int *val)
1489 {
1490 return SWIG_AsVal_long(obj,(long*)val);
1491 }
1492 #endif
1493
1494
1495 SWIGINTERN int
1496 SWIG_AsVal_bool(PyObject *obj, bool *val)
1497 {
1498 if (obj == Py_True) {
1499 if (val) *val = true;
1500 return 1;
1501 }
1502 if (obj == Py_False) {
1503 if (val) *val = false;
1504 return 1;
1505 }
1506 int res = 0;
1507 if (SWIG_AsVal_int(obj, &res)) {
1508 if (val) *val = res ? true : false;
1509 return 1;
1510 } else {
1511 PyErr_Clear();
1512 }
1513 if (val) {
1514 SWIG_type_error("bool", obj);
1515 }
1516 return 0;
1517 }
1518
1519
1520 SWIGINTERNSHORT bool
1521 SWIG_As_bool(PyObject* obj)
1522 {
1523 bool v;
1524 if (!SWIG_AsVal_bool(obj, &v)) {
1525 /*
1526 this is needed to make valgrind/purify happier.
1527 */
1528 memset((void*)&v, 0, sizeof(bool));
1529 }
1530 return v;
1531 }
1532
1533
1534 SWIGINTERNSHORT int
1535 SWIG_Check_bool(PyObject* obj)
1536 {
1537 return SWIG_AsVal_bool(obj, (bool*)0);
1538 }
1539
1540
1541 SWIGINTERN int
1542 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1543 {
1544 long v = 0;
1545 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1546 SWIG_type_error("unsigned number", obj);
1547 }
1548 else if (val)
1549 *val = (unsigned long)v;
1550 return 1;
1551 }
1552
1553
1554 SWIGINTERNSHORT int
1555 SWIG_CheckUnsignedLongInRange(unsigned long value,
1556 unsigned long max_value,
1557 const char *errmsg)
1558 {
1559 if (value > max_value) {
1560 if (errmsg) {
1561 PyErr_Format(PyExc_OverflowError,
1562 "value %lu is greater than '%s' minimum %lu",
1563 value, errmsg, max_value);
1564 }
1565 return 0;
1566 }
1567 return 1;
1568 }
1569
1570
1571 SWIGINTERN int
1572 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
1573 {
1574 const char* errmsg = val ? "unsigned char" : (char*)0;
1575 unsigned long v;
1576 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1577 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
1578 if (val) *val = (unsigned char)(v);
1579 return 1;
1580 } else {
1581 return 0;
1582 }
1583 } else {
1584 PyErr_Clear();
1585 }
1586 if (val) {
1587 SWIG_type_error(errmsg, obj);
1588 }
1589 return 0;
1590 }
1591
1592
1593 SWIGINTERNSHORT unsigned char
1594 SWIG_As_unsigned_SS_char(PyObject* obj)
1595 {
1596 unsigned char v;
1597 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
1598 /*
1599 this is needed to make valgrind/purify happier.
1600 */
1601 memset((void*)&v, 0, sizeof(unsigned char));
1602 }
1603 return v;
1604 }
1605
1606
1607 SWIGINTERNSHORT int
1608 SWIG_Check_unsigned_SS_char(PyObject* obj)
1609 {
1610 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
1611 }
1612
1613
1614 SWIGINTERNSHORT unsigned long
1615 SWIG_As_unsigned_SS_long(PyObject* obj)
1616 {
1617 unsigned long v;
1618 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1619 /*
1620 this is needed to make valgrind/purify happier.
1621 */
1622 memset((void*)&v, 0, sizeof(unsigned long));
1623 }
1624 return v;
1625 }
1626
1627
1628 SWIGINTERNSHORT int
1629 SWIG_Check_unsigned_SS_long(PyObject* obj)
1630 {
1631 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1632 }
1633
1634
1635 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1636 #define SWIG_From_unsigned_SS_char PyInt_FromLong
1637 /*@@*/
1638
1639
1640 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1641 #define SWIG_From_long PyInt_FromLong
1642 /*@@*/
1643
1644 static PyObject *wxColour_Get(wxColour *self){
1645 PyObject* rv = PyTuple_New(3);
1646 int red = -1;
1647 int green = -1;
1648 int blue = -1;
1649 if (self->Ok()) {
1650 red = self->Red();
1651 green = self->Green();
1652 blue = self->Blue();
1653 }
1654 PyTuple_SetItem(rv, 0, PyInt_FromLong(red));
1655 PyTuple_SetItem(rv, 1, PyInt_FromLong(green));
1656 PyTuple_SetItem(rv, 2, PyInt_FromLong(blue));
1657 return rv;
1658 }
1659 static unsigned long wxColour_GetRGB(wxColour *self){
1660 return self->Red() | (self->Green() << 8) | (self->Blue() << 16);
1661 }
1662
1663 SWIGINTERNSHORT PyObject*
1664 SWIG_From_unsigned_SS_long(unsigned long value)
1665 {
1666 return (value > LONG_MAX) ?
1667 PyLong_FromUnsignedLong(value)
1668 : PyInt_FromLong((long)(value));
1669 }
1670
1671
1672 SWIGINTERNSHORT int
1673 SWIG_As_int(PyObject* obj)
1674 {
1675 int v;
1676 if (!SWIG_AsVal_int(obj, &v)) {
1677 /*
1678 this is needed to make valgrind/purify happier.
1679 */
1680 memset((void*)&v, 0, sizeof(int));
1681 }
1682 return v;
1683 }
1684
1685
1686 SWIGINTERNSHORT int
1687 SWIG_Check_int(PyObject* obj)
1688 {
1689 return SWIG_AsVal_int(obj, (int*)0);
1690 }
1691
1692
1693 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1694 #define SWIG_From_int PyInt_FromLong
1695 /*@@*/
1696
1697
1698 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1699 PyObject* o2;
1700 PyObject* o3;
1701
1702 if (!target) {
1703 target = o;
1704 } else if (target == Py_None) {
1705 Py_DECREF(Py_None);
1706 target = o;
1707 } else {
1708 if (!PyTuple_Check(target)) {
1709 o2 = target;
1710 target = PyTuple_New(1);
1711 PyTuple_SetItem(target, 0, o2);
1712 }
1713 o3 = PyTuple_New(1);
1714 PyTuple_SetItem(o3, 0, o);
1715
1716 o2 = target;
1717 target = PySequence_Concat(o2, o3);
1718 Py_DECREF(o2);
1719 Py_DECREF(o3);
1720 }
1721 return target;
1722 }
1723
1724
1725 static PyObject *wxPen_GetDashes(wxPen *self){
1726 wxDash* dashes;
1727 int count = self->GetDashes(&dashes);
1728 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1729 PyObject* retval = PyList_New(0);
1730 for (int x=0; x<count; x++) {
1731 PyObject* pyint = PyInt_FromLong(dashes[x]);
1732 PyList_Append(retval, pyint);
1733 Py_DECREF(pyint);
1734 }
1735 wxPyEndBlockThreads(blocked);
1736 return retval;
1737 }
1738 static void wxPen__SetDashes(wxPen *self,PyObject *_self,PyObject *pyDashes){
1739 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1740 int size = PyList_Size(pyDashes);
1741 wxDash* dashes = (wxDash*)byte_LIST_helper(pyDashes);
1742
1743 // black magic warning! The array of wxDashes needs to exist as
1744 // long as the pen does because wxPen does not copy the array. So
1745 // stick a copy in a Python string object and attach it to _self,
1746 // and then call SetDashes with a pointer to that array. Then
1747 // when the Python pen object is destroyed the array will be
1748 // cleaned up too.
1749 PyObject* strDashes = PyString_FromStringAndSize((char*)dashes, size*sizeof(wxDash));
1750 PyObject_SetAttrString(_self, "_dashes", strDashes);
1751
1752 self->SetDashes(size, (wxDash*)PyString_AS_STRING(strDashes));
1753 delete [] dashes;
1754 Py_DECREF(strDashes);
1755 wxPyEndBlockThreads(blocked);
1756 }
1757 static bool wxPen___eq__(wxPen *self,wxPen const *other){ return other ? (*self == *other) : false; }
1758 static bool wxPen___ne__(wxPen *self,wxPen const *other){ return other ? (*self != *other) : true; }
1759
1760 #include <wx/image.h>
1761
1762 static char** ConvertListOfStrings(PyObject* listOfStrings) {
1763 char** cArray = NULL;
1764 int count;
1765
1766 if (!PyList_Check(listOfStrings)) {
1767 PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
1768 return NULL;
1769 }
1770 count = PyList_Size(listOfStrings);
1771 cArray = new char*[count];
1772
1773 for(int x=0; x<count; x++) {
1774 // TODO: Need some validation and error checking here
1775 cArray[x] = PyString_AsString(PyList_GET_ITEM(listOfStrings, x));
1776 }
1777 return cArray;
1778 }
1779
1780
1781 static wxBitmap *new_wxBitmap(PyObject *listOfStrings){
1782 char** cArray = NULL;
1783 wxBitmap* bmp;
1784
1785 cArray = ConvertListOfStrings(listOfStrings);
1786 if (! cArray)
1787 return NULL;
1788 bmp = new wxBitmap(cArray);
1789 delete [] cArray;
1790 return bmp;
1791 }
1792 static wxBitmap *new_wxBitmap(PyObject *bits,int width,int height,int depth=1){
1793 char* buf;
1794 int length;
1795 PyString_AsStringAndSize(bits, &buf, &length);
1796 return new wxBitmap(buf, width, height, depth);
1797 }
1798
1799 SWIGINTERNSHORT long
1800 SWIG_As_long(PyObject* obj)
1801 {
1802 long v;
1803 if (!SWIG_AsVal_long(obj, &v)) {
1804 /*
1805 this is needed to make valgrind/purify happier.
1806 */
1807 memset((void*)&v, 0, sizeof(long));
1808 }
1809 return v;
1810 }
1811
1812
1813 SWIGINTERNSHORT int
1814 SWIG_Check_long(PyObject* obj)
1815 {
1816 return SWIG_AsVal_long(obj, (long*)0);
1817 }
1818
1819 static void wxBitmap_SetHandle(wxBitmap *self,long handle){ self->SetHandle((WXHANDLE)handle); }
1820 static wxSize wxBitmap_GetSize(wxBitmap *self){
1821 wxSize size(self->GetWidth(), self->GetHeight());
1822 return size;
1823 }
1824 static void wxBitmap_SetMaskColour(wxBitmap *self,wxColour const &colour){
1825 wxMask *mask = new wxMask(*self, colour);
1826 self->SetMask(mask);
1827 }
1828 static void wxBitmap_SetSize(wxBitmap *self,wxSize const &size){
1829 self->SetWidth(size.x);
1830 self->SetHeight(size.y);
1831 }
1832 static bool wxBitmap___eq__(wxBitmap *self,wxBitmap const *other){ return other ? (*self == *other) : false; }
1833 static bool wxBitmap___ne__(wxBitmap *self,wxBitmap const *other){ return other ? (*self != *other) : true; }
1834 static wxMask *new_wxMask(wxBitmap const &bitmap,wxColour const &colour=wxNullColour){
1835 if ( !colour.Ok() )
1836 return new wxMask(bitmap, *wxBLACK);
1837 else
1838 return new wxMask(bitmap, colour);
1839 }
1840
1841 #include <wx/iconbndl.h>
1842
1843 static wxIcon *new_wxIcon(wxBitmap const &bmp){
1844 wxIcon* icon = new wxIcon();
1845 icon->CopyFromBitmap(bmp);
1846 return icon;
1847 }
1848 static wxIcon *new_wxIcon(PyObject *listOfStrings){
1849 char** cArray = NULL;
1850 wxIcon* icon;
1851
1852 cArray = ConvertListOfStrings(listOfStrings);
1853 if (! cArray)
1854 return NULL;
1855 icon = new wxIcon(cArray);
1856 delete [] cArray;
1857 return icon;
1858 }
1859 static void wxIcon_SetHandle(wxIcon *self,long handle){ self->SetHandle((WXHANDLE)handle); }
1860 static wxIconLocation *new_wxIconLocation(wxString const *filename=&wxPyEmptyString,int num=0){
1861
1862 return new wxIconLocation(*filename, num);
1863
1864
1865
1866 }
1867 static void wxIconLocation_SetIndex(wxIconLocation *self,int num){
1868
1869 self->SetIndex(num);
1870
1871
1872
1873 }
1874 static int wxIconLocation_GetIndex(wxIconLocation *self){
1875
1876 return self->GetIndex();
1877
1878
1879
1880 }
1881 static wxCursor *new_wxCursor(wxString const &cursorName,long type,int hotSpotX=0,int hotSpotY=0){
1882 #ifdef __WXGTK__
1883 wxImage img(cursorName, type);
1884 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X, hotSpotX);
1885 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y, hotSpotY);
1886 return new wxCursor(img);
1887 #else
1888 return new wxCursor(cursorName, type, hotSpotX, hotSpotY);
1889 #endif
1890 }
1891 static void wxCursor_SetHandle(wxCursor *self,long handle){ self->SetHandle((WXHANDLE)handle); }
1892
1893
1894 static void wxRegionIterator_Next(wxRegionIterator *self){
1895 (*self) ++;
1896 }
1897 static bool wxRegionIterator___nonzero__(wxRegionIterator *self){
1898 return self->operator bool();
1899 }
1900
1901 #include <wx/fontutil.h>
1902 #include <wx/fontmap.h>
1903 #include <wx/fontenum.h>
1904
1905 static wxString wxNativeFontInfo___str__(wxNativeFontInfo *self){
1906 return self->ToString();
1907 }
1908
1909 wxNativeEncodingInfo* wxGetNativeFontEncoding(wxFontEncoding encoding)
1910 { wxPyRaiseNotImplemented(); return NULL; }
1911
1912 bool wxTestFontEncoding(const wxNativeEncodingInfo& info)
1913 { wxPyRaiseNotImplemented(); return false; }
1914
1915 static PyObject *wxFontMapper_GetAltForEncoding(wxFontMapper *self,wxFontEncoding encoding,wxString const &facename=wxPyEmptyString,bool interactive=true){
1916 wxFontEncoding alt_enc;
1917 if (self->GetAltForEncoding(encoding, &alt_enc, facename, interactive))
1918 return PyInt_FromLong(alt_enc);
1919 else {
1920 Py_INCREF(Py_None);
1921 return Py_None;
1922 }
1923 }
1924 static wxFont *new_wxFont(wxString const &info){
1925 wxNativeFontInfo nfi;
1926 nfi.FromString(info);
1927 return new wxFont(nfi);
1928 }
1929 static wxFont *new_wxFont(int pointSize,wxFontFamily family,int flags=wxFONTFLAG_DEFAULT,wxString const &face=wxPyEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1930 return wxFont::New(pointSize, family, flags, face, encoding);
1931 }
1932 static wxFont *new_wxFont(wxSize const &pixelSize,int family,int style,int weight,bool underlined=false,wxString const &face=wxEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1933 return wxFontBase::New(pixelSize, family,
1934 style, weight, underlined,
1935 face, encoding);
1936 }
1937 static wxFont *new_wxFont(wxSize const &pixelSize,wxFontFamily family,int flags=wxFONTFLAG_DEFAULT,wxString const &face=wxEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1938 return wxFontBase::New(pixelSize, family, flags, face, encoding);
1939 }
1940 static bool wxFont___eq__(wxFont *self,wxFont const *other){ return other ? (*self == *other) : false; }
1941 static bool wxFont___ne__(wxFont *self,wxFont const *other){ return other ? (*self != *other) : true; }
1942
1943 class wxPyFontEnumerator : public wxFontEnumerator {
1944 public:
1945 wxPyFontEnumerator() {}
1946 ~wxPyFontEnumerator() {}
1947
1948 DEC_PYCALLBACK_BOOL_STRING(OnFacename);
1949 DEC_PYCALLBACK_BOOL_STRINGSTRING(OnFontEncoding);
1950
1951 PYPRIVATE;
1952 };
1953
1954 IMP_PYCALLBACK_BOOL_STRING(wxPyFontEnumerator, wxFontEnumerator, OnFacename);
1955 IMP_PYCALLBACK_BOOL_STRINGSTRING(wxPyFontEnumerator, wxFontEnumerator, OnFontEncoding);
1956
1957
1958 static PyObject *wxPyFontEnumerator_GetEncodings(wxPyFontEnumerator *self){
1959 wxArrayString* arr = self->GetEncodings();
1960 if (arr)
1961 return wxArrayString2PyList_helper(*arr);
1962 else
1963 return PyList_New(0);
1964 }
1965 static PyObject *wxPyFontEnumerator_GetFacenames(wxPyFontEnumerator *self){
1966 wxArrayString* arr = self->GetFacenames();
1967 if (arr)
1968 return wxArrayString2PyList_helper(*arr);
1969 else
1970 return PyList_New(0);
1971 }
1972
1973 #include <locale.h>
1974
1975 static wxLocale *new_wxLocale(int language=-1,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
1976 wxLocale* loc;
1977 if (language == -1)
1978 loc = new wxLocale();
1979 else
1980 loc = new wxLocale(language, flags);
1981 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1982 // for the floating point conversions and such to work right.
1983 #if PY_VERSION_HEX < 0x02040000
1984 setlocale(LC_NUMERIC, "C");
1985 #endif
1986 return loc;
1987 }
1988 static bool wxLocale_Init1(wxLocale *self,wxString const &szName,wxString const &szShort=wxPyEmptyString,wxString const &szLocale=wxPyEmptyString,bool bLoadDefault=true,bool bConvertEncoding=false){
1989 bool rc = self->Init(szName, szShort, szLocale, bLoadDefault, bConvertEncoding);
1990 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1991 // for the floating point conversions and such to work right.
1992 #if PY_VERSION_HEX < 0x02040000
1993 setlocale(LC_NUMERIC, "C");
1994 #endif
1995 return rc;
1996 }
1997 static bool wxLocale_Init2(wxLocale *self,int language=wxLANGUAGE_DEFAULT,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
1998 bool rc = self->Init(language, flags);
1999 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
2000 // for the floating point conversions and such to work right.
2001 #if PY_VERSION_HEX < 0x02040000
2002 setlocale(LC_NUMERIC, "C");
2003 #endif
2004 return rc;
2005 }
2006
2007 #include "wx/wxPython/pydrawxxx.h"
2008
2009 static wxColour wxDC_GetPixel(wxDC *self,int x,int y){
2010 wxColour col;
2011 self->GetPixel(x, y, &col);
2012 return col;
2013 }
2014 static wxColour wxDC_GetPixelPoint(wxDC *self,wxPoint const &pt){
2015 wxColour col;
2016 self->GetPixel(pt, &col);
2017 return col;
2018 }
2019
2020 SWIGINTERN int
2021 SWIG_AsVal_double(PyObject *obj, double* val)
2022 {
2023 if (PyNumber_Check(obj)) {
2024 if (val) *val = PyFloat_AsDouble(obj);
2025 return 1;
2026 }
2027 else {
2028 SWIG_type_error("number", obj);
2029 }
2030 return 0;
2031 }
2032
2033
2034 SWIGINTERNSHORT double
2035 SWIG_As_double(PyObject* obj)
2036 {
2037 double v;
2038 if (!SWIG_AsVal_double(obj, &v)) {
2039 /*
2040 this is needed to make valgrind/purify happier.
2041 */
2042 memset((void*)&v, 0, sizeof(double));
2043 }
2044 return v;
2045 }
2046
2047
2048 SWIGINTERNSHORT int
2049 SWIG_Check_double(PyObject* obj)
2050 {
2051 return SWIG_AsVal_double(obj, (double*)0);
2052 }
2053
2054 static wxRect wxDC_DrawImageLabel(wxDC *self,wxString const &text,wxBitmap const &image,wxRect const &rect,int alignment=wxALIGN_LEFT|wxALIGN_TOP,int indexAccel=-1){
2055 wxRect rv;
2056 self->DrawLabel(text, image, rect, alignment, indexAccel, &rv);
2057 return rv;
2058 }
2059
2060 static wxRect wxDC_GetClippingRect(wxDC *self){
2061 wxRect rect;
2062 self->GetClippingBox(rect);
2063 return rect;
2064 }
2065 static wxArrayInt wxDC_GetPartialTextExtents(wxDC *self,wxString const &text){
2066 wxArrayInt widths;
2067 self->GetPartialTextExtents(text, widths);
2068 return widths;
2069 }
2070
2071 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2072 #define SWIG_From_double PyFloat_FromDouble
2073 /*@@*/
2074
2075
2076 static void wxDC_SetLogicalOriginPoint(wxDC *self,wxPoint const &point){
2077 self->SetLogicalOrigin(point.x, point.y);
2078 }
2079 static void wxDC_SetDeviceOriginPoint(wxDC *self,wxPoint const &point){
2080 self->SetDeviceOrigin(point.x, point.y);
2081 }
2082 static void wxDC_CalcBoundingBoxPoint(wxDC *self,wxPoint const &point){
2083 self->CalcBoundingBox(point.x, point.y);
2084 }
2085 static PyObject *wxDC__DrawPointList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2086 return wxPyDrawXXXList(*self, wxPyDrawXXXPoint, pyCoords, pyPens, pyBrushes);
2087 }
2088 static PyObject *wxDC__DrawLineList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2089 return wxPyDrawXXXList(*self, wxPyDrawXXXLine, pyCoords, pyPens, pyBrushes);
2090 }
2091 static PyObject *wxDC__DrawRectangleList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2092 return wxPyDrawXXXList(*self, wxPyDrawXXXRectangle, pyCoords, pyPens, pyBrushes);
2093 }
2094 static PyObject *wxDC__DrawEllipseList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2095 return wxPyDrawXXXList(*self, wxPyDrawXXXEllipse, pyCoords, pyPens, pyBrushes);
2096 }
2097 static PyObject *wxDC__DrawPolygonList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2098 return wxPyDrawXXXList(*self, wxPyDrawXXXPolygon, pyCoords, pyPens, pyBrushes);
2099 }
2100 static PyObject *wxDC__DrawTextList(wxDC *self,PyObject *textList,PyObject *pyPoints,PyObject *foregroundList,PyObject *backgroundList){
2101 return wxPyDrawTextList(*self, textList, pyPoints, foregroundList, backgroundList);
2102 }
2103
2104 static void wxDC_GetBoundingBox(wxDC* dc, int* x1, int* y1, int* x2, int* y2) {
2105 *x1 = dc->MinX();
2106 *y1 = dc->MinY();
2107 *x2 = dc->MaxX();
2108 *y2 = dc->MaxY();
2109 }
2110
2111
2112 #include <wx/dcbuffer.h>
2113
2114
2115 #include <wx/dcps.h>
2116
2117
2118 #include <wx/metafile.h>
2119
2120
2121
2122 static void wxColourDatabase_Append(wxColourDatabase *self,wxString const &name,int red,int green,int blue){
2123 self->AddColour(name, wxColour(red, green, blue));
2124 }
2125
2126 #include <wx/effects.h>
2127
2128
2129 #include "wx/renderer.h"
2130
2131
2132 SWIGINTERNSHORT PyObject*
2133 SWIG_From_bool(bool value)
2134 {
2135 PyObject *obj = value ? Py_True : Py_False;
2136 Py_INCREF(obj);
2137 return obj;
2138 }
2139
2140 #ifdef __cplusplus
2141 extern "C" {
2142 #endif
2143 static PyObject *_wrap_new_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2144 PyObject *resultobj;
2145 wxGDIObject *result;
2146 char *kwnames[] = {
2147 NULL
2148 };
2149
2150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GDIObject",kwnames)) goto fail;
2151 {
2152 if (!wxPyCheckForApp()) SWIG_fail;
2153 PyThreadState* __tstate = wxPyBeginAllowThreads();
2154 result = (wxGDIObject *)new wxGDIObject();
2155
2156 wxPyEndAllowThreads(__tstate);
2157 if (PyErr_Occurred()) SWIG_fail;
2158 }
2159 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGDIObject, 1);
2160 return resultobj;
2161 fail:
2162 return NULL;
2163 }
2164
2165
2166 static PyObject *_wrap_delete_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2167 PyObject *resultobj;
2168 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2169 PyObject * obj0 = 0 ;
2170 char *kwnames[] = {
2171 (char *) "self", NULL
2172 };
2173
2174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GDIObject",kwnames,&obj0)) goto fail;
2175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2176 if (SWIG_arg_fail(1)) SWIG_fail;
2177 {
2178 PyThreadState* __tstate = wxPyBeginAllowThreads();
2179 delete arg1;
2180
2181 wxPyEndAllowThreads(__tstate);
2182 if (PyErr_Occurred()) SWIG_fail;
2183 }
2184 Py_INCREF(Py_None); resultobj = Py_None;
2185 return resultobj;
2186 fail:
2187 return NULL;
2188 }
2189
2190
2191 static PyObject *_wrap_GDIObject_GetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2192 PyObject *resultobj;
2193 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2194 bool result;
2195 PyObject * obj0 = 0 ;
2196 char *kwnames[] = {
2197 (char *) "self", NULL
2198 };
2199
2200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_GetVisible",kwnames,&obj0)) goto fail;
2201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2202 if (SWIG_arg_fail(1)) SWIG_fail;
2203 {
2204 PyThreadState* __tstate = wxPyBeginAllowThreads();
2205 result = (bool)(arg1)->GetVisible();
2206
2207 wxPyEndAllowThreads(__tstate);
2208 if (PyErr_Occurred()) SWIG_fail;
2209 }
2210 {
2211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2212 }
2213 return resultobj;
2214 fail:
2215 return NULL;
2216 }
2217
2218
2219 static PyObject *_wrap_GDIObject_SetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2220 PyObject *resultobj;
2221 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2222 bool arg2 ;
2223 PyObject * obj0 = 0 ;
2224 PyObject * obj1 = 0 ;
2225 char *kwnames[] = {
2226 (char *) "self",(char *) "visible", NULL
2227 };
2228
2229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GDIObject_SetVisible",kwnames,&obj0,&obj1)) goto fail;
2230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2231 if (SWIG_arg_fail(1)) SWIG_fail;
2232 {
2233 arg2 = (bool)(SWIG_As_bool(obj1));
2234 if (SWIG_arg_fail(2)) SWIG_fail;
2235 }
2236 {
2237 PyThreadState* __tstate = wxPyBeginAllowThreads();
2238 (arg1)->SetVisible(arg2);
2239
2240 wxPyEndAllowThreads(__tstate);
2241 if (PyErr_Occurred()) SWIG_fail;
2242 }
2243 Py_INCREF(Py_None); resultobj = Py_None;
2244 return resultobj;
2245 fail:
2246 return NULL;
2247 }
2248
2249
2250 static PyObject *_wrap_GDIObject_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
2251 PyObject *resultobj;
2252 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2253 bool result;
2254 PyObject * obj0 = 0 ;
2255 char *kwnames[] = {
2256 (char *) "self", NULL
2257 };
2258
2259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_IsNull",kwnames,&obj0)) goto fail;
2260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2261 if (SWIG_arg_fail(1)) SWIG_fail;
2262 {
2263 PyThreadState* __tstate = wxPyBeginAllowThreads();
2264 result = (bool)(arg1)->IsNull();
2265
2266 wxPyEndAllowThreads(__tstate);
2267 if (PyErr_Occurred()) SWIG_fail;
2268 }
2269 {
2270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2271 }
2272 return resultobj;
2273 fail:
2274 return NULL;
2275 }
2276
2277
2278 static PyObject * GDIObject_swigregister(PyObject *, PyObject *args) {
2279 PyObject *obj;
2280 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2281 SWIG_TypeClientData(SWIGTYPE_p_wxGDIObject, obj);
2282 Py_INCREF(obj);
2283 return Py_BuildValue((char *)"");
2284 }
2285 static PyObject *_wrap_new_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2286 PyObject *resultobj;
2287 byte arg1 = (byte) 0 ;
2288 byte arg2 = (byte) 0 ;
2289 byte arg3 = (byte) 0 ;
2290 wxColour *result;
2291 PyObject * obj0 = 0 ;
2292 PyObject * obj1 = 0 ;
2293 PyObject * obj2 = 0 ;
2294 char *kwnames[] = {
2295 (char *) "red",(char *) "green",(char *) "blue", NULL
2296 };
2297
2298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Colour",kwnames,&obj0,&obj1,&obj2)) goto fail;
2299 if (obj0) {
2300 {
2301 arg1 = (byte)(SWIG_As_unsigned_SS_char(obj0));
2302 if (SWIG_arg_fail(1)) SWIG_fail;
2303 }
2304 }
2305 if (obj1) {
2306 {
2307 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2308 if (SWIG_arg_fail(2)) SWIG_fail;
2309 }
2310 }
2311 if (obj2) {
2312 {
2313 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2314 if (SWIG_arg_fail(3)) SWIG_fail;
2315 }
2316 }
2317 {
2318 PyThreadState* __tstate = wxPyBeginAllowThreads();
2319 result = (wxColour *)new wxColour(arg1,arg2,arg3);
2320
2321 wxPyEndAllowThreads(__tstate);
2322 if (PyErr_Occurred()) SWIG_fail;
2323 }
2324 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2325 return resultobj;
2326 fail:
2327 return NULL;
2328 }
2329
2330
2331 static PyObject *_wrap_new_NamedColour(PyObject *, PyObject *args, PyObject *kwargs) {
2332 PyObject *resultobj;
2333 wxString *arg1 = 0 ;
2334 wxColour *result;
2335 bool temp1 = false ;
2336 PyObject * obj0 = 0 ;
2337 char *kwnames[] = {
2338 (char *) "colorName", NULL
2339 };
2340
2341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_NamedColour",kwnames,&obj0)) goto fail;
2342 {
2343 arg1 = wxString_in_helper(obj0);
2344 if (arg1 == NULL) SWIG_fail;
2345 temp1 = true;
2346 }
2347 {
2348 if (!wxPyCheckForApp()) SWIG_fail;
2349 PyThreadState* __tstate = wxPyBeginAllowThreads();
2350 result = (wxColour *)new wxColour((wxString const &)*arg1);
2351
2352 wxPyEndAllowThreads(__tstate);
2353 if (PyErr_Occurred()) SWIG_fail;
2354 }
2355 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2356 {
2357 if (temp1)
2358 delete arg1;
2359 }
2360 return resultobj;
2361 fail:
2362 {
2363 if (temp1)
2364 delete arg1;
2365 }
2366 return NULL;
2367 }
2368
2369
2370 static PyObject *_wrap_new_ColourRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2371 PyObject *resultobj;
2372 unsigned long arg1 ;
2373 wxColour *result;
2374 PyObject * obj0 = 0 ;
2375 char *kwnames[] = {
2376 (char *) "colRGB", NULL
2377 };
2378
2379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ColourRGB",kwnames,&obj0)) goto fail;
2380 {
2381 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
2382 if (SWIG_arg_fail(1)) SWIG_fail;
2383 }
2384 {
2385 PyThreadState* __tstate = wxPyBeginAllowThreads();
2386 result = (wxColour *)new wxColour(arg1);
2387
2388 wxPyEndAllowThreads(__tstate);
2389 if (PyErr_Occurred()) SWIG_fail;
2390 }
2391 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2392 return resultobj;
2393 fail:
2394 return NULL;
2395 }
2396
2397
2398 static PyObject *_wrap_delete_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2399 PyObject *resultobj;
2400 wxColour *arg1 = (wxColour *) 0 ;
2401 PyObject * obj0 = 0 ;
2402 char *kwnames[] = {
2403 (char *) "self", NULL
2404 };
2405
2406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Colour",kwnames,&obj0)) goto fail;
2407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2408 if (SWIG_arg_fail(1)) SWIG_fail;
2409 {
2410 PyThreadState* __tstate = wxPyBeginAllowThreads();
2411 delete arg1;
2412
2413 wxPyEndAllowThreads(__tstate);
2414 if (PyErr_Occurred()) SWIG_fail;
2415 }
2416 Py_INCREF(Py_None); resultobj = Py_None;
2417 return resultobj;
2418 fail:
2419 return NULL;
2420 }
2421
2422
2423 static PyObject *_wrap_Colour_Red(PyObject *, PyObject *args, PyObject *kwargs) {
2424 PyObject *resultobj;
2425 wxColour *arg1 = (wxColour *) 0 ;
2426 byte result;
2427 PyObject * obj0 = 0 ;
2428 char *kwnames[] = {
2429 (char *) "self", NULL
2430 };
2431
2432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Red",kwnames,&obj0)) goto fail;
2433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2434 if (SWIG_arg_fail(1)) SWIG_fail;
2435 {
2436 PyThreadState* __tstate = wxPyBeginAllowThreads();
2437 result = (byte)(arg1)->Red();
2438
2439 wxPyEndAllowThreads(__tstate);
2440 if (PyErr_Occurred()) SWIG_fail;
2441 }
2442 {
2443 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2444 }
2445 return resultobj;
2446 fail:
2447 return NULL;
2448 }
2449
2450
2451 static PyObject *_wrap_Colour_Green(PyObject *, PyObject *args, PyObject *kwargs) {
2452 PyObject *resultobj;
2453 wxColour *arg1 = (wxColour *) 0 ;
2454 byte result;
2455 PyObject * obj0 = 0 ;
2456 char *kwnames[] = {
2457 (char *) "self", NULL
2458 };
2459
2460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Green",kwnames,&obj0)) goto fail;
2461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2462 if (SWIG_arg_fail(1)) SWIG_fail;
2463 {
2464 PyThreadState* __tstate = wxPyBeginAllowThreads();
2465 result = (byte)(arg1)->Green();
2466
2467 wxPyEndAllowThreads(__tstate);
2468 if (PyErr_Occurred()) SWIG_fail;
2469 }
2470 {
2471 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2472 }
2473 return resultobj;
2474 fail:
2475 return NULL;
2476 }
2477
2478
2479 static PyObject *_wrap_Colour_Blue(PyObject *, PyObject *args, PyObject *kwargs) {
2480 PyObject *resultobj;
2481 wxColour *arg1 = (wxColour *) 0 ;
2482 byte result;
2483 PyObject * obj0 = 0 ;
2484 char *kwnames[] = {
2485 (char *) "self", NULL
2486 };
2487
2488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Blue",kwnames,&obj0)) goto fail;
2489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2490 if (SWIG_arg_fail(1)) SWIG_fail;
2491 {
2492 PyThreadState* __tstate = wxPyBeginAllowThreads();
2493 result = (byte)(arg1)->Blue();
2494
2495 wxPyEndAllowThreads(__tstate);
2496 if (PyErr_Occurred()) SWIG_fail;
2497 }
2498 {
2499 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2500 }
2501 return resultobj;
2502 fail:
2503 return NULL;
2504 }
2505
2506
2507 static PyObject *_wrap_Colour_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
2508 PyObject *resultobj;
2509 wxColour *arg1 = (wxColour *) 0 ;
2510 bool result;
2511 PyObject * obj0 = 0 ;
2512 char *kwnames[] = {
2513 (char *) "self", NULL
2514 };
2515
2516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Ok",kwnames,&obj0)) goto fail;
2517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2518 if (SWIG_arg_fail(1)) SWIG_fail;
2519 {
2520 PyThreadState* __tstate = wxPyBeginAllowThreads();
2521 result = (bool)(arg1)->Ok();
2522
2523 wxPyEndAllowThreads(__tstate);
2524 if (PyErr_Occurred()) SWIG_fail;
2525 }
2526 {
2527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2528 }
2529 return resultobj;
2530 fail:
2531 return NULL;
2532 }
2533
2534
2535 static PyObject *_wrap_Colour_Set(PyObject *, PyObject *args, PyObject *kwargs) {
2536 PyObject *resultobj;
2537 wxColour *arg1 = (wxColour *) 0 ;
2538 byte arg2 ;
2539 byte arg3 ;
2540 byte arg4 ;
2541 PyObject * obj0 = 0 ;
2542 PyObject * obj1 = 0 ;
2543 PyObject * obj2 = 0 ;
2544 PyObject * obj3 = 0 ;
2545 char *kwnames[] = {
2546 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2547 };
2548
2549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Colour_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2551 if (SWIG_arg_fail(1)) SWIG_fail;
2552 {
2553 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2554 if (SWIG_arg_fail(2)) SWIG_fail;
2555 }
2556 {
2557 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2558 if (SWIG_arg_fail(3)) SWIG_fail;
2559 }
2560 {
2561 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2562 if (SWIG_arg_fail(4)) SWIG_fail;
2563 }
2564 {
2565 PyThreadState* __tstate = wxPyBeginAllowThreads();
2566 (arg1)->Set(arg2,arg3,arg4);
2567
2568 wxPyEndAllowThreads(__tstate);
2569 if (PyErr_Occurred()) SWIG_fail;
2570 }
2571 Py_INCREF(Py_None); resultobj = Py_None;
2572 return resultobj;
2573 fail:
2574 return NULL;
2575 }
2576
2577
2578 static PyObject *_wrap_Colour_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2579 PyObject *resultobj;
2580 wxColour *arg1 = (wxColour *) 0 ;
2581 unsigned long arg2 ;
2582 PyObject * obj0 = 0 ;
2583 PyObject * obj1 = 0 ;
2584 char *kwnames[] = {
2585 (char *) "self",(char *) "colRGB", NULL
2586 };
2587
2588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetRGB",kwnames,&obj0,&obj1)) goto fail;
2589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2590 if (SWIG_arg_fail(1)) SWIG_fail;
2591 {
2592 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
2593 if (SWIG_arg_fail(2)) SWIG_fail;
2594 }
2595 {
2596 PyThreadState* __tstate = wxPyBeginAllowThreads();
2597 (arg1)->Set(arg2);
2598
2599 wxPyEndAllowThreads(__tstate);
2600 if (PyErr_Occurred()) SWIG_fail;
2601 }
2602 Py_INCREF(Py_None); resultobj = Py_None;
2603 return resultobj;
2604 fail:
2605 return NULL;
2606 }
2607
2608
2609 static PyObject *_wrap_Colour_SetFromName(PyObject *, PyObject *args, PyObject *kwargs) {
2610 PyObject *resultobj;
2611 wxColour *arg1 = (wxColour *) 0 ;
2612 wxString *arg2 = 0 ;
2613 bool temp2 = false ;
2614 PyObject * obj0 = 0 ;
2615 PyObject * obj1 = 0 ;
2616 char *kwnames[] = {
2617 (char *) "self",(char *) "colourName", NULL
2618 };
2619
2620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetFromName",kwnames,&obj0,&obj1)) goto fail;
2621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2622 if (SWIG_arg_fail(1)) SWIG_fail;
2623 {
2624 arg2 = wxString_in_helper(obj1);
2625 if (arg2 == NULL) SWIG_fail;
2626 temp2 = true;
2627 }
2628 {
2629 PyThreadState* __tstate = wxPyBeginAllowThreads();
2630 (arg1)->InitFromName((wxString const &)*arg2);
2631
2632 wxPyEndAllowThreads(__tstate);
2633 if (PyErr_Occurred()) SWIG_fail;
2634 }
2635 Py_INCREF(Py_None); resultobj = Py_None;
2636 {
2637 if (temp2)
2638 delete arg2;
2639 }
2640 return resultobj;
2641 fail:
2642 {
2643 if (temp2)
2644 delete arg2;
2645 }
2646 return NULL;
2647 }
2648
2649
2650 static PyObject *_wrap_Colour_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2651 PyObject *resultobj;
2652 wxColour *arg1 = (wxColour *) 0 ;
2653 long result;
2654 PyObject * obj0 = 0 ;
2655 char *kwnames[] = {
2656 (char *) "self", NULL
2657 };
2658
2659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetPixel",kwnames,&obj0)) goto fail;
2660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2661 if (SWIG_arg_fail(1)) SWIG_fail;
2662 {
2663 PyThreadState* __tstate = wxPyBeginAllowThreads();
2664 result = (long)((wxColour const *)arg1)->GetPixel();
2665
2666 wxPyEndAllowThreads(__tstate);
2667 if (PyErr_Occurred()) SWIG_fail;
2668 }
2669 {
2670 resultobj = SWIG_From_long((long)(result));
2671 }
2672 return resultobj;
2673 fail:
2674 return NULL;
2675 }
2676
2677
2678 static PyObject *_wrap_Colour___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
2679 PyObject *resultobj;
2680 wxColour *arg1 = (wxColour *) 0 ;
2681 wxColour *arg2 = 0 ;
2682 bool result;
2683 wxColour temp2 ;
2684 PyObject * obj0 = 0 ;
2685 PyObject * obj1 = 0 ;
2686 char *kwnames[] = {
2687 (char *) "self",(char *) "colour", NULL
2688 };
2689
2690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___eq__",kwnames,&obj0,&obj1)) goto fail;
2691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2692 if (SWIG_arg_fail(1)) SWIG_fail;
2693 {
2694 arg2 = &temp2;
2695 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2696 }
2697 {
2698 PyThreadState* __tstate = wxPyBeginAllowThreads();
2699 result = (bool)((wxColour const *)arg1)->operator ==((wxColour const &)*arg2);
2700
2701 wxPyEndAllowThreads(__tstate);
2702 if (PyErr_Occurred()) SWIG_fail;
2703 }
2704 {
2705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2706 }
2707 return resultobj;
2708 fail:
2709 return NULL;
2710 }
2711
2712
2713 static PyObject *_wrap_Colour___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
2714 PyObject *resultobj;
2715 wxColour *arg1 = (wxColour *) 0 ;
2716 wxColour *arg2 = 0 ;
2717 bool result;
2718 wxColour temp2 ;
2719 PyObject * obj0 = 0 ;
2720 PyObject * obj1 = 0 ;
2721 char *kwnames[] = {
2722 (char *) "self",(char *) "colour", NULL
2723 };
2724
2725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___ne__",kwnames,&obj0,&obj1)) goto fail;
2726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2727 if (SWIG_arg_fail(1)) SWIG_fail;
2728 {
2729 arg2 = &temp2;
2730 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2731 }
2732 {
2733 PyThreadState* __tstate = wxPyBeginAllowThreads();
2734 result = (bool)((wxColour const *)arg1)->operator !=((wxColour const &)*arg2);
2735
2736 wxPyEndAllowThreads(__tstate);
2737 if (PyErr_Occurred()) SWIG_fail;
2738 }
2739 {
2740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2741 }
2742 return resultobj;
2743 fail:
2744 return NULL;
2745 }
2746
2747
2748 static PyObject *_wrap_Colour_Get(PyObject *, PyObject *args, PyObject *kwargs) {
2749 PyObject *resultobj;
2750 wxColour *arg1 = (wxColour *) 0 ;
2751 PyObject *result;
2752 PyObject * obj0 = 0 ;
2753 char *kwnames[] = {
2754 (char *) "self", NULL
2755 };
2756
2757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Get",kwnames,&obj0)) goto fail;
2758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2759 if (SWIG_arg_fail(1)) SWIG_fail;
2760 {
2761 PyThreadState* __tstate = wxPyBeginAllowThreads();
2762 result = (PyObject *)wxColour_Get(arg1);
2763
2764 wxPyEndAllowThreads(__tstate);
2765 if (PyErr_Occurred()) SWIG_fail;
2766 }
2767 resultobj = result;
2768 return resultobj;
2769 fail:
2770 return NULL;
2771 }
2772
2773
2774 static PyObject *_wrap_Colour_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2775 PyObject *resultobj;
2776 wxColour *arg1 = (wxColour *) 0 ;
2777 unsigned long result;
2778 PyObject * obj0 = 0 ;
2779 char *kwnames[] = {
2780 (char *) "self", NULL
2781 };
2782
2783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetRGB",kwnames,&obj0)) goto fail;
2784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2785 if (SWIG_arg_fail(1)) SWIG_fail;
2786 {
2787 PyThreadState* __tstate = wxPyBeginAllowThreads();
2788 result = (unsigned long)wxColour_GetRGB(arg1);
2789
2790 wxPyEndAllowThreads(__tstate);
2791 if (PyErr_Occurred()) SWIG_fail;
2792 }
2793 {
2794 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
2795 }
2796 return resultobj;
2797 fail:
2798 return NULL;
2799 }
2800
2801
2802 static PyObject * Colour_swigregister(PyObject *, PyObject *args) {
2803 PyObject *obj;
2804 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2805 SWIG_TypeClientData(SWIGTYPE_p_wxColour, obj);
2806 Py_INCREF(obj);
2807 return Py_BuildValue((char *)"");
2808 }
2809 static PyObject *_wrap_new_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2810 PyObject *resultobj;
2811 int arg1 ;
2812 unsigned char *arg2 = (unsigned char *) 0 ;
2813 unsigned char *arg3 = (unsigned char *) 0 ;
2814 unsigned char *arg4 = (unsigned char *) 0 ;
2815 wxPalette *result;
2816 PyObject * obj0 = 0 ;
2817 PyObject * obj1 = 0 ;
2818 PyObject * obj2 = 0 ;
2819 PyObject * obj3 = 0 ;
2820 char *kwnames[] = {
2821 (char *) "n",(char *) "red",(char *) "green",(char *) "blue", NULL
2822 };
2823
2824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_Palette",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2825 {
2826 arg1 = (int)(SWIG_As_int(obj0));
2827 if (SWIG_arg_fail(1)) SWIG_fail;
2828 }
2829 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2830 if (SWIG_arg_fail(2)) SWIG_fail;
2831 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2832 if (SWIG_arg_fail(3)) SWIG_fail;
2833 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2834 if (SWIG_arg_fail(4)) SWIG_fail;
2835 {
2836 if (!wxPyCheckForApp()) SWIG_fail;
2837 PyThreadState* __tstate = wxPyBeginAllowThreads();
2838 result = (wxPalette *)new wxPalette(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
2839
2840 wxPyEndAllowThreads(__tstate);
2841 if (PyErr_Occurred()) SWIG_fail;
2842 }
2843 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 1);
2844 return resultobj;
2845 fail:
2846 return NULL;
2847 }
2848
2849
2850 static PyObject *_wrap_delete_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2851 PyObject *resultobj;
2852 wxPalette *arg1 = (wxPalette *) 0 ;
2853 PyObject * obj0 = 0 ;
2854 char *kwnames[] = {
2855 (char *) "self", NULL
2856 };
2857
2858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Palette",kwnames,&obj0)) goto fail;
2859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2860 if (SWIG_arg_fail(1)) SWIG_fail;
2861 {
2862 PyThreadState* __tstate = wxPyBeginAllowThreads();
2863 delete arg1;
2864
2865 wxPyEndAllowThreads(__tstate);
2866 if (PyErr_Occurred()) SWIG_fail;
2867 }
2868 Py_INCREF(Py_None); resultobj = Py_None;
2869 return resultobj;
2870 fail:
2871 return NULL;
2872 }
2873
2874
2875 static PyObject *_wrap_Palette_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2876 PyObject *resultobj;
2877 wxPalette *arg1 = (wxPalette *) 0 ;
2878 byte arg2 ;
2879 byte arg3 ;
2880 byte arg4 ;
2881 int result;
2882 PyObject * obj0 = 0 ;
2883 PyObject * obj1 = 0 ;
2884 PyObject * obj2 = 0 ;
2885 PyObject * obj3 = 0 ;
2886 char *kwnames[] = {
2887 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2888 };
2889
2890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Palette_GetPixel",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2892 if (SWIG_arg_fail(1)) SWIG_fail;
2893 {
2894 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2895 if (SWIG_arg_fail(2)) SWIG_fail;
2896 }
2897 {
2898 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2899 if (SWIG_arg_fail(3)) SWIG_fail;
2900 }
2901 {
2902 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2903 if (SWIG_arg_fail(4)) SWIG_fail;
2904 }
2905 {
2906 PyThreadState* __tstate = wxPyBeginAllowThreads();
2907 result = (int)(arg1)->GetPixel(arg2,arg3,arg4);
2908
2909 wxPyEndAllowThreads(__tstate);
2910 if (PyErr_Occurred()) SWIG_fail;
2911 }
2912 {
2913 resultobj = SWIG_From_int((int)(result));
2914 }
2915 return resultobj;
2916 fail:
2917 return NULL;
2918 }
2919
2920
2921 static PyObject *_wrap_Palette_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2922 PyObject *resultobj;
2923 wxPalette *arg1 = (wxPalette *) 0 ;
2924 int arg2 ;
2925 byte *arg3 = (byte *) 0 ;
2926 byte *arg4 = (byte *) 0 ;
2927 byte *arg5 = (byte *) 0 ;
2928 bool result;
2929 byte temp3 ;
2930 int res3 = 0 ;
2931 byte temp4 ;
2932 int res4 = 0 ;
2933 byte temp5 ;
2934 int res5 = 0 ;
2935 PyObject * obj0 = 0 ;
2936 PyObject * obj1 = 0 ;
2937 char *kwnames[] = {
2938 (char *) "self",(char *) "pixel", NULL
2939 };
2940
2941 arg3 = &temp3; res3 = SWIG_NEWOBJ;
2942 arg4 = &temp4; res4 = SWIG_NEWOBJ;
2943 arg5 = &temp5; res5 = SWIG_NEWOBJ;
2944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Palette_GetRGB",kwnames,&obj0,&obj1)) goto fail;
2945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2946 if (SWIG_arg_fail(1)) SWIG_fail;
2947 {
2948 arg2 = (int)(SWIG_As_int(obj1));
2949 if (SWIG_arg_fail(2)) SWIG_fail;
2950 }
2951 {
2952 PyThreadState* __tstate = wxPyBeginAllowThreads();
2953 result = (bool)(arg1)->GetRGB(arg2,arg3,arg4,arg5);
2954
2955 wxPyEndAllowThreads(__tstate);
2956 if (PyErr_Occurred()) SWIG_fail;
2957 }
2958 {
2959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2960 }
2961 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
2962 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
2963 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
2964 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
2965 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
2966 SWIG_From_unsigned_SS_char((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_unsigned_char, 0)));
2967 return resultobj;
2968 fail:
2969 return NULL;
2970 }
2971
2972
2973 static PyObject *_wrap_Palette_GetColoursCount(PyObject *, PyObject *args, PyObject *kwargs) {
2974 PyObject *resultobj;
2975 wxPalette *arg1 = (wxPalette *) 0 ;
2976 int result;
2977 PyObject * obj0 = 0 ;
2978 char *kwnames[] = {
2979 (char *) "self", NULL
2980 };
2981
2982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_GetColoursCount",kwnames,&obj0)) goto fail;
2983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2984 if (SWIG_arg_fail(1)) SWIG_fail;
2985 {
2986 PyThreadState* __tstate = wxPyBeginAllowThreads();
2987 result = (int)((wxPalette const *)arg1)->GetColoursCount();
2988
2989 wxPyEndAllowThreads(__tstate);
2990 if (PyErr_Occurred()) SWIG_fail;
2991 }
2992 {
2993 resultobj = SWIG_From_int((int)(result));
2994 }
2995 return resultobj;
2996 fail:
2997 return NULL;
2998 }
2999
3000
3001 static PyObject *_wrap_Palette_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3002 PyObject *resultobj;
3003 wxPalette *arg1 = (wxPalette *) 0 ;
3004 bool result;
3005 PyObject * obj0 = 0 ;
3006 char *kwnames[] = {
3007 (char *) "self", NULL
3008 };
3009
3010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_Ok",kwnames,&obj0)) goto fail;
3011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
3012 if (SWIG_arg_fail(1)) SWIG_fail;
3013 {
3014 PyThreadState* __tstate = wxPyBeginAllowThreads();
3015 result = (bool)(arg1)->Ok();
3016
3017 wxPyEndAllowThreads(__tstate);
3018 if (PyErr_Occurred()) SWIG_fail;
3019 }
3020 {
3021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3022 }
3023 return resultobj;
3024 fail:
3025 return NULL;
3026 }
3027
3028
3029 static PyObject * Palette_swigregister(PyObject *, PyObject *args) {
3030 PyObject *obj;
3031 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3032 SWIG_TypeClientData(SWIGTYPE_p_wxPalette, obj);
3033 Py_INCREF(obj);
3034 return Py_BuildValue((char *)"");
3035 }
3036 static PyObject *_wrap_new_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3037 PyObject *resultobj;
3038 wxColour *arg1 = 0 ;
3039 int arg2 = (int) 1 ;
3040 int arg3 = (int) wxSOLID ;
3041 wxPen *result;
3042 wxColour temp1 ;
3043 PyObject * obj0 = 0 ;
3044 PyObject * obj1 = 0 ;
3045 PyObject * obj2 = 0 ;
3046 char *kwnames[] = {
3047 (char *) "colour",(char *) "width",(char *) "style", NULL
3048 };
3049
3050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Pen",kwnames,&obj0,&obj1,&obj2)) goto fail;
3051 {
3052 arg1 = &temp1;
3053 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3054 }
3055 if (obj1) {
3056 {
3057 arg2 = (int)(SWIG_As_int(obj1));
3058 if (SWIG_arg_fail(2)) SWIG_fail;
3059 }
3060 }
3061 if (obj2) {
3062 {
3063 arg3 = (int)(SWIG_As_int(obj2));
3064 if (SWIG_arg_fail(3)) SWIG_fail;
3065 }
3066 }
3067 {
3068 if (!wxPyCheckForApp()) SWIG_fail;
3069 PyThreadState* __tstate = wxPyBeginAllowThreads();
3070 result = (wxPen *)new wxPen(*arg1,arg2,arg3);
3071
3072 wxPyEndAllowThreads(__tstate);
3073 if (PyErr_Occurred()) SWIG_fail;
3074 }
3075 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 1);
3076 return resultobj;
3077 fail:
3078 return NULL;
3079 }
3080
3081
3082 static PyObject *_wrap_delete_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3083 PyObject *resultobj;
3084 wxPen *arg1 = (wxPen *) 0 ;
3085 PyObject * obj0 = 0 ;
3086 char *kwnames[] = {
3087 (char *) "self", NULL
3088 };
3089
3090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Pen",kwnames,&obj0)) goto fail;
3091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3092 if (SWIG_arg_fail(1)) SWIG_fail;
3093 {
3094 PyThreadState* __tstate = wxPyBeginAllowThreads();
3095 delete arg1;
3096
3097 wxPyEndAllowThreads(__tstate);
3098 if (PyErr_Occurred()) SWIG_fail;
3099 }
3100 Py_INCREF(Py_None); resultobj = Py_None;
3101 return resultobj;
3102 fail:
3103 return NULL;
3104 }
3105
3106
3107 static PyObject *_wrap_Pen_GetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3108 PyObject *resultobj;
3109 wxPen *arg1 = (wxPen *) 0 ;
3110 int result;
3111 PyObject * obj0 = 0 ;
3112 char *kwnames[] = {
3113 (char *) "self", NULL
3114 };
3115
3116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetCap",kwnames,&obj0)) goto fail;
3117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3118 if (SWIG_arg_fail(1)) SWIG_fail;
3119 {
3120 PyThreadState* __tstate = wxPyBeginAllowThreads();
3121 result = (int)(arg1)->GetCap();
3122
3123 wxPyEndAllowThreads(__tstate);
3124 if (PyErr_Occurred()) SWIG_fail;
3125 }
3126 {
3127 resultobj = SWIG_From_int((int)(result));
3128 }
3129 return resultobj;
3130 fail:
3131 return NULL;
3132 }
3133
3134
3135 static PyObject *_wrap_Pen_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3136 PyObject *resultobj;
3137 wxPen *arg1 = (wxPen *) 0 ;
3138 wxColour result;
3139 PyObject * obj0 = 0 ;
3140 char *kwnames[] = {
3141 (char *) "self", NULL
3142 };
3143
3144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetColour",kwnames,&obj0)) goto fail;
3145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3146 if (SWIG_arg_fail(1)) SWIG_fail;
3147 {
3148 PyThreadState* __tstate = wxPyBeginAllowThreads();
3149 result = (arg1)->GetColour();
3150
3151 wxPyEndAllowThreads(__tstate);
3152 if (PyErr_Occurred()) SWIG_fail;
3153 }
3154 {
3155 wxColour * resultptr;
3156 resultptr = new wxColour((wxColour &)(result));
3157 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3158 }
3159 return resultobj;
3160 fail:
3161 return NULL;
3162 }
3163
3164
3165 static PyObject *_wrap_Pen_GetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3166 PyObject *resultobj;
3167 wxPen *arg1 = (wxPen *) 0 ;
3168 int result;
3169 PyObject * obj0 = 0 ;
3170 char *kwnames[] = {
3171 (char *) "self", NULL
3172 };
3173
3174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetJoin",kwnames,&obj0)) goto fail;
3175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3176 if (SWIG_arg_fail(1)) SWIG_fail;
3177 {
3178 PyThreadState* __tstate = wxPyBeginAllowThreads();
3179 result = (int)(arg1)->GetJoin();
3180
3181 wxPyEndAllowThreads(__tstate);
3182 if (PyErr_Occurred()) SWIG_fail;
3183 }
3184 {
3185 resultobj = SWIG_From_int((int)(result));
3186 }
3187 return resultobj;
3188 fail:
3189 return NULL;
3190 }
3191
3192
3193 static PyObject *_wrap_Pen_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3194 PyObject *resultobj;
3195 wxPen *arg1 = (wxPen *) 0 ;
3196 int result;
3197 PyObject * obj0 = 0 ;
3198 char *kwnames[] = {
3199 (char *) "self", NULL
3200 };
3201
3202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetStyle",kwnames,&obj0)) goto fail;
3203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3204 if (SWIG_arg_fail(1)) SWIG_fail;
3205 {
3206 PyThreadState* __tstate = wxPyBeginAllowThreads();
3207 result = (int)(arg1)->GetStyle();
3208
3209 wxPyEndAllowThreads(__tstate);
3210 if (PyErr_Occurred()) SWIG_fail;
3211 }
3212 {
3213 resultobj = SWIG_From_int((int)(result));
3214 }
3215 return resultobj;
3216 fail:
3217 return NULL;
3218 }
3219
3220
3221 static PyObject *_wrap_Pen_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3222 PyObject *resultobj;
3223 wxPen *arg1 = (wxPen *) 0 ;
3224 int result;
3225 PyObject * obj0 = 0 ;
3226 char *kwnames[] = {
3227 (char *) "self", NULL
3228 };
3229
3230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetWidth",kwnames,&obj0)) goto fail;
3231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3232 if (SWIG_arg_fail(1)) SWIG_fail;
3233 {
3234 PyThreadState* __tstate = wxPyBeginAllowThreads();
3235 result = (int)(arg1)->GetWidth();
3236
3237 wxPyEndAllowThreads(__tstate);
3238 if (PyErr_Occurred()) SWIG_fail;
3239 }
3240 {
3241 resultobj = SWIG_From_int((int)(result));
3242 }
3243 return resultobj;
3244 fail:
3245 return NULL;
3246 }
3247
3248
3249 static PyObject *_wrap_Pen_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3250 PyObject *resultobj;
3251 wxPen *arg1 = (wxPen *) 0 ;
3252 bool result;
3253 PyObject * obj0 = 0 ;
3254 char *kwnames[] = {
3255 (char *) "self", NULL
3256 };
3257
3258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_Ok",kwnames,&obj0)) goto fail;
3259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3260 if (SWIG_arg_fail(1)) SWIG_fail;
3261 {
3262 PyThreadState* __tstate = wxPyBeginAllowThreads();
3263 result = (bool)(arg1)->Ok();
3264
3265 wxPyEndAllowThreads(__tstate);
3266 if (PyErr_Occurred()) SWIG_fail;
3267 }
3268 {
3269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3270 }
3271 return resultobj;
3272 fail:
3273 return NULL;
3274 }
3275
3276
3277 static PyObject *_wrap_Pen_SetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3278 PyObject *resultobj;
3279 wxPen *arg1 = (wxPen *) 0 ;
3280 int arg2 ;
3281 PyObject * obj0 = 0 ;
3282 PyObject * obj1 = 0 ;
3283 char *kwnames[] = {
3284 (char *) "self",(char *) "cap_style", NULL
3285 };
3286
3287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetCap",kwnames,&obj0,&obj1)) goto fail;
3288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3289 if (SWIG_arg_fail(1)) SWIG_fail;
3290 {
3291 arg2 = (int)(SWIG_As_int(obj1));
3292 if (SWIG_arg_fail(2)) SWIG_fail;
3293 }
3294 {
3295 PyThreadState* __tstate = wxPyBeginAllowThreads();
3296 (arg1)->SetCap(arg2);
3297
3298 wxPyEndAllowThreads(__tstate);
3299 if (PyErr_Occurred()) SWIG_fail;
3300 }
3301 Py_INCREF(Py_None); resultobj = Py_None;
3302 return resultobj;
3303 fail:
3304 return NULL;
3305 }
3306
3307
3308 static PyObject *_wrap_Pen_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3309 PyObject *resultobj;
3310 wxPen *arg1 = (wxPen *) 0 ;
3311 wxColour *arg2 = 0 ;
3312 wxColour temp2 ;
3313 PyObject * obj0 = 0 ;
3314 PyObject * obj1 = 0 ;
3315 char *kwnames[] = {
3316 (char *) "self",(char *) "colour", NULL
3317 };
3318
3319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetColour",kwnames,&obj0,&obj1)) goto fail;
3320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3321 if (SWIG_arg_fail(1)) SWIG_fail;
3322 {
3323 arg2 = &temp2;
3324 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3325 }
3326 {
3327 PyThreadState* __tstate = wxPyBeginAllowThreads();
3328 (arg1)->SetColour(*arg2);
3329
3330 wxPyEndAllowThreads(__tstate);
3331 if (PyErr_Occurred()) SWIG_fail;
3332 }
3333 Py_INCREF(Py_None); resultobj = Py_None;
3334 return resultobj;
3335 fail:
3336 return NULL;
3337 }
3338
3339
3340 static PyObject *_wrap_Pen_SetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3341 PyObject *resultobj;
3342 wxPen *arg1 = (wxPen *) 0 ;
3343 int arg2 ;
3344 PyObject * obj0 = 0 ;
3345 PyObject * obj1 = 0 ;
3346 char *kwnames[] = {
3347 (char *) "self",(char *) "join_style", NULL
3348 };
3349
3350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetJoin",kwnames,&obj0,&obj1)) goto fail;
3351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3352 if (SWIG_arg_fail(1)) SWIG_fail;
3353 {
3354 arg2 = (int)(SWIG_As_int(obj1));
3355 if (SWIG_arg_fail(2)) SWIG_fail;
3356 }
3357 {
3358 PyThreadState* __tstate = wxPyBeginAllowThreads();
3359 (arg1)->SetJoin(arg2);
3360
3361 wxPyEndAllowThreads(__tstate);
3362 if (PyErr_Occurred()) SWIG_fail;
3363 }
3364 Py_INCREF(Py_None); resultobj = Py_None;
3365 return resultobj;
3366 fail:
3367 return NULL;
3368 }
3369
3370
3371 static PyObject *_wrap_Pen_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3372 PyObject *resultobj;
3373 wxPen *arg1 = (wxPen *) 0 ;
3374 int arg2 ;
3375 PyObject * obj0 = 0 ;
3376 PyObject * obj1 = 0 ;
3377 char *kwnames[] = {
3378 (char *) "self",(char *) "style", NULL
3379 };
3380
3381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3383 if (SWIG_arg_fail(1)) SWIG_fail;
3384 {
3385 arg2 = (int)(SWIG_As_int(obj1));
3386 if (SWIG_arg_fail(2)) SWIG_fail;
3387 }
3388 {
3389 PyThreadState* __tstate = wxPyBeginAllowThreads();
3390 (arg1)->SetStyle(arg2);
3391
3392 wxPyEndAllowThreads(__tstate);
3393 if (PyErr_Occurred()) SWIG_fail;
3394 }
3395 Py_INCREF(Py_None); resultobj = Py_None;
3396 return resultobj;
3397 fail:
3398 return NULL;
3399 }
3400
3401
3402 static PyObject *_wrap_Pen_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3403 PyObject *resultobj;
3404 wxPen *arg1 = (wxPen *) 0 ;
3405 int arg2 ;
3406 PyObject * obj0 = 0 ;
3407 PyObject * obj1 = 0 ;
3408 char *kwnames[] = {
3409 (char *) "self",(char *) "width", NULL
3410 };
3411
3412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3414 if (SWIG_arg_fail(1)) SWIG_fail;
3415 {
3416 arg2 = (int)(SWIG_As_int(obj1));
3417 if (SWIG_arg_fail(2)) SWIG_fail;
3418 }
3419 {
3420 PyThreadState* __tstate = wxPyBeginAllowThreads();
3421 (arg1)->SetWidth(arg2);
3422
3423 wxPyEndAllowThreads(__tstate);
3424 if (PyErr_Occurred()) SWIG_fail;
3425 }
3426 Py_INCREF(Py_None); resultobj = Py_None;
3427 return resultobj;
3428 fail:
3429 return NULL;
3430 }
3431
3432
3433 static PyObject *_wrap_Pen_SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3434 PyObject *resultobj;
3435 wxPen *arg1 = (wxPen *) 0 ;
3436 int arg2 ;
3437 wxDash *arg3 = (wxDash *) 0 ;
3438 PyObject * obj0 = 0 ;
3439 PyObject * obj1 = 0 ;
3440 char *kwnames[] = {
3441 (char *) "self",(char *) "dashes", NULL
3442 };
3443
3444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetDashes",kwnames,&obj0,&obj1)) goto fail;
3445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3446 if (SWIG_arg_fail(1)) SWIG_fail;
3447 {
3448 arg2 = PyList_Size(obj1);
3449 arg3 = (wxDash*)byte_LIST_helper(obj1);
3450 if (arg3 == NULL) SWIG_fail;
3451 }
3452 {
3453 PyThreadState* __tstate = wxPyBeginAllowThreads();
3454 (arg1)->SetDashes(arg2,arg3);
3455
3456 wxPyEndAllowThreads(__tstate);
3457 if (PyErr_Occurred()) SWIG_fail;
3458 }
3459 Py_INCREF(Py_None); resultobj = Py_None;
3460 {
3461 if (arg3) delete [] arg3;
3462 }
3463 return resultobj;
3464 fail:
3465 {
3466 if (arg3) delete [] arg3;
3467 }
3468 return NULL;
3469 }
3470
3471
3472 static PyObject *_wrap_Pen_GetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3473 PyObject *resultobj;
3474 wxPen *arg1 = (wxPen *) 0 ;
3475 PyObject *result;
3476 PyObject * obj0 = 0 ;
3477 char *kwnames[] = {
3478 (char *) "self", NULL
3479 };
3480
3481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetDashes",kwnames,&obj0)) goto fail;
3482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3483 if (SWIG_arg_fail(1)) SWIG_fail;
3484 {
3485 PyThreadState* __tstate = wxPyBeginAllowThreads();
3486 result = (PyObject *)wxPen_GetDashes(arg1);
3487
3488 wxPyEndAllowThreads(__tstate);
3489 if (PyErr_Occurred()) SWIG_fail;
3490 }
3491 resultobj = result;
3492 return resultobj;
3493 fail:
3494 return NULL;
3495 }
3496
3497
3498 static PyObject *_wrap_Pen__SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3499 PyObject *resultobj;
3500 wxPen *arg1 = (wxPen *) 0 ;
3501 PyObject *arg2 = (PyObject *) 0 ;
3502 PyObject *arg3 = (PyObject *) 0 ;
3503 PyObject * obj0 = 0 ;
3504 PyObject * obj1 = 0 ;
3505 PyObject * obj2 = 0 ;
3506 char *kwnames[] = {
3507 (char *) "self",(char *) "_self",(char *) "pyDashes", NULL
3508 };
3509
3510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Pen__SetDashes",kwnames,&obj0,&obj1,&obj2)) goto fail;
3511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3512 if (SWIG_arg_fail(1)) SWIG_fail;
3513 arg2 = obj1;
3514 arg3 = obj2;
3515 {
3516 PyThreadState* __tstate = wxPyBeginAllowThreads();
3517 wxPen__SetDashes(arg1,arg2,arg3);
3518
3519 wxPyEndAllowThreads(__tstate);
3520 if (PyErr_Occurred()) SWIG_fail;
3521 }
3522 Py_INCREF(Py_None); resultobj = Py_None;
3523 return resultobj;
3524 fail:
3525 return NULL;
3526 }
3527
3528
3529 static PyObject *_wrap_Pen_GetDashCount(PyObject *, PyObject *args, PyObject *kwargs) {
3530 PyObject *resultobj;
3531 wxPen *arg1 = (wxPen *) 0 ;
3532 int result;
3533 PyObject * obj0 = 0 ;
3534 char *kwnames[] = {
3535 (char *) "self", NULL
3536 };
3537
3538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetDashCount",kwnames,&obj0)) goto fail;
3539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3540 if (SWIG_arg_fail(1)) SWIG_fail;
3541 {
3542 PyThreadState* __tstate = wxPyBeginAllowThreads();
3543 result = (int)((wxPen const *)arg1)->GetDashCount();
3544
3545 wxPyEndAllowThreads(__tstate);
3546 if (PyErr_Occurred()) SWIG_fail;
3547 }
3548 {
3549 resultobj = SWIG_From_int((int)(result));
3550 }
3551 return resultobj;
3552 fail:
3553 return NULL;
3554 }
3555
3556
3557 static PyObject *_wrap_Pen_GetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3558 PyObject *resultobj;
3559 wxPen *arg1 = (wxPen *) 0 ;
3560 wxBitmap *result;
3561 PyObject * obj0 = 0 ;
3562 char *kwnames[] = {
3563 (char *) "self", NULL
3564 };
3565
3566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetStipple",kwnames,&obj0)) goto fail;
3567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3568 if (SWIG_arg_fail(1)) SWIG_fail;
3569 {
3570 PyThreadState* __tstate = wxPyBeginAllowThreads();
3571 result = (wxBitmap *)(arg1)->GetStipple();
3572
3573 wxPyEndAllowThreads(__tstate);
3574 if (PyErr_Occurred()) SWIG_fail;
3575 }
3576 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 0);
3577 return resultobj;
3578 fail:
3579 return NULL;
3580 }
3581
3582
3583 static PyObject *_wrap_Pen_SetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3584 PyObject *resultobj;
3585 wxPen *arg1 = (wxPen *) 0 ;
3586 wxBitmap *arg2 = 0 ;
3587 PyObject * obj0 = 0 ;
3588 PyObject * obj1 = 0 ;
3589 char *kwnames[] = {
3590 (char *) "self",(char *) "stipple", NULL
3591 };
3592
3593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetStipple",kwnames,&obj0,&obj1)) goto fail;
3594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3595 if (SWIG_arg_fail(1)) SWIG_fail;
3596 {
3597 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3598 if (SWIG_arg_fail(2)) SWIG_fail;
3599 if (arg2 == NULL) {
3600 SWIG_null_ref("wxBitmap");
3601 }
3602 if (SWIG_arg_fail(2)) SWIG_fail;
3603 }
3604 {
3605 PyThreadState* __tstate = wxPyBeginAllowThreads();
3606 (arg1)->SetStipple(*arg2);
3607
3608 wxPyEndAllowThreads(__tstate);
3609 if (PyErr_Occurred()) SWIG_fail;
3610 }
3611 Py_INCREF(Py_None); resultobj = Py_None;
3612 return resultobj;
3613 fail:
3614 return NULL;
3615 }
3616
3617
3618 static PyObject *_wrap_Pen___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3619 PyObject *resultobj;
3620 wxPen *arg1 = (wxPen *) 0 ;
3621 wxPen *arg2 = (wxPen *) 0 ;
3622 bool result;
3623 PyObject * obj0 = 0 ;
3624 PyObject * obj1 = 0 ;
3625 char *kwnames[] = {
3626 (char *) "self",(char *) "other", NULL
3627 };
3628
3629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___eq__",kwnames,&obj0,&obj1)) goto fail;
3630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3631 if (SWIG_arg_fail(1)) SWIG_fail;
3632 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3633 if (SWIG_arg_fail(2)) SWIG_fail;
3634 {
3635 PyThreadState* __tstate = wxPyBeginAllowThreads();
3636 result = (bool)wxPen___eq__(arg1,(wxPen const *)arg2);
3637
3638 wxPyEndAllowThreads(__tstate);
3639 if (PyErr_Occurred()) SWIG_fail;
3640 }
3641 {
3642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3643 }
3644 return resultobj;
3645 fail:
3646 return NULL;
3647 }
3648
3649
3650 static PyObject *_wrap_Pen___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3651 PyObject *resultobj;
3652 wxPen *arg1 = (wxPen *) 0 ;
3653 wxPen *arg2 = (wxPen *) 0 ;
3654 bool result;
3655 PyObject * obj0 = 0 ;
3656 PyObject * obj1 = 0 ;
3657 char *kwnames[] = {
3658 (char *) "self",(char *) "other", NULL
3659 };
3660
3661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___ne__",kwnames,&obj0,&obj1)) goto fail;
3662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3663 if (SWIG_arg_fail(1)) SWIG_fail;
3664 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3665 if (SWIG_arg_fail(2)) SWIG_fail;
3666 {
3667 PyThreadState* __tstate = wxPyBeginAllowThreads();
3668 result = (bool)wxPen___ne__(arg1,(wxPen const *)arg2);
3669
3670 wxPyEndAllowThreads(__tstate);
3671 if (PyErr_Occurred()) SWIG_fail;
3672 }
3673 {
3674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3675 }
3676 return resultobj;
3677 fail:
3678 return NULL;
3679 }
3680
3681
3682 static PyObject * Pen_swigregister(PyObject *, PyObject *args) {
3683 PyObject *obj;
3684 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3685 SWIG_TypeClientData(SWIGTYPE_p_wxPen, obj);
3686 Py_INCREF(obj);
3687 return Py_BuildValue((char *)"");
3688 }
3689 static PyObject *_wrap_new_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3690 PyObject *resultobj;
3691 wxColour *arg1 = 0 ;
3692 int arg2 = (int) wxSOLID ;
3693 wxBrush *result;
3694 wxColour temp1 ;
3695 PyObject * obj0 = 0 ;
3696 PyObject * obj1 = 0 ;
3697 char *kwnames[] = {
3698 (char *) "colour",(char *) "style", NULL
3699 };
3700
3701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Brush",kwnames,&obj0,&obj1)) goto fail;
3702 {
3703 arg1 = &temp1;
3704 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3705 }
3706 if (obj1) {
3707 {
3708 arg2 = (int)(SWIG_As_int(obj1));
3709 if (SWIG_arg_fail(2)) SWIG_fail;
3710 }
3711 }
3712 {
3713 if (!wxPyCheckForApp()) SWIG_fail;
3714 PyThreadState* __tstate = wxPyBeginAllowThreads();
3715 result = (wxBrush *)new wxBrush((wxColour const &)*arg1,arg2);
3716
3717 wxPyEndAllowThreads(__tstate);
3718 if (PyErr_Occurred()) SWIG_fail;
3719 }
3720 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 1);
3721 return resultobj;
3722 fail:
3723 return NULL;
3724 }
3725
3726
3727 static PyObject *_wrap_new_BrushFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
3728 PyObject *resultobj;
3729 wxBitmap *arg1 = 0 ;
3730 wxBrush *result;
3731 PyObject * obj0 = 0 ;
3732 char *kwnames[] = {
3733 (char *) "stippleBitmap", NULL
3734 };
3735
3736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BrushFromBitmap",kwnames,&obj0)) goto fail;
3737 {
3738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3739 if (SWIG_arg_fail(1)) SWIG_fail;
3740 if (arg1 == NULL) {
3741 SWIG_null_ref("wxBitmap");
3742 }
3743 if (SWIG_arg_fail(1)) SWIG_fail;
3744 }
3745 {
3746 if (!wxPyCheckForApp()) SWIG_fail;
3747 PyThreadState* __tstate = wxPyBeginAllowThreads();
3748 result = (wxBrush *)new wxBrush((wxBitmap const &)*arg1);
3749
3750 wxPyEndAllowThreads(__tstate);
3751 if (PyErr_Occurred()) SWIG_fail;
3752 }
3753 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 1);
3754 return resultobj;
3755 fail:
3756 return NULL;
3757 }
3758
3759
3760 static PyObject *_wrap_delete_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3761 PyObject *resultobj;
3762 wxBrush *arg1 = (wxBrush *) 0 ;
3763 PyObject * obj0 = 0 ;
3764 char *kwnames[] = {
3765 (char *) "self", NULL
3766 };
3767
3768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Brush",kwnames,&obj0)) goto fail;
3769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3770 if (SWIG_arg_fail(1)) SWIG_fail;
3771 {
3772 PyThreadState* __tstate = wxPyBeginAllowThreads();
3773 delete arg1;
3774
3775 wxPyEndAllowThreads(__tstate);
3776 if (PyErr_Occurred()) SWIG_fail;
3777 }
3778 Py_INCREF(Py_None); resultobj = Py_None;
3779 return resultobj;
3780 fail:
3781 return NULL;
3782 }
3783
3784
3785 static PyObject *_wrap_Brush_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3786 PyObject *resultobj;
3787 wxBrush *arg1 = (wxBrush *) 0 ;
3788 wxColour *arg2 = 0 ;
3789 wxColour temp2 ;
3790 PyObject * obj0 = 0 ;
3791 PyObject * obj1 = 0 ;
3792 char *kwnames[] = {
3793 (char *) "self",(char *) "col", NULL
3794 };
3795
3796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetColour",kwnames,&obj0,&obj1)) goto fail;
3797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3798 if (SWIG_arg_fail(1)) SWIG_fail;
3799 {
3800 arg2 = &temp2;
3801 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3802 }
3803 {
3804 PyThreadState* __tstate = wxPyBeginAllowThreads();
3805 (arg1)->SetColour((wxColour const &)*arg2);
3806
3807 wxPyEndAllowThreads(__tstate);
3808 if (PyErr_Occurred()) SWIG_fail;
3809 }
3810 Py_INCREF(Py_None); resultobj = Py_None;
3811 return resultobj;
3812 fail:
3813 return NULL;
3814 }
3815
3816
3817 static PyObject *_wrap_Brush_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3818 PyObject *resultobj;
3819 wxBrush *arg1 = (wxBrush *) 0 ;
3820 int arg2 ;
3821 PyObject * obj0 = 0 ;
3822 PyObject * obj1 = 0 ;
3823 char *kwnames[] = {
3824 (char *) "self",(char *) "style", NULL
3825 };
3826
3827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStyle",kwnames,&obj0,&obj1)) 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 arg2 = (int)(SWIG_As_int(obj1));
3832 if (SWIG_arg_fail(2)) SWIG_fail;
3833 }
3834 {
3835 PyThreadState* __tstate = wxPyBeginAllowThreads();
3836 (arg1)->SetStyle(arg2);
3837
3838 wxPyEndAllowThreads(__tstate);
3839 if (PyErr_Occurred()) SWIG_fail;
3840 }
3841 Py_INCREF(Py_None); resultobj = Py_None;
3842 return resultobj;
3843 fail:
3844 return NULL;
3845 }
3846
3847
3848 static PyObject *_wrap_Brush_SetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3849 PyObject *resultobj;
3850 wxBrush *arg1 = (wxBrush *) 0 ;
3851 wxBitmap *arg2 = 0 ;
3852 PyObject * obj0 = 0 ;
3853 PyObject * obj1 = 0 ;
3854 char *kwnames[] = {
3855 (char *) "self",(char *) "stipple", NULL
3856 };
3857
3858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStipple",kwnames,&obj0,&obj1)) goto fail;
3859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3860 if (SWIG_arg_fail(1)) SWIG_fail;
3861 {
3862 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3863 if (SWIG_arg_fail(2)) SWIG_fail;
3864 if (arg2 == NULL) {
3865 SWIG_null_ref("wxBitmap");
3866 }
3867 if (SWIG_arg_fail(2)) SWIG_fail;
3868 }
3869 {
3870 PyThreadState* __tstate = wxPyBeginAllowThreads();
3871 (arg1)->SetStipple((wxBitmap const &)*arg2);
3872
3873 wxPyEndAllowThreads(__tstate);
3874 if (PyErr_Occurred()) SWIG_fail;
3875 }
3876 Py_INCREF(Py_None); resultobj = Py_None;
3877 return resultobj;
3878 fail:
3879 return NULL;
3880 }
3881
3882
3883 static PyObject *_wrap_Brush_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3884 PyObject *resultobj;
3885 wxBrush *arg1 = (wxBrush *) 0 ;
3886 wxColour result;
3887 PyObject * obj0 = 0 ;
3888 char *kwnames[] = {
3889 (char *) "self", NULL
3890 };
3891
3892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetColour",kwnames,&obj0)) goto fail;
3893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3894 if (SWIG_arg_fail(1)) SWIG_fail;
3895 {
3896 PyThreadState* __tstate = wxPyBeginAllowThreads();
3897 result = ((wxBrush const *)arg1)->GetColour();
3898
3899 wxPyEndAllowThreads(__tstate);
3900 if (PyErr_Occurred()) SWIG_fail;
3901 }
3902 {
3903 wxColour * resultptr;
3904 resultptr = new wxColour((wxColour &)(result));
3905 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3906 }
3907 return resultobj;
3908 fail:
3909 return NULL;
3910 }
3911
3912
3913 static PyObject *_wrap_Brush_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3914 PyObject *resultobj;
3915 wxBrush *arg1 = (wxBrush *) 0 ;
3916 int result;
3917 PyObject * obj0 = 0 ;
3918 char *kwnames[] = {
3919 (char *) "self", NULL
3920 };
3921
3922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStyle",kwnames,&obj0)) goto fail;
3923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3924 if (SWIG_arg_fail(1)) SWIG_fail;
3925 {
3926 PyThreadState* __tstate = wxPyBeginAllowThreads();
3927 result = (int)((wxBrush const *)arg1)->GetStyle();
3928
3929 wxPyEndAllowThreads(__tstate);
3930 if (PyErr_Occurred()) SWIG_fail;
3931 }
3932 {
3933 resultobj = SWIG_From_int((int)(result));
3934 }
3935 return resultobj;
3936 fail:
3937 return NULL;
3938 }
3939
3940
3941 static PyObject *_wrap_Brush_GetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3942 PyObject *resultobj;
3943 wxBrush *arg1 = (wxBrush *) 0 ;
3944 wxBitmap *result;
3945 PyObject * obj0 = 0 ;
3946 char *kwnames[] = {
3947 (char *) "self", NULL
3948 };
3949
3950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStipple",kwnames,&obj0)) goto fail;
3951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3952 if (SWIG_arg_fail(1)) SWIG_fail;
3953 {
3954 PyThreadState* __tstate = wxPyBeginAllowThreads();
3955 result = (wxBitmap *)((wxBrush const *)arg1)->GetStipple();
3956
3957 wxPyEndAllowThreads(__tstate);
3958 if (PyErr_Occurred()) SWIG_fail;
3959 }
3960 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 0);
3961 return resultobj;
3962 fail:
3963 return NULL;
3964 }
3965
3966
3967 static PyObject *_wrap_Brush_IsHatch(PyObject *, PyObject *args, PyObject *kwargs) {
3968 PyObject *resultobj;
3969 wxBrush *arg1 = (wxBrush *) 0 ;
3970 bool result;
3971 PyObject * obj0 = 0 ;
3972 char *kwnames[] = {
3973 (char *) "self", NULL
3974 };
3975
3976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_IsHatch",kwnames,&obj0)) goto fail;
3977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3978 if (SWIG_arg_fail(1)) SWIG_fail;
3979 {
3980 PyThreadState* __tstate = wxPyBeginAllowThreads();
3981 result = (bool)((wxBrush const *)arg1)->IsHatch();
3982
3983 wxPyEndAllowThreads(__tstate);
3984 if (PyErr_Occurred()) SWIG_fail;
3985 }
3986 {
3987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3988 }
3989 return resultobj;
3990 fail:
3991 return NULL;
3992 }
3993
3994
3995 static PyObject *_wrap_Brush_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3996 PyObject *resultobj;
3997 wxBrush *arg1 = (wxBrush *) 0 ;
3998 bool result;
3999 PyObject * obj0 = 0 ;
4000 char *kwnames[] = {
4001 (char *) "self", NULL
4002 };
4003
4004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_Ok",kwnames,&obj0)) goto fail;
4005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
4006 if (SWIG_arg_fail(1)) SWIG_fail;
4007 {
4008 PyThreadState* __tstate = wxPyBeginAllowThreads();
4009 result = (bool)(arg1)->Ok();
4010
4011 wxPyEndAllowThreads(__tstate);
4012 if (PyErr_Occurred()) SWIG_fail;
4013 }
4014 {
4015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4016 }
4017 return resultobj;
4018 fail:
4019 return NULL;
4020 }
4021
4022
4023 static PyObject * Brush_swigregister(PyObject *, PyObject *args) {
4024 PyObject *obj;
4025 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4026 SWIG_TypeClientData(SWIGTYPE_p_wxBrush, obj);
4027 Py_INCREF(obj);
4028 return Py_BuildValue((char *)"");
4029 }
4030 static PyObject *_wrap_new_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4031 PyObject *resultobj;
4032 wxString *arg1 = 0 ;
4033 wxBitmapType arg2 = (wxBitmapType) wxBITMAP_TYPE_ANY ;
4034 wxBitmap *result;
4035 bool temp1 = false ;
4036 PyObject * obj0 = 0 ;
4037 PyObject * obj1 = 0 ;
4038 char *kwnames[] = {
4039 (char *) "name",(char *) "type", NULL
4040 };
4041
4042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Bitmap",kwnames,&obj0,&obj1)) goto fail;
4043 {
4044 arg1 = wxString_in_helper(obj0);
4045 if (arg1 == NULL) SWIG_fail;
4046 temp1 = true;
4047 }
4048 if (obj1) {
4049 {
4050 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
4051 if (SWIG_arg_fail(2)) SWIG_fail;
4052 }
4053 }
4054 {
4055 if (!wxPyCheckForApp()) SWIG_fail;
4056 PyThreadState* __tstate = wxPyBeginAllowThreads();
4057 result = (wxBitmap *)new wxBitmap((wxString const &)*arg1,(wxBitmapType )arg2);
4058
4059 wxPyEndAllowThreads(__tstate);
4060 if (PyErr_Occurred()) SWIG_fail;
4061 }
4062 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4063 {
4064 if (temp1)
4065 delete arg1;
4066 }
4067 return resultobj;
4068 fail:
4069 {
4070 if (temp1)
4071 delete arg1;
4072 }
4073 return NULL;
4074 }
4075
4076
4077 static PyObject *_wrap_delete_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4078 PyObject *resultobj;
4079 wxBitmap *arg1 = (wxBitmap *) 0 ;
4080 PyObject * obj0 = 0 ;
4081 char *kwnames[] = {
4082 (char *) "self", NULL
4083 };
4084
4085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Bitmap",kwnames,&obj0)) goto fail;
4086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4087 if (SWIG_arg_fail(1)) SWIG_fail;
4088 {
4089 PyThreadState* __tstate = wxPyBeginAllowThreads();
4090 delete arg1;
4091
4092 wxPyEndAllowThreads(__tstate);
4093 if (PyErr_Occurred()) SWIG_fail;
4094 }
4095 Py_INCREF(Py_None); resultobj = Py_None;
4096 return resultobj;
4097 fail:
4098 return NULL;
4099 }
4100
4101
4102 static PyObject *_wrap_new_EmptyBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4103 PyObject *resultobj;
4104 int arg1 ;
4105 int arg2 ;
4106 int arg3 = (int) -1 ;
4107 wxBitmap *result;
4108 PyObject * obj0 = 0 ;
4109 PyObject * obj1 = 0 ;
4110 PyObject * obj2 = 0 ;
4111 char *kwnames[] = {
4112 (char *) "width",(char *) "height",(char *) "depth", NULL
4113 };
4114
4115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_EmptyBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
4116 {
4117 arg1 = (int)(SWIG_As_int(obj0));
4118 if (SWIG_arg_fail(1)) SWIG_fail;
4119 }
4120 {
4121 arg2 = (int)(SWIG_As_int(obj1));
4122 if (SWIG_arg_fail(2)) SWIG_fail;
4123 }
4124 if (obj2) {
4125 {
4126 arg3 = (int)(SWIG_As_int(obj2));
4127 if (SWIG_arg_fail(3)) SWIG_fail;
4128 }
4129 }
4130 {
4131 if (!wxPyCheckForApp()) SWIG_fail;
4132 PyThreadState* __tstate = wxPyBeginAllowThreads();
4133 result = (wxBitmap *)new wxBitmap(arg1,arg2,arg3);
4134
4135 wxPyEndAllowThreads(__tstate);
4136 if (PyErr_Occurred()) SWIG_fail;
4137 }
4138 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4139 return resultobj;
4140 fail:
4141 return NULL;
4142 }
4143
4144
4145 static PyObject *_wrap_new_BitmapFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4146 PyObject *resultobj;
4147 wxIcon *arg1 = 0 ;
4148 wxBitmap *result;
4149 PyObject * obj0 = 0 ;
4150 char *kwnames[] = {
4151 (char *) "icon", NULL
4152 };
4153
4154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromIcon",kwnames,&obj0)) goto fail;
4155 {
4156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4157 if (SWIG_arg_fail(1)) SWIG_fail;
4158 if (arg1 == NULL) {
4159 SWIG_null_ref("wxIcon");
4160 }
4161 if (SWIG_arg_fail(1)) SWIG_fail;
4162 }
4163 {
4164 if (!wxPyCheckForApp()) SWIG_fail;
4165 PyThreadState* __tstate = wxPyBeginAllowThreads();
4166 result = (wxBitmap *)new wxBitmap((wxIcon const &)*arg1);
4167
4168 wxPyEndAllowThreads(__tstate);
4169 if (PyErr_Occurred()) SWIG_fail;
4170 }
4171 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4172 return resultobj;
4173 fail:
4174 return NULL;
4175 }
4176
4177
4178 static PyObject *_wrap_new_BitmapFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
4179 PyObject *resultobj;
4180 wxImage *arg1 = 0 ;
4181 int arg2 = (int) -1 ;
4182 wxBitmap *result;
4183 PyObject * obj0 = 0 ;
4184 PyObject * obj1 = 0 ;
4185 char *kwnames[] = {
4186 (char *) "image",(char *) "depth", NULL
4187 };
4188
4189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BitmapFromImage",kwnames,&obj0,&obj1)) goto fail;
4190 {
4191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
4192 if (SWIG_arg_fail(1)) SWIG_fail;
4193 if (arg1 == NULL) {
4194 SWIG_null_ref("wxImage");
4195 }
4196 if (SWIG_arg_fail(1)) SWIG_fail;
4197 }
4198 if (obj1) {
4199 {
4200 arg2 = (int)(SWIG_As_int(obj1));
4201 if (SWIG_arg_fail(2)) SWIG_fail;
4202 }
4203 }
4204 {
4205 if (!wxPyCheckForApp()) SWIG_fail;
4206 PyThreadState* __tstate = wxPyBeginAllowThreads();
4207 result = (wxBitmap *)new wxBitmap((wxImage const &)*arg1,arg2);
4208
4209 wxPyEndAllowThreads(__tstate);
4210 if (PyErr_Occurred()) SWIG_fail;
4211 }
4212 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4213 return resultobj;
4214 fail:
4215 return NULL;
4216 }
4217
4218
4219 static PyObject *_wrap_new_BitmapFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
4220 PyObject *resultobj;
4221 PyObject *arg1 = (PyObject *) 0 ;
4222 wxBitmap *result;
4223 PyObject * obj0 = 0 ;
4224 char *kwnames[] = {
4225 (char *) "listOfStrings", NULL
4226 };
4227
4228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromXPMData",kwnames,&obj0)) goto fail;
4229 arg1 = obj0;
4230 {
4231 if (!wxPyCheckForApp()) SWIG_fail;
4232 PyThreadState* __tstate = wxPyBeginAllowThreads();
4233 result = (wxBitmap *)new_wxBitmap(arg1);
4234
4235 wxPyEndAllowThreads(__tstate);
4236 if (PyErr_Occurred()) SWIG_fail;
4237 }
4238 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4239 return resultobj;
4240 fail:
4241 return NULL;
4242 }
4243
4244
4245 static PyObject *_wrap_new_BitmapFromBits(PyObject *, PyObject *args, PyObject *kwargs) {
4246 PyObject *resultobj;
4247 PyObject *arg1 = (PyObject *) 0 ;
4248 int arg2 ;
4249 int arg3 ;
4250 int arg4 = (int) 1 ;
4251 wxBitmap *result;
4252 PyObject * obj0 = 0 ;
4253 PyObject * obj1 = 0 ;
4254 PyObject * obj2 = 0 ;
4255 PyObject * obj3 = 0 ;
4256 char *kwnames[] = {
4257 (char *) "bits",(char *) "width",(char *) "height",(char *) "depth", NULL
4258 };
4259
4260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:new_BitmapFromBits",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4261 arg1 = obj0;
4262 {
4263 arg2 = (int)(SWIG_As_int(obj1));
4264 if (SWIG_arg_fail(2)) SWIG_fail;
4265 }
4266 {
4267 arg3 = (int)(SWIG_As_int(obj2));
4268 if (SWIG_arg_fail(3)) SWIG_fail;
4269 }
4270 if (obj3) {
4271 {
4272 arg4 = (int)(SWIG_As_int(obj3));
4273 if (SWIG_arg_fail(4)) SWIG_fail;
4274 }
4275 }
4276 {
4277 if (!wxPyCheckForApp()) SWIG_fail;
4278 PyThreadState* __tstate = wxPyBeginAllowThreads();
4279 result = (wxBitmap *)new_wxBitmap(arg1,arg2,arg3,arg4);
4280
4281 wxPyEndAllowThreads(__tstate);
4282 if (PyErr_Occurred()) SWIG_fail;
4283 }
4284 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4285 return resultobj;
4286 fail:
4287 return NULL;
4288 }
4289
4290
4291 static PyObject *_wrap_Bitmap_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
4292 PyObject *resultobj;
4293 wxBitmap *arg1 = (wxBitmap *) 0 ;
4294 long result;
4295 PyObject * obj0 = 0 ;
4296 char *kwnames[] = {
4297 (char *) "self", NULL
4298 };
4299
4300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetHandle",kwnames,&obj0)) goto fail;
4301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4302 if (SWIG_arg_fail(1)) SWIG_fail;
4303 {
4304 PyThreadState* __tstate = wxPyBeginAllowThreads();
4305 result = (long)(arg1)->GetHandle();
4306
4307 wxPyEndAllowThreads(__tstate);
4308 if (PyErr_Occurred()) SWIG_fail;
4309 }
4310 {
4311 resultobj = SWIG_From_long((long)(result));
4312 }
4313 return resultobj;
4314 fail:
4315 return NULL;
4316 }
4317
4318
4319 static PyObject *_wrap_Bitmap_SetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
4320 PyObject *resultobj;
4321 wxBitmap *arg1 = (wxBitmap *) 0 ;
4322 long arg2 ;
4323 PyObject * obj0 = 0 ;
4324 PyObject * obj1 = 0 ;
4325 char *kwnames[] = {
4326 (char *) "self",(char *) "handle", NULL
4327 };
4328
4329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetHandle",kwnames,&obj0,&obj1)) goto fail;
4330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4331 if (SWIG_arg_fail(1)) SWIG_fail;
4332 {
4333 arg2 = (long)(SWIG_As_long(obj1));
4334 if (SWIG_arg_fail(2)) SWIG_fail;
4335 }
4336 {
4337 PyThreadState* __tstate = wxPyBeginAllowThreads();
4338 wxBitmap_SetHandle(arg1,arg2);
4339
4340 wxPyEndAllowThreads(__tstate);
4341 if (PyErr_Occurred()) SWIG_fail;
4342 }
4343 Py_INCREF(Py_None); resultobj = Py_None;
4344 return resultobj;
4345 fail:
4346 return NULL;
4347 }
4348
4349
4350 static PyObject *_wrap_Bitmap_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
4351 PyObject *resultobj;
4352 wxBitmap *arg1 = (wxBitmap *) 0 ;
4353 bool result;
4354 PyObject * obj0 = 0 ;
4355 char *kwnames[] = {
4356 (char *) "self", NULL
4357 };
4358
4359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_Ok",kwnames,&obj0)) goto fail;
4360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4361 if (SWIG_arg_fail(1)) SWIG_fail;
4362 {
4363 PyThreadState* __tstate = wxPyBeginAllowThreads();
4364 result = (bool)(arg1)->Ok();
4365
4366 wxPyEndAllowThreads(__tstate);
4367 if (PyErr_Occurred()) SWIG_fail;
4368 }
4369 {
4370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4371 }
4372 return resultobj;
4373 fail:
4374 return NULL;
4375 }
4376
4377
4378 static PyObject *_wrap_Bitmap_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4379 PyObject *resultobj;
4380 wxBitmap *arg1 = (wxBitmap *) 0 ;
4381 int result;
4382 PyObject * obj0 = 0 ;
4383 char *kwnames[] = {
4384 (char *) "self", NULL
4385 };
4386
4387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetWidth",kwnames,&obj0)) goto fail;
4388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4389 if (SWIG_arg_fail(1)) SWIG_fail;
4390 {
4391 PyThreadState* __tstate = wxPyBeginAllowThreads();
4392 result = (int)(arg1)->GetWidth();
4393
4394 wxPyEndAllowThreads(__tstate);
4395 if (PyErr_Occurred()) SWIG_fail;
4396 }
4397 {
4398 resultobj = SWIG_From_int((int)(result));
4399 }
4400 return resultobj;
4401 fail:
4402 return NULL;
4403 }
4404
4405
4406 static PyObject *_wrap_Bitmap_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4407 PyObject *resultobj;
4408 wxBitmap *arg1 = (wxBitmap *) 0 ;
4409 int result;
4410 PyObject * obj0 = 0 ;
4411 char *kwnames[] = {
4412 (char *) "self", NULL
4413 };
4414
4415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetHeight",kwnames,&obj0)) goto fail;
4416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4417 if (SWIG_arg_fail(1)) SWIG_fail;
4418 {
4419 PyThreadState* __tstate = wxPyBeginAllowThreads();
4420 result = (int)(arg1)->GetHeight();
4421
4422 wxPyEndAllowThreads(__tstate);
4423 if (PyErr_Occurred()) SWIG_fail;
4424 }
4425 {
4426 resultobj = SWIG_From_int((int)(result));
4427 }
4428 return resultobj;
4429 fail:
4430 return NULL;
4431 }
4432
4433
4434 static PyObject *_wrap_Bitmap_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4435 PyObject *resultobj;
4436 wxBitmap *arg1 = (wxBitmap *) 0 ;
4437 int result;
4438 PyObject * obj0 = 0 ;
4439 char *kwnames[] = {
4440 (char *) "self", NULL
4441 };
4442
4443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetDepth",kwnames,&obj0)) goto fail;
4444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4445 if (SWIG_arg_fail(1)) SWIG_fail;
4446 {
4447 PyThreadState* __tstate = wxPyBeginAllowThreads();
4448 result = (int)(arg1)->GetDepth();
4449
4450 wxPyEndAllowThreads(__tstate);
4451 if (PyErr_Occurred()) SWIG_fail;
4452 }
4453 {
4454 resultobj = SWIG_From_int((int)(result));
4455 }
4456 return resultobj;
4457 fail:
4458 return NULL;
4459 }
4460
4461
4462 static PyObject *_wrap_Bitmap_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4463 PyObject *resultobj;
4464 wxBitmap *arg1 = (wxBitmap *) 0 ;
4465 wxSize result;
4466 PyObject * obj0 = 0 ;
4467 char *kwnames[] = {
4468 (char *) "self", NULL
4469 };
4470
4471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetSize",kwnames,&obj0)) goto fail;
4472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4473 if (SWIG_arg_fail(1)) SWIG_fail;
4474 {
4475 PyThreadState* __tstate = wxPyBeginAllowThreads();
4476 result = wxBitmap_GetSize(arg1);
4477
4478 wxPyEndAllowThreads(__tstate);
4479 if (PyErr_Occurred()) SWIG_fail;
4480 }
4481 {
4482 wxSize * resultptr;
4483 resultptr = new wxSize((wxSize &)(result));
4484 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
4485 }
4486 return resultobj;
4487 fail:
4488 return NULL;
4489 }
4490
4491
4492 static PyObject *_wrap_Bitmap_ConvertToImage(PyObject *, PyObject *args, PyObject *kwargs) {
4493 PyObject *resultobj;
4494 wxBitmap *arg1 = (wxBitmap *) 0 ;
4495 SwigValueWrapper<wxImage > result;
4496 PyObject * obj0 = 0 ;
4497 char *kwnames[] = {
4498 (char *) "self", NULL
4499 };
4500
4501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_ConvertToImage",kwnames,&obj0)) goto fail;
4502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4503 if (SWIG_arg_fail(1)) SWIG_fail;
4504 {
4505 PyThreadState* __tstate = wxPyBeginAllowThreads();
4506 result = ((wxBitmap const *)arg1)->ConvertToImage();
4507
4508 wxPyEndAllowThreads(__tstate);
4509 if (PyErr_Occurred()) SWIG_fail;
4510 }
4511 {
4512 wxImage * resultptr;
4513 resultptr = new wxImage((wxImage &)(result));
4514 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
4515 }
4516 return resultobj;
4517 fail:
4518 return NULL;
4519 }
4520
4521
4522 static PyObject *_wrap_Bitmap_GetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4523 PyObject *resultobj;
4524 wxBitmap *arg1 = (wxBitmap *) 0 ;
4525 wxMask *result;
4526 PyObject * obj0 = 0 ;
4527 char *kwnames[] = {
4528 (char *) "self", NULL
4529 };
4530
4531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetMask",kwnames,&obj0)) goto fail;
4532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4533 if (SWIG_arg_fail(1)) SWIG_fail;
4534 {
4535 PyThreadState* __tstate = wxPyBeginAllowThreads();
4536 result = (wxMask *)((wxBitmap const *)arg1)->GetMask();
4537
4538 wxPyEndAllowThreads(__tstate);
4539 if (PyErr_Occurred()) SWIG_fail;
4540 }
4541 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 0);
4542 return resultobj;
4543 fail:
4544 return NULL;
4545 }
4546
4547
4548 static PyObject *_wrap_Bitmap_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4549 PyObject *resultobj;
4550 wxBitmap *arg1 = (wxBitmap *) 0 ;
4551 wxMask *arg2 = (wxMask *) 0 ;
4552 PyObject * obj0 = 0 ;
4553 PyObject * obj1 = 0 ;
4554 char *kwnames[] = {
4555 (char *) "self",(char *) "mask", NULL
4556 };
4557
4558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMask",kwnames,&obj0,&obj1)) goto fail;
4559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4560 if (SWIG_arg_fail(1)) SWIG_fail;
4561 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMask, SWIG_POINTER_EXCEPTION | 0);
4562 if (SWIG_arg_fail(2)) SWIG_fail;
4563 {
4564 PyThreadState* __tstate = wxPyBeginAllowThreads();
4565 (arg1)->SetMask(arg2);
4566
4567 wxPyEndAllowThreads(__tstate);
4568 if (PyErr_Occurred()) SWIG_fail;
4569 }
4570 Py_INCREF(Py_None); resultobj = Py_None;
4571 return resultobj;
4572 fail:
4573 return NULL;
4574 }
4575
4576
4577 static PyObject *_wrap_Bitmap_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
4578 PyObject *resultobj;
4579 wxBitmap *arg1 = (wxBitmap *) 0 ;
4580 wxColour *arg2 = 0 ;
4581 wxColour temp2 ;
4582 PyObject * obj0 = 0 ;
4583 PyObject * obj1 = 0 ;
4584 char *kwnames[] = {
4585 (char *) "self",(char *) "colour", NULL
4586 };
4587
4588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMaskColour",kwnames,&obj0,&obj1)) goto fail;
4589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4590 if (SWIG_arg_fail(1)) SWIG_fail;
4591 {
4592 arg2 = &temp2;
4593 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4594 }
4595 {
4596 PyThreadState* __tstate = wxPyBeginAllowThreads();
4597 wxBitmap_SetMaskColour(arg1,(wxColour const &)*arg2);
4598
4599 wxPyEndAllowThreads(__tstate);
4600 if (PyErr_Occurred()) SWIG_fail;
4601 }
4602 Py_INCREF(Py_None); resultobj = Py_None;
4603 return resultobj;
4604 fail:
4605 return NULL;
4606 }
4607
4608
4609 static PyObject *_wrap_Bitmap_GetSubBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4610 PyObject *resultobj;
4611 wxBitmap *arg1 = (wxBitmap *) 0 ;
4612 wxRect *arg2 = 0 ;
4613 SwigValueWrapper<wxBitmap > result;
4614 wxRect temp2 ;
4615 PyObject * obj0 = 0 ;
4616 PyObject * obj1 = 0 ;
4617 char *kwnames[] = {
4618 (char *) "self",(char *) "rect", NULL
4619 };
4620
4621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_GetSubBitmap",kwnames,&obj0,&obj1)) goto fail;
4622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4623 if (SWIG_arg_fail(1)) SWIG_fail;
4624 {
4625 arg2 = &temp2;
4626 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4627 }
4628 {
4629 PyThreadState* __tstate = wxPyBeginAllowThreads();
4630 result = ((wxBitmap const *)arg1)->GetSubBitmap((wxRect const &)*arg2);
4631
4632 wxPyEndAllowThreads(__tstate);
4633 if (PyErr_Occurred()) SWIG_fail;
4634 }
4635 {
4636 wxBitmap * resultptr;
4637 resultptr = new wxBitmap((wxBitmap &)(result));
4638 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
4639 }
4640 return resultobj;
4641 fail:
4642 return NULL;
4643 }
4644
4645
4646 static PyObject *_wrap_Bitmap_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
4647 PyObject *resultobj;
4648 wxBitmap *arg1 = (wxBitmap *) 0 ;
4649 wxString *arg2 = 0 ;
4650 wxBitmapType arg3 ;
4651 wxPalette *arg4 = (wxPalette *) NULL ;
4652 bool result;
4653 bool temp2 = false ;
4654 PyObject * obj0 = 0 ;
4655 PyObject * obj1 = 0 ;
4656 PyObject * obj2 = 0 ;
4657 PyObject * obj3 = 0 ;
4658 char *kwnames[] = {
4659 (char *) "self",(char *) "name",(char *) "type",(char *) "palette", NULL
4660 };
4661
4662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Bitmap_SaveFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4664 if (SWIG_arg_fail(1)) SWIG_fail;
4665 {
4666 arg2 = wxString_in_helper(obj1);
4667 if (arg2 == NULL) SWIG_fail;
4668 temp2 = true;
4669 }
4670 {
4671 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4672 if (SWIG_arg_fail(3)) SWIG_fail;
4673 }
4674 if (obj3) {
4675 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
4676 if (SWIG_arg_fail(4)) SWIG_fail;
4677 }
4678 {
4679 PyThreadState* __tstate = wxPyBeginAllowThreads();
4680 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxBitmapType )arg3,arg4);
4681
4682 wxPyEndAllowThreads(__tstate);
4683 if (PyErr_Occurred()) SWIG_fail;
4684 }
4685 {
4686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4687 }
4688 {
4689 if (temp2)
4690 delete arg2;
4691 }
4692 return resultobj;
4693 fail:
4694 {
4695 if (temp2)
4696 delete arg2;
4697 }
4698 return NULL;
4699 }
4700
4701
4702 static PyObject *_wrap_Bitmap_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
4703 PyObject *resultobj;
4704 wxBitmap *arg1 = (wxBitmap *) 0 ;
4705 wxString *arg2 = 0 ;
4706 wxBitmapType arg3 ;
4707 bool result;
4708 bool temp2 = false ;
4709 PyObject * obj0 = 0 ;
4710 PyObject * obj1 = 0 ;
4711 PyObject * obj2 = 0 ;
4712 char *kwnames[] = {
4713 (char *) "self",(char *) "name",(char *) "type", NULL
4714 };
4715
4716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Bitmap_LoadFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
4717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4718 if (SWIG_arg_fail(1)) SWIG_fail;
4719 {
4720 arg2 = wxString_in_helper(obj1);
4721 if (arg2 == NULL) SWIG_fail;
4722 temp2 = true;
4723 }
4724 {
4725 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4726 if (SWIG_arg_fail(3)) SWIG_fail;
4727 }
4728 {
4729 PyThreadState* __tstate = wxPyBeginAllowThreads();
4730 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxBitmapType )arg3);
4731
4732 wxPyEndAllowThreads(__tstate);
4733 if (PyErr_Occurred()) SWIG_fail;
4734 }
4735 {
4736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4737 }
4738 {
4739 if (temp2)
4740 delete arg2;
4741 }
4742 return resultobj;
4743 fail:
4744 {
4745 if (temp2)
4746 delete arg2;
4747 }
4748 return NULL;
4749 }
4750
4751
4752 static PyObject *_wrap_Bitmap_GetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
4753 PyObject *resultobj;
4754 wxBitmap *arg1 = (wxBitmap *) 0 ;
4755 wxPalette *result;
4756 PyObject * obj0 = 0 ;
4757 char *kwnames[] = {
4758 (char *) "self", NULL
4759 };
4760
4761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetPalette",kwnames,&obj0)) goto fail;
4762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4763 if (SWIG_arg_fail(1)) SWIG_fail;
4764 {
4765 PyThreadState* __tstate = wxPyBeginAllowThreads();
4766 result = (wxPalette *)((wxBitmap const *)arg1)->GetPalette();
4767
4768 wxPyEndAllowThreads(__tstate);
4769 if (PyErr_Occurred()) SWIG_fail;
4770 }
4771 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 0);
4772 return resultobj;
4773 fail:
4774 return NULL;
4775 }
4776
4777
4778 static PyObject *_wrap_Bitmap_SetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
4779 PyObject *resultobj;
4780 wxBitmap *arg1 = (wxBitmap *) 0 ;
4781 wxPalette *arg2 = 0 ;
4782 PyObject * obj0 = 0 ;
4783 PyObject * obj1 = 0 ;
4784 char *kwnames[] = {
4785 (char *) "self",(char *) "palette", NULL
4786 };
4787
4788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetPalette",kwnames,&obj0,&obj1)) goto fail;
4789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4790 if (SWIG_arg_fail(1)) SWIG_fail;
4791 {
4792 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
4793 if (SWIG_arg_fail(2)) SWIG_fail;
4794 if (arg2 == NULL) {
4795 SWIG_null_ref("wxPalette");
4796 }
4797 if (SWIG_arg_fail(2)) SWIG_fail;
4798 }
4799 {
4800 PyThreadState* __tstate = wxPyBeginAllowThreads();
4801 (arg1)->SetPalette((wxPalette const &)*arg2);
4802
4803 wxPyEndAllowThreads(__tstate);
4804 if (PyErr_Occurred()) SWIG_fail;
4805 }
4806 Py_INCREF(Py_None); resultobj = Py_None;
4807 return resultobj;
4808 fail:
4809 return NULL;
4810 }
4811
4812
4813 static PyObject *_wrap_Bitmap_CopyFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4814 PyObject *resultobj;
4815 wxBitmap *arg1 = (wxBitmap *) 0 ;
4816 wxIcon *arg2 = 0 ;
4817 bool result;
4818 PyObject * obj0 = 0 ;
4819 PyObject * obj1 = 0 ;
4820 char *kwnames[] = {
4821 (char *) "self",(char *) "icon", NULL
4822 };
4823
4824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_CopyFromIcon",kwnames,&obj0,&obj1)) goto fail;
4825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4826 if (SWIG_arg_fail(1)) SWIG_fail;
4827 {
4828 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4829 if (SWIG_arg_fail(2)) SWIG_fail;
4830 if (arg2 == NULL) {
4831 SWIG_null_ref("wxIcon");
4832 }
4833 if (SWIG_arg_fail(2)) SWIG_fail;
4834 }
4835 {
4836 PyThreadState* __tstate = wxPyBeginAllowThreads();
4837 result = (bool)(arg1)->CopyFromIcon((wxIcon 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 *_wrap_Bitmap_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4852 PyObject *resultobj;
4853 wxBitmap *arg1 = (wxBitmap *) 0 ;
4854 int arg2 ;
4855 PyObject * obj0 = 0 ;
4856 PyObject * obj1 = 0 ;
4857 char *kwnames[] = {
4858 (char *) "self",(char *) "height", NULL
4859 };
4860
4861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetHeight",kwnames,&obj0,&obj1)) goto fail;
4862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4863 if (SWIG_arg_fail(1)) SWIG_fail;
4864 {
4865 arg2 = (int)(SWIG_As_int(obj1));
4866 if (SWIG_arg_fail(2)) SWIG_fail;
4867 }
4868 {
4869 PyThreadState* __tstate = wxPyBeginAllowThreads();
4870 (arg1)->SetHeight(arg2);
4871
4872 wxPyEndAllowThreads(__tstate);
4873 if (PyErr_Occurred()) SWIG_fail;
4874 }
4875 Py_INCREF(Py_None); resultobj = Py_None;
4876 return resultobj;
4877 fail:
4878 return NULL;
4879 }
4880
4881
4882 static PyObject *_wrap_Bitmap_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4883 PyObject *resultobj;
4884 wxBitmap *arg1 = (wxBitmap *) 0 ;
4885 int arg2 ;
4886 PyObject * obj0 = 0 ;
4887 PyObject * obj1 = 0 ;
4888 char *kwnames[] = {
4889 (char *) "self",(char *) "width", NULL
4890 };
4891
4892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetWidth",kwnames,&obj0,&obj1)) goto fail;
4893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4894 if (SWIG_arg_fail(1)) SWIG_fail;
4895 {
4896 arg2 = (int)(SWIG_As_int(obj1));
4897 if (SWIG_arg_fail(2)) SWIG_fail;
4898 }
4899 {
4900 PyThreadState* __tstate = wxPyBeginAllowThreads();
4901 (arg1)->SetWidth(arg2);
4902
4903 wxPyEndAllowThreads(__tstate);
4904 if (PyErr_Occurred()) SWIG_fail;
4905 }
4906 Py_INCREF(Py_None); resultobj = Py_None;
4907 return resultobj;
4908 fail:
4909 return NULL;
4910 }
4911
4912
4913 static PyObject *_wrap_Bitmap_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4914 PyObject *resultobj;
4915 wxBitmap *arg1 = (wxBitmap *) 0 ;
4916 int arg2 ;
4917 PyObject * obj0 = 0 ;
4918 PyObject * obj1 = 0 ;
4919 char *kwnames[] = {
4920 (char *) "self",(char *) "depth", NULL
4921 };
4922
4923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetDepth",kwnames,&obj0,&obj1)) goto fail;
4924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4925 if (SWIG_arg_fail(1)) SWIG_fail;
4926 {
4927 arg2 = (int)(SWIG_As_int(obj1));
4928 if (SWIG_arg_fail(2)) SWIG_fail;
4929 }
4930 {
4931 PyThreadState* __tstate = wxPyBeginAllowThreads();
4932 (arg1)->SetDepth(arg2);
4933
4934 wxPyEndAllowThreads(__tstate);
4935 if (PyErr_Occurred()) SWIG_fail;
4936 }
4937 Py_INCREF(Py_None); resultobj = Py_None;
4938 return resultobj;
4939 fail:
4940 return NULL;
4941 }
4942
4943
4944 static PyObject *_wrap_Bitmap_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4945 PyObject *resultobj;
4946 wxBitmap *arg1 = (wxBitmap *) 0 ;
4947 wxSize *arg2 = 0 ;
4948 wxSize temp2 ;
4949 PyObject * obj0 = 0 ;
4950 PyObject * obj1 = 0 ;
4951 char *kwnames[] = {
4952 (char *) "self",(char *) "size", NULL
4953 };
4954
4955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetSize",kwnames,&obj0,&obj1)) goto fail;
4956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4957 if (SWIG_arg_fail(1)) SWIG_fail;
4958 {
4959 arg2 = &temp2;
4960 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4961 }
4962 {
4963 PyThreadState* __tstate = wxPyBeginAllowThreads();
4964 wxBitmap_SetSize(arg1,(wxSize const &)*arg2);
4965
4966 wxPyEndAllowThreads(__tstate);
4967 if (PyErr_Occurred()) SWIG_fail;
4968 }
4969 Py_INCREF(Py_None); resultobj = Py_None;
4970 return resultobj;
4971 fail:
4972 return NULL;
4973 }
4974
4975
4976 static PyObject *_wrap_Bitmap_CopyFromCursor(PyObject *, PyObject *args, PyObject *kwargs) {
4977 PyObject *resultobj;
4978 wxBitmap *arg1 = (wxBitmap *) 0 ;
4979 wxCursor *arg2 = 0 ;
4980 bool result;
4981 PyObject * obj0 = 0 ;
4982 PyObject * obj1 = 0 ;
4983 char *kwnames[] = {
4984 (char *) "self",(char *) "cursor", NULL
4985 };
4986
4987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_CopyFromCursor",kwnames,&obj0,&obj1)) goto fail;
4988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4989 if (SWIG_arg_fail(1)) SWIG_fail;
4990 {
4991 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
4992 if (SWIG_arg_fail(2)) SWIG_fail;
4993 if (arg2 == NULL) {
4994 SWIG_null_ref("wxCursor");
4995 }
4996 if (SWIG_arg_fail(2)) SWIG_fail;
4997 }
4998 {
4999 PyThreadState* __tstate = wxPyBeginAllowThreads();
5000 result = (bool)(arg1)->CopyFromCursor((wxCursor const &)*arg2);
5001
5002 wxPyEndAllowThreads(__tstate);
5003 if (PyErr_Occurred()) SWIG_fail;
5004 }
5005 {
5006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5007 }
5008 return resultobj;
5009 fail:
5010 return NULL;
5011 }
5012
5013
5014 static PyObject *_wrap_Bitmap_GetQuality(PyObject *, PyObject *args, PyObject *kwargs) {
5015 PyObject *resultobj;
5016 wxBitmap *arg1 = (wxBitmap *) 0 ;
5017 int result;
5018 PyObject * obj0 = 0 ;
5019 char *kwnames[] = {
5020 (char *) "self", NULL
5021 };
5022
5023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetQuality",kwnames,&obj0)) goto fail;
5024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5025 if (SWIG_arg_fail(1)) SWIG_fail;
5026 {
5027 PyThreadState* __tstate = wxPyBeginAllowThreads();
5028 result = (int)(arg1)->GetQuality();
5029
5030 wxPyEndAllowThreads(__tstate);
5031 if (PyErr_Occurred()) SWIG_fail;
5032 }
5033 {
5034 resultobj = SWIG_From_int((int)(result));
5035 }
5036 return resultobj;
5037 fail:
5038 return NULL;
5039 }
5040
5041
5042 static PyObject *_wrap_Bitmap_SetQuality(PyObject *, PyObject *args, PyObject *kwargs) {
5043 PyObject *resultobj;
5044 wxBitmap *arg1 = (wxBitmap *) 0 ;
5045 int arg2 ;
5046 PyObject * obj0 = 0 ;
5047 PyObject * obj1 = 0 ;
5048 char *kwnames[] = {
5049 (char *) "self",(char *) "q", NULL
5050 };
5051
5052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetQuality",kwnames,&obj0,&obj1)) goto fail;
5053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5054 if (SWIG_arg_fail(1)) SWIG_fail;
5055 {
5056 arg2 = (int)(SWIG_As_int(obj1));
5057 if (SWIG_arg_fail(2)) SWIG_fail;
5058 }
5059 {
5060 PyThreadState* __tstate = wxPyBeginAllowThreads();
5061 (arg1)->SetQuality(arg2);
5062
5063 wxPyEndAllowThreads(__tstate);
5064 if (PyErr_Occurred()) SWIG_fail;
5065 }
5066 Py_INCREF(Py_None); resultobj = Py_None;
5067 return resultobj;
5068 fail:
5069 return NULL;
5070 }
5071
5072
5073 static PyObject *_wrap_Bitmap___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
5074 PyObject *resultobj;
5075 wxBitmap *arg1 = (wxBitmap *) 0 ;
5076 wxBitmap *arg2 = (wxBitmap *) 0 ;
5077 bool result;
5078 PyObject * obj0 = 0 ;
5079 PyObject * obj1 = 0 ;
5080 char *kwnames[] = {
5081 (char *) "self",(char *) "other", NULL
5082 };
5083
5084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___eq__",kwnames,&obj0,&obj1)) goto fail;
5085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5086 if (SWIG_arg_fail(1)) SWIG_fail;
5087 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5088 if (SWIG_arg_fail(2)) SWIG_fail;
5089 {
5090 PyThreadState* __tstate = wxPyBeginAllowThreads();
5091 result = (bool)wxBitmap___eq__(arg1,(wxBitmap const *)arg2);
5092
5093 wxPyEndAllowThreads(__tstate);
5094 if (PyErr_Occurred()) SWIG_fail;
5095 }
5096 {
5097 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5098 }
5099 return resultobj;
5100 fail:
5101 return NULL;
5102 }
5103
5104
5105 static PyObject *_wrap_Bitmap___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
5106 PyObject *resultobj;
5107 wxBitmap *arg1 = (wxBitmap *) 0 ;
5108 wxBitmap *arg2 = (wxBitmap *) 0 ;
5109 bool result;
5110 PyObject * obj0 = 0 ;
5111 PyObject * obj1 = 0 ;
5112 char *kwnames[] = {
5113 (char *) "self",(char *) "other", NULL
5114 };
5115
5116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___ne__",kwnames,&obj0,&obj1)) goto fail;
5117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5118 if (SWIG_arg_fail(1)) SWIG_fail;
5119 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5120 if (SWIG_arg_fail(2)) SWIG_fail;
5121 {
5122 PyThreadState* __tstate = wxPyBeginAllowThreads();
5123 result = (bool)wxBitmap___ne__(arg1,(wxBitmap const *)arg2);
5124
5125 wxPyEndAllowThreads(__tstate);
5126 if (PyErr_Occurred()) SWIG_fail;
5127 }
5128 {
5129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5130 }
5131 return resultobj;
5132 fail:
5133 return NULL;
5134 }
5135
5136
5137 static PyObject * Bitmap_swigregister(PyObject *, PyObject *args) {
5138 PyObject *obj;
5139 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5140 SWIG_TypeClientData(SWIGTYPE_p_wxBitmap, obj);
5141 Py_INCREF(obj);
5142 return Py_BuildValue((char *)"");
5143 }
5144 static PyObject *_wrap_new_Mask(PyObject *, PyObject *args, PyObject *kwargs) {
5145 PyObject *resultobj;
5146 wxBitmap *arg1 = 0 ;
5147 wxColour const &arg2_defvalue = wxNullColour ;
5148 wxColour *arg2 = (wxColour *) &arg2_defvalue ;
5149 wxMask *result;
5150 wxColour temp2 ;
5151 PyObject * obj0 = 0 ;
5152 PyObject * obj1 = 0 ;
5153 char *kwnames[] = {
5154 (char *) "bitmap",(char *) "colour", NULL
5155 };
5156
5157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Mask",kwnames,&obj0,&obj1)) goto fail;
5158 {
5159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5160 if (SWIG_arg_fail(1)) SWIG_fail;
5161 if (arg1 == NULL) {
5162 SWIG_null_ref("wxBitmap");
5163 }
5164 if (SWIG_arg_fail(1)) SWIG_fail;
5165 }
5166 if (obj1) {
5167 {
5168 arg2 = &temp2;
5169 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5170 }
5171 }
5172 {
5173 if (!wxPyCheckForApp()) SWIG_fail;
5174 PyThreadState* __tstate = wxPyBeginAllowThreads();
5175 result = (wxMask *)new_wxMask((wxBitmap const &)*arg1,(wxColour const &)*arg2);
5176
5177 wxPyEndAllowThreads(__tstate);
5178 if (PyErr_Occurred()) SWIG_fail;
5179 }
5180 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 1);
5181 return resultobj;
5182 fail:
5183 return NULL;
5184 }
5185
5186
5187 static PyObject * Mask_swigregister(PyObject *, PyObject *args) {
5188 PyObject *obj;
5189 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5190 SWIG_TypeClientData(SWIGTYPE_p_wxMask, obj);
5191 Py_INCREF(obj);
5192 return Py_BuildValue((char *)"");
5193 }
5194 static PyObject *_wrap_new_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
5195 PyObject *resultobj;
5196 wxString *arg1 = 0 ;
5197 wxBitmapType arg2 ;
5198 int arg3 = (int) -1 ;
5199 int arg4 = (int) -1 ;
5200 wxIcon *result;
5201 bool temp1 = false ;
5202 PyObject * obj0 = 0 ;
5203 PyObject * obj1 = 0 ;
5204 PyObject * obj2 = 0 ;
5205 PyObject * obj3 = 0 ;
5206 char *kwnames[] = {
5207 (char *) "name",(char *) "type",(char *) "desiredWidth",(char *) "desiredHeight", NULL
5208 };
5209
5210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Icon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5211 {
5212 arg1 = wxString_in_helper(obj0);
5213 if (arg1 == NULL) SWIG_fail;
5214 temp1 = true;
5215 }
5216 {
5217 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
5218 if (SWIG_arg_fail(2)) SWIG_fail;
5219 }
5220 if (obj2) {
5221 {
5222 arg3 = (int)(SWIG_As_int(obj2));
5223 if (SWIG_arg_fail(3)) SWIG_fail;
5224 }
5225 }
5226 if (obj3) {
5227 {
5228 arg4 = (int)(SWIG_As_int(obj3));
5229 if (SWIG_arg_fail(4)) SWIG_fail;
5230 }
5231 }
5232 {
5233 if (!wxPyCheckForApp()) SWIG_fail;
5234 PyThreadState* __tstate = wxPyBeginAllowThreads();
5235 result = (wxIcon *)new wxIcon((wxString const &)*arg1,(wxBitmapType )arg2,arg3,arg4);
5236
5237 wxPyEndAllowThreads(__tstate);
5238 if (PyErr_Occurred()) SWIG_fail;
5239 }
5240 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5241 {
5242 if (temp1)
5243 delete arg1;
5244 }
5245 return resultobj;
5246 fail:
5247 {
5248 if (temp1)
5249 delete arg1;
5250 }
5251 return NULL;
5252 }
5253
5254
5255 static PyObject *_wrap_delete_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
5256 PyObject *resultobj;
5257 wxIcon *arg1 = (wxIcon *) 0 ;
5258 PyObject * obj0 = 0 ;
5259 char *kwnames[] = {
5260 (char *) "self", NULL
5261 };
5262
5263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Icon",kwnames,&obj0)) goto fail;
5264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5265 if (SWIG_arg_fail(1)) SWIG_fail;
5266 {
5267 PyThreadState* __tstate = wxPyBeginAllowThreads();
5268 delete arg1;
5269
5270 wxPyEndAllowThreads(__tstate);
5271 if (PyErr_Occurred()) SWIG_fail;
5272 }
5273 Py_INCREF(Py_None); resultobj = Py_None;
5274 return resultobj;
5275 fail:
5276 return NULL;
5277 }
5278
5279
5280 static PyObject *_wrap_new_EmptyIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5281 PyObject *resultobj;
5282 wxIcon *result;
5283 char *kwnames[] = {
5284 NULL
5285 };
5286
5287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EmptyIcon",kwnames)) goto fail;
5288 {
5289 if (!wxPyCheckForApp()) SWIG_fail;
5290 PyThreadState* __tstate = wxPyBeginAllowThreads();
5291 result = (wxIcon *)new wxIcon();
5292
5293 wxPyEndAllowThreads(__tstate);
5294 if (PyErr_Occurred()) SWIG_fail;
5295 }
5296 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5297 return resultobj;
5298 fail:
5299 return NULL;
5300 }
5301
5302
5303 static PyObject *_wrap_new_IconFromLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5304 PyObject *resultobj;
5305 wxIconLocation *arg1 = 0 ;
5306 wxIcon *result;
5307 PyObject * obj0 = 0 ;
5308 char *kwnames[] = {
5309 (char *) "loc", NULL
5310 };
5311
5312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromLocation",kwnames,&obj0)) goto fail;
5313 {
5314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5315 if (SWIG_arg_fail(1)) SWIG_fail;
5316 if (arg1 == NULL) {
5317 SWIG_null_ref("wxIconLocation");
5318 }
5319 if (SWIG_arg_fail(1)) SWIG_fail;
5320 }
5321 {
5322 if (!wxPyCheckForApp()) SWIG_fail;
5323 PyThreadState* __tstate = wxPyBeginAllowThreads();
5324 result = (wxIcon *)new wxIcon((wxIconLocation const &)*arg1);
5325
5326 wxPyEndAllowThreads(__tstate);
5327 if (PyErr_Occurred()) SWIG_fail;
5328 }
5329 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5330 return resultobj;
5331 fail:
5332 return NULL;
5333 }
5334
5335
5336 static PyObject *_wrap_new_IconFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5337 PyObject *resultobj;
5338 wxBitmap *arg1 = 0 ;
5339 wxIcon *result;
5340 PyObject * obj0 = 0 ;
5341 char *kwnames[] = {
5342 (char *) "bmp", NULL
5343 };
5344
5345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromBitmap",kwnames,&obj0)) goto fail;
5346 {
5347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5348 if (SWIG_arg_fail(1)) SWIG_fail;
5349 if (arg1 == NULL) {
5350 SWIG_null_ref("wxBitmap");
5351 }
5352 if (SWIG_arg_fail(1)) SWIG_fail;
5353 }
5354 {
5355 if (!wxPyCheckForApp()) SWIG_fail;
5356 PyThreadState* __tstate = wxPyBeginAllowThreads();
5357 result = (wxIcon *)new_wxIcon((wxBitmap const &)*arg1);
5358
5359 wxPyEndAllowThreads(__tstate);
5360 if (PyErr_Occurred()) SWIG_fail;
5361 }
5362 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5363 return resultobj;
5364 fail:
5365 return NULL;
5366 }
5367
5368
5369 static PyObject *_wrap_new_IconFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
5370 PyObject *resultobj;
5371 PyObject *arg1 = (PyObject *) 0 ;
5372 wxIcon *result;
5373 PyObject * obj0 = 0 ;
5374 char *kwnames[] = {
5375 (char *) "listOfStrings", NULL
5376 };
5377
5378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromXPMData",kwnames,&obj0)) goto fail;
5379 arg1 = obj0;
5380 {
5381 if (!wxPyCheckForApp()) SWIG_fail;
5382 PyThreadState* __tstate = wxPyBeginAllowThreads();
5383 result = (wxIcon *)new_wxIcon(arg1);
5384
5385 wxPyEndAllowThreads(__tstate);
5386 if (PyErr_Occurred()) SWIG_fail;
5387 }
5388 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5389 return resultobj;
5390 fail:
5391 return NULL;
5392 }
5393
5394
5395 static PyObject *_wrap_Icon_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
5396 PyObject *resultobj;
5397 wxIcon *arg1 = (wxIcon *) 0 ;
5398 wxString *arg2 = 0 ;
5399 wxBitmapType arg3 ;
5400 bool result;
5401 bool temp2 = false ;
5402 PyObject * obj0 = 0 ;
5403 PyObject * obj1 = 0 ;
5404 PyObject * obj2 = 0 ;
5405 char *kwnames[] = {
5406 (char *) "self",(char *) "name",(char *) "type", NULL
5407 };
5408
5409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Icon_LoadFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
5410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5411 if (SWIG_arg_fail(1)) SWIG_fail;
5412 {
5413 arg2 = wxString_in_helper(obj1);
5414 if (arg2 == NULL) SWIG_fail;
5415 temp2 = true;
5416 }
5417 {
5418 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
5419 if (SWIG_arg_fail(3)) SWIG_fail;
5420 }
5421 {
5422 PyThreadState* __tstate = wxPyBeginAllowThreads();
5423 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxBitmapType )arg3);
5424
5425 wxPyEndAllowThreads(__tstate);
5426 if (PyErr_Occurred()) SWIG_fail;
5427 }
5428 {
5429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5430 }
5431 {
5432 if (temp2)
5433 delete arg2;
5434 }
5435 return resultobj;
5436 fail:
5437 {
5438 if (temp2)
5439 delete arg2;
5440 }
5441 return NULL;
5442 }
5443
5444
5445 static PyObject *_wrap_Icon_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
5446 PyObject *resultobj;
5447 wxIcon *arg1 = (wxIcon *) 0 ;
5448 long result;
5449 PyObject * obj0 = 0 ;
5450 char *kwnames[] = {
5451 (char *) "self", NULL
5452 };
5453
5454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetHandle",kwnames,&obj0)) goto fail;
5455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5456 if (SWIG_arg_fail(1)) SWIG_fail;
5457 {
5458 PyThreadState* __tstate = wxPyBeginAllowThreads();
5459 result = (long)(arg1)->GetHandle();
5460
5461 wxPyEndAllowThreads(__tstate);
5462 if (PyErr_Occurred()) SWIG_fail;
5463 }
5464 {
5465 resultobj = SWIG_From_long((long)(result));
5466 }
5467 return resultobj;
5468 fail:
5469 return NULL;
5470 }
5471
5472
5473 static PyObject *_wrap_Icon_SetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
5474 PyObject *resultobj;
5475 wxIcon *arg1 = (wxIcon *) 0 ;
5476 long arg2 ;
5477 PyObject * obj0 = 0 ;
5478 PyObject * obj1 = 0 ;
5479 char *kwnames[] = {
5480 (char *) "self",(char *) "handle", NULL
5481 };
5482
5483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetHandle",kwnames,&obj0,&obj1)) goto fail;
5484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5485 if (SWIG_arg_fail(1)) SWIG_fail;
5486 {
5487 arg2 = (long)(SWIG_As_long(obj1));
5488 if (SWIG_arg_fail(2)) SWIG_fail;
5489 }
5490 {
5491 PyThreadState* __tstate = wxPyBeginAllowThreads();
5492 wxIcon_SetHandle(arg1,arg2);
5493
5494 wxPyEndAllowThreads(__tstate);
5495 if (PyErr_Occurred()) SWIG_fail;
5496 }
5497 Py_INCREF(Py_None); resultobj = Py_None;
5498 return resultobj;
5499 fail:
5500 return NULL;
5501 }
5502
5503
5504 static PyObject *_wrap_Icon_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
5505 PyObject *resultobj;
5506 wxIcon *arg1 = (wxIcon *) 0 ;
5507 bool result;
5508 PyObject * obj0 = 0 ;
5509 char *kwnames[] = {
5510 (char *) "self", NULL
5511 };
5512
5513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_Ok",kwnames,&obj0)) goto fail;
5514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5515 if (SWIG_arg_fail(1)) SWIG_fail;
5516 {
5517 PyThreadState* __tstate = wxPyBeginAllowThreads();
5518 result = (bool)(arg1)->Ok();
5519
5520 wxPyEndAllowThreads(__tstate);
5521 if (PyErr_Occurred()) SWIG_fail;
5522 }
5523 {
5524 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5525 }
5526 return resultobj;
5527 fail:
5528 return NULL;
5529 }
5530
5531
5532 static PyObject *_wrap_Icon_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5533 PyObject *resultobj;
5534 wxIcon *arg1 = (wxIcon *) 0 ;
5535 int result;
5536 PyObject * obj0 = 0 ;
5537 char *kwnames[] = {
5538 (char *) "self", NULL
5539 };
5540
5541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetWidth",kwnames,&obj0)) goto fail;
5542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5543 if (SWIG_arg_fail(1)) SWIG_fail;
5544 {
5545 PyThreadState* __tstate = wxPyBeginAllowThreads();
5546 result = (int)(arg1)->GetWidth();
5547
5548 wxPyEndAllowThreads(__tstate);
5549 if (PyErr_Occurred()) SWIG_fail;
5550 }
5551 {
5552 resultobj = SWIG_From_int((int)(result));
5553 }
5554 return resultobj;
5555 fail:
5556 return NULL;
5557 }
5558
5559
5560 static PyObject *_wrap_Icon_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5561 PyObject *resultobj;
5562 wxIcon *arg1 = (wxIcon *) 0 ;
5563 int result;
5564 PyObject * obj0 = 0 ;
5565 char *kwnames[] = {
5566 (char *) "self", NULL
5567 };
5568
5569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetHeight",kwnames,&obj0)) goto fail;
5570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5571 if (SWIG_arg_fail(1)) SWIG_fail;
5572 {
5573 PyThreadState* __tstate = wxPyBeginAllowThreads();
5574 result = (int)(arg1)->GetHeight();
5575
5576 wxPyEndAllowThreads(__tstate);
5577 if (PyErr_Occurred()) SWIG_fail;
5578 }
5579 {
5580 resultobj = SWIG_From_int((int)(result));
5581 }
5582 return resultobj;
5583 fail:
5584 return NULL;
5585 }
5586
5587
5588 static PyObject *_wrap_Icon_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5589 PyObject *resultobj;
5590 wxIcon *arg1 = (wxIcon *) 0 ;
5591 int result;
5592 PyObject * obj0 = 0 ;
5593 char *kwnames[] = {
5594 (char *) "self", NULL
5595 };
5596
5597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetDepth",kwnames,&obj0)) goto fail;
5598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5599 if (SWIG_arg_fail(1)) SWIG_fail;
5600 {
5601 PyThreadState* __tstate = wxPyBeginAllowThreads();
5602 result = (int)(arg1)->GetDepth();
5603
5604 wxPyEndAllowThreads(__tstate);
5605 if (PyErr_Occurred()) SWIG_fail;
5606 }
5607 {
5608 resultobj = SWIG_From_int((int)(result));
5609 }
5610 return resultobj;
5611 fail:
5612 return NULL;
5613 }
5614
5615
5616 static PyObject *_wrap_Icon_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5617 PyObject *resultobj;
5618 wxIcon *arg1 = (wxIcon *) 0 ;
5619 int arg2 ;
5620 PyObject * obj0 = 0 ;
5621 PyObject * obj1 = 0 ;
5622 char *kwnames[] = {
5623 (char *) "self",(char *) "w", NULL
5624 };
5625
5626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5628 if (SWIG_arg_fail(1)) SWIG_fail;
5629 {
5630 arg2 = (int)(SWIG_As_int(obj1));
5631 if (SWIG_arg_fail(2)) SWIG_fail;
5632 }
5633 {
5634 PyThreadState* __tstate = wxPyBeginAllowThreads();
5635 (arg1)->SetWidth(arg2);
5636
5637 wxPyEndAllowThreads(__tstate);
5638 if (PyErr_Occurred()) SWIG_fail;
5639 }
5640 Py_INCREF(Py_None); resultobj = Py_None;
5641 return resultobj;
5642 fail:
5643 return NULL;
5644 }
5645
5646
5647 static PyObject *_wrap_Icon_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5648 PyObject *resultobj;
5649 wxIcon *arg1 = (wxIcon *) 0 ;
5650 int arg2 ;
5651 PyObject * obj0 = 0 ;
5652 PyObject * obj1 = 0 ;
5653 char *kwnames[] = {
5654 (char *) "self",(char *) "h", NULL
5655 };
5656
5657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5659 if (SWIG_arg_fail(1)) SWIG_fail;
5660 {
5661 arg2 = (int)(SWIG_As_int(obj1));
5662 if (SWIG_arg_fail(2)) SWIG_fail;
5663 }
5664 {
5665 PyThreadState* __tstate = wxPyBeginAllowThreads();
5666 (arg1)->SetHeight(arg2);
5667
5668 wxPyEndAllowThreads(__tstate);
5669 if (PyErr_Occurred()) SWIG_fail;
5670 }
5671 Py_INCREF(Py_None); resultobj = Py_None;
5672 return resultobj;
5673 fail:
5674 return NULL;
5675 }
5676
5677
5678 static PyObject *_wrap_Icon_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5679 PyObject *resultobj;
5680 wxIcon *arg1 = (wxIcon *) 0 ;
5681 int arg2 ;
5682 PyObject * obj0 = 0 ;
5683 PyObject * obj1 = 0 ;
5684 char *kwnames[] = {
5685 (char *) "self",(char *) "d", NULL
5686 };
5687
5688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetDepth",kwnames,&obj0,&obj1)) goto fail;
5689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5690 if (SWIG_arg_fail(1)) SWIG_fail;
5691 {
5692 arg2 = (int)(SWIG_As_int(obj1));
5693 if (SWIG_arg_fail(2)) SWIG_fail;
5694 }
5695 {
5696 PyThreadState* __tstate = wxPyBeginAllowThreads();
5697 (arg1)->SetDepth(arg2);
5698
5699 wxPyEndAllowThreads(__tstate);
5700 if (PyErr_Occurred()) SWIG_fail;
5701 }
5702 Py_INCREF(Py_None); resultobj = Py_None;
5703 return resultobj;
5704 fail:
5705 return NULL;
5706 }
5707
5708
5709 static PyObject *_wrap_Icon_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5710 PyObject *resultobj;
5711 wxIcon *arg1 = (wxIcon *) 0 ;
5712 wxSize *arg2 = 0 ;
5713 wxSize temp2 ;
5714 PyObject * obj0 = 0 ;
5715 PyObject * obj1 = 0 ;
5716 char *kwnames[] = {
5717 (char *) "self",(char *) "size", NULL
5718 };
5719
5720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetSize",kwnames,&obj0,&obj1)) goto fail;
5721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5722 if (SWIG_arg_fail(1)) SWIG_fail;
5723 {
5724 arg2 = &temp2;
5725 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5726 }
5727 {
5728 PyThreadState* __tstate = wxPyBeginAllowThreads();
5729 (arg1)->SetSize((wxSize const &)*arg2);
5730
5731 wxPyEndAllowThreads(__tstate);
5732 if (PyErr_Occurred()) SWIG_fail;
5733 }
5734 Py_INCREF(Py_None); resultobj = Py_None;
5735 return resultobj;
5736 fail:
5737 return NULL;
5738 }
5739
5740
5741 static PyObject *_wrap_Icon_CopyFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5742 PyObject *resultobj;
5743 wxIcon *arg1 = (wxIcon *) 0 ;
5744 wxBitmap *arg2 = 0 ;
5745 PyObject * obj0 = 0 ;
5746 PyObject * obj1 = 0 ;
5747 char *kwnames[] = {
5748 (char *) "self",(char *) "bmp", NULL
5749 };
5750
5751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_CopyFromBitmap",kwnames,&obj0,&obj1)) goto fail;
5752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5753 if (SWIG_arg_fail(1)) SWIG_fail;
5754 {
5755 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5756 if (SWIG_arg_fail(2)) SWIG_fail;
5757 if (arg2 == NULL) {
5758 SWIG_null_ref("wxBitmap");
5759 }
5760 if (SWIG_arg_fail(2)) SWIG_fail;
5761 }
5762 {
5763 PyThreadState* __tstate = wxPyBeginAllowThreads();
5764 (arg1)->CopyFromBitmap((wxBitmap const &)*arg2);
5765
5766 wxPyEndAllowThreads(__tstate);
5767 if (PyErr_Occurred()) SWIG_fail;
5768 }
5769 Py_INCREF(Py_None); resultobj = Py_None;
5770 return resultobj;
5771 fail:
5772 return NULL;
5773 }
5774
5775
5776 static PyObject * Icon_swigregister(PyObject *, PyObject *args) {
5777 PyObject *obj;
5778 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5779 SWIG_TypeClientData(SWIGTYPE_p_wxIcon, obj);
5780 Py_INCREF(obj);
5781 return Py_BuildValue((char *)"");
5782 }
5783 static PyObject *_wrap_new_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5784 PyObject *resultobj;
5785 wxString *arg1 = (wxString *) &wxPyEmptyString ;
5786 int arg2 = (int) 0 ;
5787 wxIconLocation *result;
5788 bool temp1 = false ;
5789 PyObject * obj0 = 0 ;
5790 PyObject * obj1 = 0 ;
5791 char *kwnames[] = {
5792 (char *) "filename",(char *) "num", NULL
5793 };
5794
5795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconLocation",kwnames,&obj0,&obj1)) goto fail;
5796 if (obj0) {
5797 {
5798 arg1 = wxString_in_helper(obj0);
5799 if (arg1 == NULL) SWIG_fail;
5800 temp1 = true;
5801 }
5802 }
5803 if (obj1) {
5804 {
5805 arg2 = (int)(SWIG_As_int(obj1));
5806 if (SWIG_arg_fail(2)) SWIG_fail;
5807 }
5808 }
5809 {
5810 PyThreadState* __tstate = wxPyBeginAllowThreads();
5811 result = (wxIconLocation *)new_wxIconLocation((wxString const *)arg1,arg2);
5812
5813 wxPyEndAllowThreads(__tstate);
5814 if (PyErr_Occurred()) SWIG_fail;
5815 }
5816 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconLocation, 1);
5817 {
5818 if (temp1)
5819 delete arg1;
5820 }
5821 return resultobj;
5822 fail:
5823 {
5824 if (temp1)
5825 delete arg1;
5826 }
5827 return NULL;
5828 }
5829
5830
5831 static PyObject *_wrap_delete_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5832 PyObject *resultobj;
5833 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5834 PyObject * obj0 = 0 ;
5835 char *kwnames[] = {
5836 (char *) "self", NULL
5837 };
5838
5839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconLocation",kwnames,&obj0)) goto fail;
5840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5841 if (SWIG_arg_fail(1)) SWIG_fail;
5842 {
5843 PyThreadState* __tstate = wxPyBeginAllowThreads();
5844 delete arg1;
5845
5846 wxPyEndAllowThreads(__tstate);
5847 if (PyErr_Occurred()) SWIG_fail;
5848 }
5849 Py_INCREF(Py_None); resultobj = Py_None;
5850 return resultobj;
5851 fail:
5852 return NULL;
5853 }
5854
5855
5856 static PyObject *_wrap_IconLocation_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
5857 PyObject *resultobj;
5858 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5859 bool result;
5860 PyObject * obj0 = 0 ;
5861 char *kwnames[] = {
5862 (char *) "self", NULL
5863 };
5864
5865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_IsOk",kwnames,&obj0)) goto fail;
5866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5867 if (SWIG_arg_fail(1)) SWIG_fail;
5868 {
5869 PyThreadState* __tstate = wxPyBeginAllowThreads();
5870 result = (bool)((wxIconLocation const *)arg1)->IsOk();
5871
5872 wxPyEndAllowThreads(__tstate);
5873 if (PyErr_Occurred()) SWIG_fail;
5874 }
5875 {
5876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5877 }
5878 return resultobj;
5879 fail:
5880 return NULL;
5881 }
5882
5883
5884 static PyObject *_wrap_IconLocation_SetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5885 PyObject *resultobj;
5886 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5887 wxString *arg2 = 0 ;
5888 bool temp2 = false ;
5889 PyObject * obj0 = 0 ;
5890 PyObject * obj1 = 0 ;
5891 char *kwnames[] = {
5892 (char *) "self",(char *) "filename", NULL
5893 };
5894
5895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetFileName",kwnames,&obj0,&obj1)) goto fail;
5896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5897 if (SWIG_arg_fail(1)) SWIG_fail;
5898 {
5899 arg2 = wxString_in_helper(obj1);
5900 if (arg2 == NULL) SWIG_fail;
5901 temp2 = true;
5902 }
5903 {
5904 PyThreadState* __tstate = wxPyBeginAllowThreads();
5905 (arg1)->SetFileName((wxString const &)*arg2);
5906
5907 wxPyEndAllowThreads(__tstate);
5908 if (PyErr_Occurred()) SWIG_fail;
5909 }
5910 Py_INCREF(Py_None); resultobj = Py_None;
5911 {
5912 if (temp2)
5913 delete arg2;
5914 }
5915 return resultobj;
5916 fail:
5917 {
5918 if (temp2)
5919 delete arg2;
5920 }
5921 return NULL;
5922 }
5923
5924
5925 static PyObject *_wrap_IconLocation_GetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5926 PyObject *resultobj;
5927 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5928 wxString *result;
5929 PyObject * obj0 = 0 ;
5930 char *kwnames[] = {
5931 (char *) "self", NULL
5932 };
5933
5934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetFileName",kwnames,&obj0)) goto fail;
5935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5936 if (SWIG_arg_fail(1)) SWIG_fail;
5937 {
5938 PyThreadState* __tstate = wxPyBeginAllowThreads();
5939 {
5940 wxString const &_result_ref = ((wxIconLocation const *)arg1)->GetFileName();
5941 result = (wxString *) &_result_ref;
5942 }
5943
5944 wxPyEndAllowThreads(__tstate);
5945 if (PyErr_Occurred()) SWIG_fail;
5946 }
5947 {
5948 #if wxUSE_UNICODE
5949 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
5950 #else
5951 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
5952 #endif
5953 }
5954 return resultobj;
5955 fail:
5956 return NULL;
5957 }
5958
5959
5960 static PyObject *_wrap_IconLocation_SetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5961 PyObject *resultobj;
5962 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5963 int arg2 ;
5964 PyObject * obj0 = 0 ;
5965 PyObject * obj1 = 0 ;
5966 char *kwnames[] = {
5967 (char *) "self",(char *) "num", NULL
5968 };
5969
5970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetIndex",kwnames,&obj0,&obj1)) goto fail;
5971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5972 if (SWIG_arg_fail(1)) SWIG_fail;
5973 {
5974 arg2 = (int)(SWIG_As_int(obj1));
5975 if (SWIG_arg_fail(2)) SWIG_fail;
5976 }
5977 {
5978 PyThreadState* __tstate = wxPyBeginAllowThreads();
5979 wxIconLocation_SetIndex(arg1,arg2);
5980
5981 wxPyEndAllowThreads(__tstate);
5982 if (PyErr_Occurred()) SWIG_fail;
5983 }
5984 Py_INCREF(Py_None); resultobj = Py_None;
5985 return resultobj;
5986 fail:
5987 return NULL;
5988 }
5989
5990
5991 static PyObject *_wrap_IconLocation_GetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5992 PyObject *resultobj;
5993 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5994 int result;
5995 PyObject * obj0 = 0 ;
5996 char *kwnames[] = {
5997 (char *) "self", NULL
5998 };
5999
6000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetIndex",kwnames,&obj0)) goto fail;
6001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
6002 if (SWIG_arg_fail(1)) SWIG_fail;
6003 {
6004 PyThreadState* __tstate = wxPyBeginAllowThreads();
6005 result = (int)wxIconLocation_GetIndex(arg1);
6006
6007 wxPyEndAllowThreads(__tstate);
6008 if (PyErr_Occurred()) SWIG_fail;
6009 }
6010 {
6011 resultobj = SWIG_From_int((int)(result));
6012 }
6013 return resultobj;
6014 fail:
6015 return NULL;
6016 }
6017
6018
6019 static PyObject * IconLocation_swigregister(PyObject *, PyObject *args) {
6020 PyObject *obj;
6021 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6022 SWIG_TypeClientData(SWIGTYPE_p_wxIconLocation, obj);
6023 Py_INCREF(obj);
6024 return Py_BuildValue((char *)"");
6025 }
6026 static PyObject *_wrap_new_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
6027 PyObject *resultobj;
6028 wxIconBundle *result;
6029 char *kwnames[] = {
6030 NULL
6031 };
6032
6033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IconBundle",kwnames)) goto fail;
6034 {
6035 PyThreadState* __tstate = wxPyBeginAllowThreads();
6036 result = (wxIconBundle *)new wxIconBundle();
6037
6038 wxPyEndAllowThreads(__tstate);
6039 if (PyErr_Occurred()) SWIG_fail;
6040 }
6041 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
6042 return resultobj;
6043 fail:
6044 return NULL;
6045 }
6046
6047
6048 static PyObject *_wrap_new_IconBundleFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
6049 PyObject *resultobj;
6050 wxString *arg1 = 0 ;
6051 long arg2 ;
6052 wxIconBundle *result;
6053 bool temp1 = false ;
6054 PyObject * obj0 = 0 ;
6055 PyObject * obj1 = 0 ;
6056 char *kwnames[] = {
6057 (char *) "file",(char *) "type", NULL
6058 };
6059
6060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_IconBundleFromFile",kwnames,&obj0,&obj1)) goto fail;
6061 {
6062 arg1 = wxString_in_helper(obj0);
6063 if (arg1 == NULL) SWIG_fail;
6064 temp1 = true;
6065 }
6066 {
6067 arg2 = (long)(SWIG_As_long(obj1));
6068 if (SWIG_arg_fail(2)) SWIG_fail;
6069 }
6070 {
6071 PyThreadState* __tstate = wxPyBeginAllowThreads();
6072 result = (wxIconBundle *)new wxIconBundle((wxString const &)*arg1,arg2);
6073
6074 wxPyEndAllowThreads(__tstate);
6075 if (PyErr_Occurred()) SWIG_fail;
6076 }
6077 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
6078 {
6079 if (temp1)
6080 delete arg1;
6081 }
6082 return resultobj;
6083 fail:
6084 {
6085 if (temp1)
6086 delete arg1;
6087 }
6088 return NULL;
6089 }
6090
6091
6092 static PyObject *_wrap_new_IconBundleFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
6093 PyObject *resultobj;
6094 wxIcon *arg1 = 0 ;
6095 wxIconBundle *result;
6096 PyObject * obj0 = 0 ;
6097 char *kwnames[] = {
6098 (char *) "icon", NULL
6099 };
6100
6101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconBundleFromIcon",kwnames,&obj0)) goto fail;
6102 {
6103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
6104 if (SWIG_arg_fail(1)) SWIG_fail;
6105 if (arg1 == NULL) {
6106 SWIG_null_ref("wxIcon");
6107 }
6108 if (SWIG_arg_fail(1)) SWIG_fail;
6109 }
6110 {
6111 PyThreadState* __tstate = wxPyBeginAllowThreads();
6112 result = (wxIconBundle *)new wxIconBundle((wxIcon const &)*arg1);
6113
6114 wxPyEndAllowThreads(__tstate);
6115 if (PyErr_Occurred()) SWIG_fail;
6116 }
6117 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
6118 return resultobj;
6119 fail:
6120 return NULL;
6121 }
6122
6123
6124 static PyObject *_wrap_delete_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
6125 PyObject *resultobj;
6126 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
6127 PyObject * obj0 = 0 ;
6128 char *kwnames[] = {
6129 (char *) "self", NULL
6130 };
6131
6132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconBundle",kwnames,&obj0)) goto fail;
6133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
6134 if (SWIG_arg_fail(1)) SWIG_fail;
6135 {
6136 PyThreadState* __tstate = wxPyBeginAllowThreads();
6137 delete arg1;
6138
6139 wxPyEndAllowThreads(__tstate);
6140 if (PyErr_Occurred()) SWIG_fail;
6141 }
6142 Py_INCREF(Py_None); resultobj = Py_None;
6143 return resultobj;
6144 fail:
6145 return NULL;
6146 }
6147
6148
6149 static PyObject *_wrap_IconBundle_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
6150 PyObject *resultobj;
6151 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
6152 wxIcon *arg2 = 0 ;
6153 PyObject * obj0 = 0 ;
6154 PyObject * obj1 = 0 ;
6155 char *kwnames[] = {
6156 (char *) "self",(char *) "icon", NULL
6157 };
6158
6159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_AddIcon",kwnames,&obj0,&obj1)) goto fail;
6160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
6161 if (SWIG_arg_fail(1)) SWIG_fail;
6162 {
6163 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
6164 if (SWIG_arg_fail(2)) SWIG_fail;
6165 if (arg2 == NULL) {
6166 SWIG_null_ref("wxIcon");
6167 }
6168 if (SWIG_arg_fail(2)) SWIG_fail;
6169 }
6170 {
6171 PyThreadState* __tstate = wxPyBeginAllowThreads();
6172 (arg1)->AddIcon((wxIcon const &)*arg2);
6173
6174 wxPyEndAllowThreads(__tstate);
6175 if (PyErr_Occurred()) SWIG_fail;
6176 }
6177 Py_INCREF(Py_None); resultobj = Py_None;
6178 return resultobj;
6179 fail:
6180 return NULL;
6181 }
6182
6183
6184 static PyObject *_wrap_IconBundle_AddIconFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
6185 PyObject *resultobj;
6186 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
6187 wxString *arg2 = 0 ;
6188 long arg3 ;
6189 bool temp2 = false ;
6190 PyObject * obj0 = 0 ;
6191 PyObject * obj1 = 0 ;
6192 PyObject * obj2 = 0 ;
6193 char *kwnames[] = {
6194 (char *) "self",(char *) "file",(char *) "type", NULL
6195 };
6196
6197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IconBundle_AddIconFromFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
6198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
6199 if (SWIG_arg_fail(1)) SWIG_fail;
6200 {
6201 arg2 = wxString_in_helper(obj1);
6202 if (arg2 == NULL) SWIG_fail;
6203 temp2 = true;
6204 }
6205 {
6206 arg3 = (long)(SWIG_As_long(obj2));
6207 if (SWIG_arg_fail(3)) SWIG_fail;
6208 }
6209 {
6210 PyThreadState* __tstate = wxPyBeginAllowThreads();
6211 (arg1)->AddIcon((wxString const &)*arg2,arg3);
6212
6213 wxPyEndAllowThreads(__tstate);
6214 if (PyErr_Occurred()) SWIG_fail;
6215 }
6216 Py_INCREF(Py_None); resultobj = Py_None;
6217 {
6218 if (temp2)
6219 delete arg2;
6220 }
6221 return resultobj;
6222 fail:
6223 {
6224 if (temp2)
6225 delete arg2;
6226 }
6227 return NULL;
6228 }
6229
6230
6231 static PyObject *_wrap_IconBundle_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
6232 PyObject *resultobj;
6233 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
6234 wxSize *arg2 = 0 ;
6235 wxIcon *result;
6236 wxSize temp2 ;
6237 PyObject * obj0 = 0 ;
6238 PyObject * obj1 = 0 ;
6239 char *kwnames[] = {
6240 (char *) "self",(char *) "size", NULL
6241 };
6242
6243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_GetIcon",kwnames,&obj0,&obj1)) goto fail;
6244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
6245 if (SWIG_arg_fail(1)) SWIG_fail;
6246 {
6247 arg2 = &temp2;
6248 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6249 }
6250 {
6251 PyThreadState* __tstate = wxPyBeginAllowThreads();
6252 {
6253 wxIcon const &_result_ref = ((wxIconBundle const *)arg1)->GetIcon((wxSize const &)*arg2);
6254 result = (wxIcon *) &_result_ref;
6255 }
6256
6257 wxPyEndAllowThreads(__tstate);
6258 if (PyErr_Occurred()) SWIG_fail;
6259 }
6260 {
6261 wxIcon* resultptr = new wxIcon(*result);
6262 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxIcon, 1);
6263 }
6264 return resultobj;
6265 fail:
6266 return NULL;
6267 }
6268
6269
6270 static PyObject * IconBundle_swigregister(PyObject *, PyObject *args) {
6271 PyObject *obj;
6272 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6273 SWIG_TypeClientData(SWIGTYPE_p_wxIconBundle, obj);
6274 Py_INCREF(obj);
6275 return Py_BuildValue((char *)"");
6276 }
6277 static PyObject *_wrap_new_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
6278 PyObject *resultobj;
6279 wxString *arg1 = 0 ;
6280 long arg2 ;
6281 int arg3 = (int) 0 ;
6282 int arg4 = (int) 0 ;
6283 wxCursor *result;
6284 bool temp1 = false ;
6285 PyObject * obj0 = 0 ;
6286 PyObject * obj1 = 0 ;
6287 PyObject * obj2 = 0 ;
6288 PyObject * obj3 = 0 ;
6289 char *kwnames[] = {
6290 (char *) "cursorName",(char *) "type",(char *) "hotSpotX",(char *) "hotSpotY", NULL
6291 };
6292
6293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Cursor",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6294 {
6295 arg1 = wxString_in_helper(obj0);
6296 if (arg1 == NULL) SWIG_fail;
6297 temp1 = true;
6298 }
6299 {
6300 arg2 = (long)(SWIG_As_long(obj1));
6301 if (SWIG_arg_fail(2)) SWIG_fail;
6302 }
6303 if (obj2) {
6304 {
6305 arg3 = (int)(SWIG_As_int(obj2));
6306 if (SWIG_arg_fail(3)) SWIG_fail;
6307 }
6308 }
6309 if (obj3) {
6310 {
6311 arg4 = (int)(SWIG_As_int(obj3));
6312 if (SWIG_arg_fail(4)) SWIG_fail;
6313 }
6314 }
6315 {
6316 if (!wxPyCheckForApp()) SWIG_fail;
6317 PyThreadState* __tstate = wxPyBeginAllowThreads();
6318 result = (wxCursor *)new_wxCursor((wxString const &)*arg1,arg2,arg3,arg4);
6319
6320 wxPyEndAllowThreads(__tstate);
6321 if (PyErr_Occurred()) SWIG_fail;
6322 }
6323 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6324 {
6325 if (temp1)
6326 delete arg1;
6327 }
6328 return resultobj;
6329 fail:
6330 {
6331 if (temp1)
6332 delete arg1;
6333 }
6334 return NULL;
6335 }
6336
6337
6338 static PyObject *_wrap_delete_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
6339 PyObject *resultobj;
6340 wxCursor *arg1 = (wxCursor *) 0 ;
6341 PyObject * obj0 = 0 ;
6342 char *kwnames[] = {
6343 (char *) "self", NULL
6344 };
6345
6346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Cursor",kwnames,&obj0)) goto fail;
6347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6348 if (SWIG_arg_fail(1)) SWIG_fail;
6349 {
6350 PyThreadState* __tstate = wxPyBeginAllowThreads();
6351 delete arg1;
6352
6353 wxPyEndAllowThreads(__tstate);
6354 if (PyErr_Occurred()) SWIG_fail;
6355 }
6356 Py_INCREF(Py_None); resultobj = Py_None;
6357 return resultobj;
6358 fail:
6359 return NULL;
6360 }
6361
6362
6363 static PyObject *_wrap_new_StockCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6364 PyObject *resultobj;
6365 int arg1 ;
6366 wxCursor *result;
6367 PyObject * obj0 = 0 ;
6368 char *kwnames[] = {
6369 (char *) "id", NULL
6370 };
6371
6372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_StockCursor",kwnames,&obj0)) goto fail;
6373 {
6374 arg1 = (int)(SWIG_As_int(obj0));
6375 if (SWIG_arg_fail(1)) SWIG_fail;
6376 }
6377 {
6378 if (!wxPyCheckForApp()) SWIG_fail;
6379 PyThreadState* __tstate = wxPyBeginAllowThreads();
6380 result = (wxCursor *)new wxCursor(arg1);
6381
6382 wxPyEndAllowThreads(__tstate);
6383 if (PyErr_Occurred()) SWIG_fail;
6384 }
6385 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6386 return resultobj;
6387 fail:
6388 return NULL;
6389 }
6390
6391
6392 static PyObject *_wrap_new_CursorFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
6393 PyObject *resultobj;
6394 wxImage *arg1 = 0 ;
6395 wxCursor *result;
6396 PyObject * obj0 = 0 ;
6397 char *kwnames[] = {
6398 (char *) "image", NULL
6399 };
6400
6401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CursorFromImage",kwnames,&obj0)) goto fail;
6402 {
6403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
6404 if (SWIG_arg_fail(1)) SWIG_fail;
6405 if (arg1 == NULL) {
6406 SWIG_null_ref("wxImage");
6407 }
6408 if (SWIG_arg_fail(1)) SWIG_fail;
6409 }
6410 {
6411 if (!wxPyCheckForApp()) SWIG_fail;
6412 PyThreadState* __tstate = wxPyBeginAllowThreads();
6413 result = (wxCursor *)new wxCursor((wxImage const &)*arg1);
6414
6415 wxPyEndAllowThreads(__tstate);
6416 if (PyErr_Occurred()) SWIG_fail;
6417 }
6418 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6419 return resultobj;
6420 fail:
6421 return NULL;
6422 }
6423
6424
6425 static PyObject *_wrap_Cursor_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
6426 PyObject *resultobj;
6427 wxCursor *arg1 = (wxCursor *) 0 ;
6428 long result;
6429 PyObject * obj0 = 0 ;
6430 char *kwnames[] = {
6431 (char *) "self", NULL
6432 };
6433
6434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_GetHandle",kwnames,&obj0)) goto fail;
6435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6436 if (SWIG_arg_fail(1)) SWIG_fail;
6437 {
6438 PyThreadState* __tstate = wxPyBeginAllowThreads();
6439 result = (long)(arg1)->GetHandle();
6440
6441 wxPyEndAllowThreads(__tstate);
6442 if (PyErr_Occurred()) SWIG_fail;
6443 }
6444 {
6445 resultobj = SWIG_From_long((long)(result));
6446 }
6447 return resultobj;
6448 fail:
6449 return NULL;
6450 }
6451
6452
6453 static PyObject *_wrap_Cursor_SetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
6454 PyObject *resultobj;
6455 wxCursor *arg1 = (wxCursor *) 0 ;
6456 long arg2 ;
6457 PyObject * obj0 = 0 ;
6458 PyObject * obj1 = 0 ;
6459 char *kwnames[] = {
6460 (char *) "self",(char *) "handle", NULL
6461 };
6462
6463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetHandle",kwnames,&obj0,&obj1)) goto fail;
6464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6465 if (SWIG_arg_fail(1)) SWIG_fail;
6466 {
6467 arg2 = (long)(SWIG_As_long(obj1));
6468 if (SWIG_arg_fail(2)) SWIG_fail;
6469 }
6470 {
6471 PyThreadState* __tstate = wxPyBeginAllowThreads();
6472 wxCursor_SetHandle(arg1,arg2);
6473
6474 wxPyEndAllowThreads(__tstate);
6475 if (PyErr_Occurred()) SWIG_fail;
6476 }
6477 Py_INCREF(Py_None); resultobj = Py_None;
6478 return resultobj;
6479 fail:
6480 return NULL;
6481 }
6482
6483
6484 static PyObject *_wrap_Cursor_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
6485 PyObject *resultobj;
6486 wxCursor *arg1 = (wxCursor *) 0 ;
6487 bool result;
6488 PyObject * obj0 = 0 ;
6489 char *kwnames[] = {
6490 (char *) "self", NULL
6491 };
6492
6493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_Ok",kwnames,&obj0)) goto fail;
6494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6495 if (SWIG_arg_fail(1)) SWIG_fail;
6496 {
6497 PyThreadState* __tstate = wxPyBeginAllowThreads();
6498 result = (bool)(arg1)->Ok();
6499
6500 wxPyEndAllowThreads(__tstate);
6501 if (PyErr_Occurred()) SWIG_fail;
6502 }
6503 {
6504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6505 }
6506 return resultobj;
6507 fail:
6508 return NULL;
6509 }
6510
6511
6512 static PyObject *_wrap_Cursor_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
6513 PyObject *resultobj;
6514 wxCursor *arg1 = (wxCursor *) 0 ;
6515 int result;
6516 PyObject * obj0 = 0 ;
6517 char *kwnames[] = {
6518 (char *) "self", NULL
6519 };
6520
6521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_GetWidth",kwnames,&obj0)) goto fail;
6522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6523 if (SWIG_arg_fail(1)) SWIG_fail;
6524 {
6525 PyThreadState* __tstate = wxPyBeginAllowThreads();
6526 result = (int)(arg1)->GetWidth();
6527
6528 wxPyEndAllowThreads(__tstate);
6529 if (PyErr_Occurred()) SWIG_fail;
6530 }
6531 {
6532 resultobj = SWIG_From_int((int)(result));
6533 }
6534 return resultobj;
6535 fail:
6536 return NULL;
6537 }
6538
6539
6540 static PyObject *_wrap_Cursor_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
6541 PyObject *resultobj;
6542 wxCursor *arg1 = (wxCursor *) 0 ;
6543 int result;
6544 PyObject * obj0 = 0 ;
6545 char *kwnames[] = {
6546 (char *) "self", NULL
6547 };
6548
6549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_GetHeight",kwnames,&obj0)) goto fail;
6550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6551 if (SWIG_arg_fail(1)) SWIG_fail;
6552 {
6553 PyThreadState* __tstate = wxPyBeginAllowThreads();
6554 result = (int)(arg1)->GetHeight();
6555
6556 wxPyEndAllowThreads(__tstate);
6557 if (PyErr_Occurred()) SWIG_fail;
6558 }
6559 {
6560 resultobj = SWIG_From_int((int)(result));
6561 }
6562 return resultobj;
6563 fail:
6564 return NULL;
6565 }
6566
6567
6568 static PyObject *_wrap_Cursor_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
6569 PyObject *resultobj;
6570 wxCursor *arg1 = (wxCursor *) 0 ;
6571 int result;
6572 PyObject * obj0 = 0 ;
6573 char *kwnames[] = {
6574 (char *) "self", NULL
6575 };
6576
6577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_GetDepth",kwnames,&obj0)) goto fail;
6578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6579 if (SWIG_arg_fail(1)) SWIG_fail;
6580 {
6581 PyThreadState* __tstate = wxPyBeginAllowThreads();
6582 result = (int)(arg1)->GetDepth();
6583
6584 wxPyEndAllowThreads(__tstate);
6585 if (PyErr_Occurred()) SWIG_fail;
6586 }
6587 {
6588 resultobj = SWIG_From_int((int)(result));
6589 }
6590 return resultobj;
6591 fail:
6592 return NULL;
6593 }
6594
6595
6596 static PyObject *_wrap_Cursor_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
6597 PyObject *resultobj;
6598 wxCursor *arg1 = (wxCursor *) 0 ;
6599 int arg2 ;
6600 PyObject * obj0 = 0 ;
6601 PyObject * obj1 = 0 ;
6602 char *kwnames[] = {
6603 (char *) "self",(char *) "w", NULL
6604 };
6605
6606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetWidth",kwnames,&obj0,&obj1)) goto fail;
6607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6608 if (SWIG_arg_fail(1)) SWIG_fail;
6609 {
6610 arg2 = (int)(SWIG_As_int(obj1));
6611 if (SWIG_arg_fail(2)) SWIG_fail;
6612 }
6613 {
6614 PyThreadState* __tstate = wxPyBeginAllowThreads();
6615 (arg1)->SetWidth(arg2);
6616
6617 wxPyEndAllowThreads(__tstate);
6618 if (PyErr_Occurred()) SWIG_fail;
6619 }
6620 Py_INCREF(Py_None); resultobj = Py_None;
6621 return resultobj;
6622 fail:
6623 return NULL;
6624 }
6625
6626
6627 static PyObject *_wrap_Cursor_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
6628 PyObject *resultobj;
6629 wxCursor *arg1 = (wxCursor *) 0 ;
6630 int arg2 ;
6631 PyObject * obj0 = 0 ;
6632 PyObject * obj1 = 0 ;
6633 char *kwnames[] = {
6634 (char *) "self",(char *) "h", NULL
6635 };
6636
6637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetHeight",kwnames,&obj0,&obj1)) goto fail;
6638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6639 if (SWIG_arg_fail(1)) SWIG_fail;
6640 {
6641 arg2 = (int)(SWIG_As_int(obj1));
6642 if (SWIG_arg_fail(2)) SWIG_fail;
6643 }
6644 {
6645 PyThreadState* __tstate = wxPyBeginAllowThreads();
6646 (arg1)->SetHeight(arg2);
6647
6648 wxPyEndAllowThreads(__tstate);
6649 if (PyErr_Occurred()) SWIG_fail;
6650 }
6651 Py_INCREF(Py_None); resultobj = Py_None;
6652 return resultobj;
6653 fail:
6654 return NULL;
6655 }
6656
6657
6658 static PyObject *_wrap_Cursor_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
6659 PyObject *resultobj;
6660 wxCursor *arg1 = (wxCursor *) 0 ;
6661 int arg2 ;
6662 PyObject * obj0 = 0 ;
6663 PyObject * obj1 = 0 ;
6664 char *kwnames[] = {
6665 (char *) "self",(char *) "d", NULL
6666 };
6667
6668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetDepth",kwnames,&obj0,&obj1)) goto fail;
6669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6670 if (SWIG_arg_fail(1)) SWIG_fail;
6671 {
6672 arg2 = (int)(SWIG_As_int(obj1));
6673 if (SWIG_arg_fail(2)) SWIG_fail;
6674 }
6675 {
6676 PyThreadState* __tstate = wxPyBeginAllowThreads();
6677 (arg1)->SetDepth(arg2);
6678
6679 wxPyEndAllowThreads(__tstate);
6680 if (PyErr_Occurred()) SWIG_fail;
6681 }
6682 Py_INCREF(Py_None); resultobj = Py_None;
6683 return resultobj;
6684 fail:
6685 return NULL;
6686 }
6687
6688
6689 static PyObject *_wrap_Cursor_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6690 PyObject *resultobj;
6691 wxCursor *arg1 = (wxCursor *) 0 ;
6692 wxSize *arg2 = 0 ;
6693 wxSize temp2 ;
6694 PyObject * obj0 = 0 ;
6695 PyObject * obj1 = 0 ;
6696 char *kwnames[] = {
6697 (char *) "self",(char *) "size", NULL
6698 };
6699
6700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetSize",kwnames,&obj0,&obj1)) goto fail;
6701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6702 if (SWIG_arg_fail(1)) SWIG_fail;
6703 {
6704 arg2 = &temp2;
6705 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6706 }
6707 {
6708 PyThreadState* __tstate = wxPyBeginAllowThreads();
6709 (arg1)->SetSize((wxSize const &)*arg2);
6710
6711 wxPyEndAllowThreads(__tstate);
6712 if (PyErr_Occurred()) SWIG_fail;
6713 }
6714 Py_INCREF(Py_None); resultobj = Py_None;
6715 return resultobj;
6716 fail:
6717 return NULL;
6718 }
6719
6720
6721 static PyObject * Cursor_swigregister(PyObject *, PyObject *args) {
6722 PyObject *obj;
6723 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6724 SWIG_TypeClientData(SWIGTYPE_p_wxCursor, obj);
6725 Py_INCREF(obj);
6726 return Py_BuildValue((char *)"");
6727 }
6728 static PyObject *_wrap_new_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6729 PyObject *resultobj;
6730 int arg1 = (int) 0 ;
6731 int arg2 = (int) 0 ;
6732 int arg3 = (int) 0 ;
6733 int arg4 = (int) 0 ;
6734 wxRegion *result;
6735 PyObject * obj0 = 0 ;
6736 PyObject * obj1 = 0 ;
6737 PyObject * obj2 = 0 ;
6738 PyObject * obj3 = 0 ;
6739 char *kwnames[] = {
6740 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6741 };
6742
6743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Region",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6744 if (obj0) {
6745 {
6746 arg1 = (int)(SWIG_As_int(obj0));
6747 if (SWIG_arg_fail(1)) SWIG_fail;
6748 }
6749 }
6750 if (obj1) {
6751 {
6752 arg2 = (int)(SWIG_As_int(obj1));
6753 if (SWIG_arg_fail(2)) SWIG_fail;
6754 }
6755 }
6756 if (obj2) {
6757 {
6758 arg3 = (int)(SWIG_As_int(obj2));
6759 if (SWIG_arg_fail(3)) SWIG_fail;
6760 }
6761 }
6762 if (obj3) {
6763 {
6764 arg4 = (int)(SWIG_As_int(obj3));
6765 if (SWIG_arg_fail(4)) SWIG_fail;
6766 }
6767 }
6768 {
6769 if (!wxPyCheckForApp()) SWIG_fail;
6770 PyThreadState* __tstate = wxPyBeginAllowThreads();
6771 result = (wxRegion *)new wxRegion(arg1,arg2,arg3,arg4);
6772
6773 wxPyEndAllowThreads(__tstate);
6774 if (PyErr_Occurred()) SWIG_fail;
6775 }
6776 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6777 return resultobj;
6778 fail:
6779 return NULL;
6780 }
6781
6782
6783 static PyObject *_wrap_new_RegionFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
6784 PyObject *resultobj;
6785 wxBitmap *arg1 = 0 ;
6786 wxRegion *result;
6787 PyObject * obj0 = 0 ;
6788 char *kwnames[] = {
6789 (char *) "bmp", NULL
6790 };
6791
6792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionFromBitmap",kwnames,&obj0)) goto fail;
6793 {
6794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6795 if (SWIG_arg_fail(1)) SWIG_fail;
6796 if (arg1 == NULL) {
6797 SWIG_null_ref("wxBitmap");
6798 }
6799 if (SWIG_arg_fail(1)) SWIG_fail;
6800 }
6801 {
6802 if (!wxPyCheckForApp()) SWIG_fail;
6803 PyThreadState* __tstate = wxPyBeginAllowThreads();
6804 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1);
6805
6806 wxPyEndAllowThreads(__tstate);
6807 if (PyErr_Occurred()) SWIG_fail;
6808 }
6809 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6810 return resultobj;
6811 fail:
6812 return NULL;
6813 }
6814
6815
6816 static PyObject *_wrap_new_RegionFromBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
6817 PyObject *resultobj;
6818 wxBitmap *arg1 = 0 ;
6819 wxColour *arg2 = 0 ;
6820 int arg3 = (int) 0 ;
6821 wxRegion *result;
6822 wxColour temp2 ;
6823 PyObject * obj0 = 0 ;
6824 PyObject * obj1 = 0 ;
6825 PyObject * obj2 = 0 ;
6826 char *kwnames[] = {
6827 (char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
6828 };
6829
6830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_RegionFromBitmapColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
6831 {
6832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6833 if (SWIG_arg_fail(1)) SWIG_fail;
6834 if (arg1 == NULL) {
6835 SWIG_null_ref("wxBitmap");
6836 }
6837 if (SWIG_arg_fail(1)) SWIG_fail;
6838 }
6839 {
6840 arg2 = &temp2;
6841 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6842 }
6843 if (obj2) {
6844 {
6845 arg3 = (int)(SWIG_As_int(obj2));
6846 if (SWIG_arg_fail(3)) SWIG_fail;
6847 }
6848 }
6849 {
6850 if (!wxPyCheckForApp()) SWIG_fail;
6851 PyThreadState* __tstate = wxPyBeginAllowThreads();
6852 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1,(wxColour const &)*arg2,arg3);
6853
6854 wxPyEndAllowThreads(__tstate);
6855 if (PyErr_Occurred()) SWIG_fail;
6856 }
6857 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6858 return resultobj;
6859 fail:
6860 return NULL;
6861 }
6862
6863
6864 static PyObject *_wrap_new_RegionFromPoints(PyObject *, PyObject *args, PyObject *kwargs) {
6865 PyObject *resultobj;
6866 int arg1 ;
6867 wxPoint *arg2 = (wxPoint *) 0 ;
6868 int arg3 = (int) wxWINDING_RULE ;
6869 wxRegion *result;
6870 PyObject * obj0 = 0 ;
6871 PyObject * obj1 = 0 ;
6872 char *kwnames[] = {
6873 (char *) "points",(char *) "fillStyle", NULL
6874 };
6875
6876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_RegionFromPoints",kwnames,&obj0,&obj1)) goto fail;
6877 {
6878 arg2 = wxPoint_LIST_helper(obj0, &arg1);
6879 if (arg2 == NULL) SWIG_fail;
6880 }
6881 if (obj1) {
6882 {
6883 arg3 = (int)(SWIG_As_int(obj1));
6884 if (SWIG_arg_fail(3)) SWIG_fail;
6885 }
6886 }
6887 {
6888 if (!wxPyCheckForApp()) SWIG_fail;
6889 PyThreadState* __tstate = wxPyBeginAllowThreads();
6890 result = (wxRegion *)new wxRegion(arg1,arg2,arg3);
6891
6892 wxPyEndAllowThreads(__tstate);
6893 if (PyErr_Occurred()) SWIG_fail;
6894 }
6895 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6896 {
6897 if (arg2) delete [] arg2;
6898 }
6899 return resultobj;
6900 fail:
6901 {
6902 if (arg2) delete [] arg2;
6903 }
6904 return NULL;
6905 }
6906
6907
6908 static PyObject *_wrap_delete_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6909 PyObject *resultobj;
6910 wxRegion *arg1 = (wxRegion *) 0 ;
6911 PyObject * obj0 = 0 ;
6912 char *kwnames[] = {
6913 (char *) "self", NULL
6914 };
6915
6916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Region",kwnames,&obj0)) goto fail;
6917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6918 if (SWIG_arg_fail(1)) SWIG_fail;
6919 {
6920 PyThreadState* __tstate = wxPyBeginAllowThreads();
6921 delete arg1;
6922
6923 wxPyEndAllowThreads(__tstate);
6924 if (PyErr_Occurred()) SWIG_fail;
6925 }
6926 Py_INCREF(Py_None); resultobj = Py_None;
6927 return resultobj;
6928 fail:
6929 return NULL;
6930 }
6931
6932
6933 static PyObject *_wrap_Region_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
6934 PyObject *resultobj;
6935 wxRegion *arg1 = (wxRegion *) 0 ;
6936 PyObject * obj0 = 0 ;
6937 char *kwnames[] = {
6938 (char *) "self", NULL
6939 };
6940
6941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_Clear",kwnames,&obj0)) goto fail;
6942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6943 if (SWIG_arg_fail(1)) SWIG_fail;
6944 {
6945 PyThreadState* __tstate = wxPyBeginAllowThreads();
6946 (arg1)->Clear();
6947
6948 wxPyEndAllowThreads(__tstate);
6949 if (PyErr_Occurred()) SWIG_fail;
6950 }
6951 Py_INCREF(Py_None); resultobj = Py_None;
6952 return resultobj;
6953 fail:
6954 return NULL;
6955 }
6956
6957
6958 static PyObject *_wrap_Region_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
6959 PyObject *resultobj;
6960 wxRegion *arg1 = (wxRegion *) 0 ;
6961 int arg2 ;
6962 int arg3 ;
6963 bool result;
6964 PyObject * obj0 = 0 ;
6965 PyObject * obj1 = 0 ;
6966 PyObject * obj2 = 0 ;
6967 char *kwnames[] = {
6968 (char *) "self",(char *) "x",(char *) "y", NULL
6969 };
6970
6971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Offset",kwnames,&obj0,&obj1,&obj2)) goto fail;
6972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6973 if (SWIG_arg_fail(1)) SWIG_fail;
6974 {
6975 arg2 = (int)(SWIG_As_int(obj1));
6976 if (SWIG_arg_fail(2)) SWIG_fail;
6977 }
6978 {
6979 arg3 = (int)(SWIG_As_int(obj2));
6980 if (SWIG_arg_fail(3)) SWIG_fail;
6981 }
6982 {
6983 PyThreadState* __tstate = wxPyBeginAllowThreads();
6984 result = (bool)(arg1)->Offset(arg2,arg3);
6985
6986 wxPyEndAllowThreads(__tstate);
6987 if (PyErr_Occurred()) SWIG_fail;
6988 }
6989 {
6990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6991 }
6992 return resultobj;
6993 fail:
6994 return NULL;
6995 }
6996
6997
6998 static PyObject *_wrap_Region_Contains(PyObject *, PyObject *args, PyObject *kwargs) {
6999 PyObject *resultobj;
7000 wxRegion *arg1 = (wxRegion *) 0 ;
7001 int arg2 ;
7002 int arg3 ;
7003 wxRegionContain result;
7004 PyObject * obj0 = 0 ;
7005 PyObject * obj1 = 0 ;
7006 PyObject * obj2 = 0 ;
7007 char *kwnames[] = {
7008 (char *) "self",(char *) "x",(char *) "y", NULL
7009 };
7010
7011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Contains",kwnames,&obj0,&obj1,&obj2)) goto fail;
7012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7013 if (SWIG_arg_fail(1)) SWIG_fail;
7014 {
7015 arg2 = (int)(SWIG_As_int(obj1));
7016 if (SWIG_arg_fail(2)) SWIG_fail;
7017 }
7018 {
7019 arg3 = (int)(SWIG_As_int(obj2));
7020 if (SWIG_arg_fail(3)) SWIG_fail;
7021 }
7022 {
7023 PyThreadState* __tstate = wxPyBeginAllowThreads();
7024 result = (wxRegionContain)(arg1)->Contains(arg2,arg3);
7025
7026 wxPyEndAllowThreads(__tstate);
7027 if (PyErr_Occurred()) SWIG_fail;
7028 }
7029 resultobj = SWIG_From_int((result));
7030 return resultobj;
7031 fail:
7032 return NULL;
7033 }
7034
7035
7036 static PyObject *_wrap_Region_ContainsPoint(PyObject *, PyObject *args, PyObject *kwargs) {
7037 PyObject *resultobj;
7038 wxRegion *arg1 = (wxRegion *) 0 ;
7039 wxPoint *arg2 = 0 ;
7040 wxRegionContain result;
7041 wxPoint temp2 ;
7042 PyObject * obj0 = 0 ;
7043 PyObject * obj1 = 0 ;
7044 char *kwnames[] = {
7045 (char *) "self",(char *) "pt", NULL
7046 };
7047
7048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsPoint",kwnames,&obj0,&obj1)) goto fail;
7049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7050 if (SWIG_arg_fail(1)) SWIG_fail;
7051 {
7052 arg2 = &temp2;
7053 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7054 }
7055 {
7056 PyThreadState* __tstate = wxPyBeginAllowThreads();
7057 result = (wxRegionContain)(arg1)->Contains((wxPoint const &)*arg2);
7058
7059 wxPyEndAllowThreads(__tstate);
7060 if (PyErr_Occurred()) SWIG_fail;
7061 }
7062 resultobj = SWIG_From_int((result));
7063 return resultobj;
7064 fail:
7065 return NULL;
7066 }
7067
7068
7069 static PyObject *_wrap_Region_ContainsRect(PyObject *, PyObject *args, PyObject *kwargs) {
7070 PyObject *resultobj;
7071 wxRegion *arg1 = (wxRegion *) 0 ;
7072 wxRect *arg2 = 0 ;
7073 wxRegionContain result;
7074 wxRect temp2 ;
7075 PyObject * obj0 = 0 ;
7076 PyObject * obj1 = 0 ;
7077 char *kwnames[] = {
7078 (char *) "self",(char *) "rect", NULL
7079 };
7080
7081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsRect",kwnames,&obj0,&obj1)) goto fail;
7082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7083 if (SWIG_arg_fail(1)) SWIG_fail;
7084 {
7085 arg2 = &temp2;
7086 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7087 }
7088 {
7089 PyThreadState* __tstate = wxPyBeginAllowThreads();
7090 result = (wxRegionContain)(arg1)->Contains((wxRect const &)*arg2);
7091
7092 wxPyEndAllowThreads(__tstate);
7093 if (PyErr_Occurred()) SWIG_fail;
7094 }
7095 resultobj = SWIG_From_int((result));
7096 return resultobj;
7097 fail:
7098 return NULL;
7099 }
7100
7101
7102 static PyObject *_wrap_Region_ContainsRectDim(PyObject *, PyObject *args, PyObject *kwargs) {
7103 PyObject *resultobj;
7104 wxRegion *arg1 = (wxRegion *) 0 ;
7105 int arg2 ;
7106 int arg3 ;
7107 int arg4 ;
7108 int arg5 ;
7109 wxRegionContain result;
7110 PyObject * obj0 = 0 ;
7111 PyObject * obj1 = 0 ;
7112 PyObject * obj2 = 0 ;
7113 PyObject * obj3 = 0 ;
7114 PyObject * obj4 = 0 ;
7115 char *kwnames[] = {
7116 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
7117 };
7118
7119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_ContainsRectDim",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7121 if (SWIG_arg_fail(1)) SWIG_fail;
7122 {
7123 arg2 = (int)(SWIG_As_int(obj1));
7124 if (SWIG_arg_fail(2)) SWIG_fail;
7125 }
7126 {
7127 arg3 = (int)(SWIG_As_int(obj2));
7128 if (SWIG_arg_fail(3)) SWIG_fail;
7129 }
7130 {
7131 arg4 = (int)(SWIG_As_int(obj3));
7132 if (SWIG_arg_fail(4)) SWIG_fail;
7133 }
7134 {
7135 arg5 = (int)(SWIG_As_int(obj4));
7136 if (SWIG_arg_fail(5)) SWIG_fail;
7137 }
7138 {
7139 PyThreadState* __tstate = wxPyBeginAllowThreads();
7140 result = (wxRegionContain)(arg1)->Contains(arg2,arg3,arg4,arg5);
7141
7142 wxPyEndAllowThreads(__tstate);
7143 if (PyErr_Occurred()) SWIG_fail;
7144 }
7145 resultobj = SWIG_From_int((result));
7146 return resultobj;
7147 fail:
7148 return NULL;
7149 }
7150
7151
7152 static PyObject *_wrap_Region_GetBox(PyObject *, PyObject *args, PyObject *kwargs) {
7153 PyObject *resultobj;
7154 wxRegion *arg1 = (wxRegion *) 0 ;
7155 wxRect result;
7156 PyObject * obj0 = 0 ;
7157 char *kwnames[] = {
7158 (char *) "self", NULL
7159 };
7160
7161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_GetBox",kwnames,&obj0)) goto fail;
7162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7163 if (SWIG_arg_fail(1)) SWIG_fail;
7164 {
7165 PyThreadState* __tstate = wxPyBeginAllowThreads();
7166 result = (arg1)->GetBox();
7167
7168 wxPyEndAllowThreads(__tstate);
7169 if (PyErr_Occurred()) SWIG_fail;
7170 }
7171 {
7172 wxRect * resultptr;
7173 resultptr = new wxRect((wxRect &)(result));
7174 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
7175 }
7176 return resultobj;
7177 fail:
7178 return NULL;
7179 }
7180
7181
7182 static PyObject *_wrap_Region_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
7183 PyObject *resultobj;
7184 wxRegion *arg1 = (wxRegion *) 0 ;
7185 int arg2 ;
7186 int arg3 ;
7187 int arg4 ;
7188 int arg5 ;
7189 bool result;
7190 PyObject * obj0 = 0 ;
7191 PyObject * obj1 = 0 ;
7192 PyObject * obj2 = 0 ;
7193 PyObject * obj3 = 0 ;
7194 PyObject * obj4 = 0 ;
7195 char *kwnames[] = {
7196 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7197 };
7198
7199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Intersect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7201 if (SWIG_arg_fail(1)) SWIG_fail;
7202 {
7203 arg2 = (int)(SWIG_As_int(obj1));
7204 if (SWIG_arg_fail(2)) SWIG_fail;
7205 }
7206 {
7207 arg3 = (int)(SWIG_As_int(obj2));
7208 if (SWIG_arg_fail(3)) SWIG_fail;
7209 }
7210 {
7211 arg4 = (int)(SWIG_As_int(obj3));
7212 if (SWIG_arg_fail(4)) SWIG_fail;
7213 }
7214 {
7215 arg5 = (int)(SWIG_As_int(obj4));
7216 if (SWIG_arg_fail(5)) SWIG_fail;
7217 }
7218 {
7219 PyThreadState* __tstate = wxPyBeginAllowThreads();
7220 result = (bool)(arg1)->Intersect(arg2,arg3,arg4,arg5);
7221
7222 wxPyEndAllowThreads(__tstate);
7223 if (PyErr_Occurred()) SWIG_fail;
7224 }
7225 {
7226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7227 }
7228 return resultobj;
7229 fail:
7230 return NULL;
7231 }
7232
7233
7234 static PyObject *_wrap_Region_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
7235 PyObject *resultobj;
7236 wxRegion *arg1 = (wxRegion *) 0 ;
7237 wxRect *arg2 = 0 ;
7238 bool result;
7239 wxRect temp2 ;
7240 PyObject * obj0 = 0 ;
7241 PyObject * obj1 = 0 ;
7242 char *kwnames[] = {
7243 (char *) "self",(char *) "rect", NULL
7244 };
7245
7246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRect",kwnames,&obj0,&obj1)) goto fail;
7247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7248 if (SWIG_arg_fail(1)) SWIG_fail;
7249 {
7250 arg2 = &temp2;
7251 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7252 }
7253 {
7254 PyThreadState* __tstate = wxPyBeginAllowThreads();
7255 result = (bool)(arg1)->Intersect((wxRect const &)*arg2);
7256
7257 wxPyEndAllowThreads(__tstate);
7258 if (PyErr_Occurred()) SWIG_fail;
7259 }
7260 {
7261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7262 }
7263 return resultobj;
7264 fail:
7265 return NULL;
7266 }
7267
7268
7269 static PyObject *_wrap_Region_IntersectRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7270 PyObject *resultobj;
7271 wxRegion *arg1 = (wxRegion *) 0 ;
7272 wxRegion *arg2 = 0 ;
7273 bool result;
7274 PyObject * obj0 = 0 ;
7275 PyObject * obj1 = 0 ;
7276 char *kwnames[] = {
7277 (char *) "self",(char *) "region", NULL
7278 };
7279
7280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRegion",kwnames,&obj0,&obj1)) goto fail;
7281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7282 if (SWIG_arg_fail(1)) SWIG_fail;
7283 {
7284 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7285 if (SWIG_arg_fail(2)) SWIG_fail;
7286 if (arg2 == NULL) {
7287 SWIG_null_ref("wxRegion");
7288 }
7289 if (SWIG_arg_fail(2)) SWIG_fail;
7290 }
7291 {
7292 PyThreadState* __tstate = wxPyBeginAllowThreads();
7293 result = (bool)(arg1)->Intersect((wxRegion const &)*arg2);
7294
7295 wxPyEndAllowThreads(__tstate);
7296 if (PyErr_Occurred()) SWIG_fail;
7297 }
7298 {
7299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7300 }
7301 return resultobj;
7302 fail:
7303 return NULL;
7304 }
7305
7306
7307 static PyObject *_wrap_Region_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
7308 PyObject *resultobj;
7309 wxRegion *arg1 = (wxRegion *) 0 ;
7310 bool result;
7311 PyObject * obj0 = 0 ;
7312 char *kwnames[] = {
7313 (char *) "self", NULL
7314 };
7315
7316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_IsEmpty",kwnames,&obj0)) goto fail;
7317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7318 if (SWIG_arg_fail(1)) SWIG_fail;
7319 {
7320 PyThreadState* __tstate = wxPyBeginAllowThreads();
7321 result = (bool)(arg1)->IsEmpty();
7322
7323 wxPyEndAllowThreads(__tstate);
7324 if (PyErr_Occurred()) SWIG_fail;
7325 }
7326 {
7327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7328 }
7329 return resultobj;
7330 fail:
7331 return NULL;
7332 }
7333
7334
7335 static PyObject *_wrap_Region_Union(PyObject *, PyObject *args, PyObject *kwargs) {
7336 PyObject *resultobj;
7337 wxRegion *arg1 = (wxRegion *) 0 ;
7338 int arg2 ;
7339 int arg3 ;
7340 int arg4 ;
7341 int arg5 ;
7342 bool result;
7343 PyObject * obj0 = 0 ;
7344 PyObject * obj1 = 0 ;
7345 PyObject * obj2 = 0 ;
7346 PyObject * obj3 = 0 ;
7347 PyObject * obj4 = 0 ;
7348 char *kwnames[] = {
7349 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7350 };
7351
7352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Union",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7354 if (SWIG_arg_fail(1)) SWIG_fail;
7355 {
7356 arg2 = (int)(SWIG_As_int(obj1));
7357 if (SWIG_arg_fail(2)) SWIG_fail;
7358 }
7359 {
7360 arg3 = (int)(SWIG_As_int(obj2));
7361 if (SWIG_arg_fail(3)) SWIG_fail;
7362 }
7363 {
7364 arg4 = (int)(SWIG_As_int(obj3));
7365 if (SWIG_arg_fail(4)) SWIG_fail;
7366 }
7367 {
7368 arg5 = (int)(SWIG_As_int(obj4));
7369 if (SWIG_arg_fail(5)) SWIG_fail;
7370 }
7371 {
7372 PyThreadState* __tstate = wxPyBeginAllowThreads();
7373 result = (bool)(arg1)->Union(arg2,arg3,arg4,arg5);
7374
7375 wxPyEndAllowThreads(__tstate);
7376 if (PyErr_Occurred()) SWIG_fail;
7377 }
7378 {
7379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7380 }
7381 return resultobj;
7382 fail:
7383 return NULL;
7384 }
7385
7386
7387 static PyObject *_wrap_Region_UnionRect(PyObject *, PyObject *args, PyObject *kwargs) {
7388 PyObject *resultobj;
7389 wxRegion *arg1 = (wxRegion *) 0 ;
7390 wxRect *arg2 = 0 ;
7391 bool result;
7392 wxRect temp2 ;
7393 PyObject * obj0 = 0 ;
7394 PyObject * obj1 = 0 ;
7395 char *kwnames[] = {
7396 (char *) "self",(char *) "rect", NULL
7397 };
7398
7399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRect",kwnames,&obj0,&obj1)) goto fail;
7400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7401 if (SWIG_arg_fail(1)) SWIG_fail;
7402 {
7403 arg2 = &temp2;
7404 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7405 }
7406 {
7407 PyThreadState* __tstate = wxPyBeginAllowThreads();
7408 result = (bool)(arg1)->Union((wxRect const &)*arg2);
7409
7410 wxPyEndAllowThreads(__tstate);
7411 if (PyErr_Occurred()) SWIG_fail;
7412 }
7413 {
7414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7415 }
7416 return resultobj;
7417 fail:
7418 return NULL;
7419 }
7420
7421
7422 static PyObject *_wrap_Region_UnionRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7423 PyObject *resultobj;
7424 wxRegion *arg1 = (wxRegion *) 0 ;
7425 wxRegion *arg2 = 0 ;
7426 bool result;
7427 PyObject * obj0 = 0 ;
7428 PyObject * obj1 = 0 ;
7429 char *kwnames[] = {
7430 (char *) "self",(char *) "region", NULL
7431 };
7432
7433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRegion",kwnames,&obj0,&obj1)) goto fail;
7434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7435 if (SWIG_arg_fail(1)) SWIG_fail;
7436 {
7437 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7438 if (SWIG_arg_fail(2)) SWIG_fail;
7439 if (arg2 == NULL) {
7440 SWIG_null_ref("wxRegion");
7441 }
7442 if (SWIG_arg_fail(2)) SWIG_fail;
7443 }
7444 {
7445 PyThreadState* __tstate = wxPyBeginAllowThreads();
7446 result = (bool)(arg1)->Union((wxRegion const &)*arg2);
7447
7448 wxPyEndAllowThreads(__tstate);
7449 if (PyErr_Occurred()) SWIG_fail;
7450 }
7451 {
7452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7453 }
7454 return resultobj;
7455 fail:
7456 return NULL;
7457 }
7458
7459
7460 static PyObject *_wrap_Region_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
7461 PyObject *resultobj;
7462 wxRegion *arg1 = (wxRegion *) 0 ;
7463 int arg2 ;
7464 int arg3 ;
7465 int arg4 ;
7466 int arg5 ;
7467 bool result;
7468 PyObject * obj0 = 0 ;
7469 PyObject * obj1 = 0 ;
7470 PyObject * obj2 = 0 ;
7471 PyObject * obj3 = 0 ;
7472 PyObject * obj4 = 0 ;
7473 char *kwnames[] = {
7474 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7475 };
7476
7477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Subtract",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7479 if (SWIG_arg_fail(1)) SWIG_fail;
7480 {
7481 arg2 = (int)(SWIG_As_int(obj1));
7482 if (SWIG_arg_fail(2)) SWIG_fail;
7483 }
7484 {
7485 arg3 = (int)(SWIG_As_int(obj2));
7486 if (SWIG_arg_fail(3)) SWIG_fail;
7487 }
7488 {
7489 arg4 = (int)(SWIG_As_int(obj3));
7490 if (SWIG_arg_fail(4)) SWIG_fail;
7491 }
7492 {
7493 arg5 = (int)(SWIG_As_int(obj4));
7494 if (SWIG_arg_fail(5)) SWIG_fail;
7495 }
7496 {
7497 PyThreadState* __tstate = wxPyBeginAllowThreads();
7498 result = (bool)(arg1)->Subtract(arg2,arg3,arg4,arg5);
7499
7500 wxPyEndAllowThreads(__tstate);
7501 if (PyErr_Occurred()) SWIG_fail;
7502 }
7503 {
7504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7505 }
7506 return resultobj;
7507 fail:
7508 return NULL;
7509 }
7510
7511
7512 static PyObject *_wrap_Region_SubtractRect(PyObject *, PyObject *args, PyObject *kwargs) {
7513 PyObject *resultobj;
7514 wxRegion *arg1 = (wxRegion *) 0 ;
7515 wxRect *arg2 = 0 ;
7516 bool result;
7517 wxRect temp2 ;
7518 PyObject * obj0 = 0 ;
7519 PyObject * obj1 = 0 ;
7520 char *kwnames[] = {
7521 (char *) "self",(char *) "rect", NULL
7522 };
7523
7524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRect",kwnames,&obj0,&obj1)) goto fail;
7525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7526 if (SWIG_arg_fail(1)) SWIG_fail;
7527 {
7528 arg2 = &temp2;
7529 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7530 }
7531 {
7532 PyThreadState* __tstate = wxPyBeginAllowThreads();
7533 result = (bool)(arg1)->Subtract((wxRect const &)*arg2);
7534
7535 wxPyEndAllowThreads(__tstate);
7536 if (PyErr_Occurred()) SWIG_fail;
7537 }
7538 {
7539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7540 }
7541 return resultobj;
7542 fail:
7543 return NULL;
7544 }
7545
7546
7547 static PyObject *_wrap_Region_SubtractRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7548 PyObject *resultobj;
7549 wxRegion *arg1 = (wxRegion *) 0 ;
7550 wxRegion *arg2 = 0 ;
7551 bool result;
7552 PyObject * obj0 = 0 ;
7553 PyObject * obj1 = 0 ;
7554 char *kwnames[] = {
7555 (char *) "self",(char *) "region", NULL
7556 };
7557
7558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRegion",kwnames,&obj0,&obj1)) goto fail;
7559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7560 if (SWIG_arg_fail(1)) SWIG_fail;
7561 {
7562 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7563 if (SWIG_arg_fail(2)) SWIG_fail;
7564 if (arg2 == NULL) {
7565 SWIG_null_ref("wxRegion");
7566 }
7567 if (SWIG_arg_fail(2)) SWIG_fail;
7568 }
7569 {
7570 PyThreadState* __tstate = wxPyBeginAllowThreads();
7571 result = (bool)(arg1)->Subtract((wxRegion const &)*arg2);
7572
7573 wxPyEndAllowThreads(__tstate);
7574 if (PyErr_Occurred()) SWIG_fail;
7575 }
7576 {
7577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7578 }
7579 return resultobj;
7580 fail:
7581 return NULL;
7582 }
7583
7584
7585 static PyObject *_wrap_Region_Xor(PyObject *, PyObject *args, PyObject *kwargs) {
7586 PyObject *resultobj;
7587 wxRegion *arg1 = (wxRegion *) 0 ;
7588 int arg2 ;
7589 int arg3 ;
7590 int arg4 ;
7591 int arg5 ;
7592 bool result;
7593 PyObject * obj0 = 0 ;
7594 PyObject * obj1 = 0 ;
7595 PyObject * obj2 = 0 ;
7596 PyObject * obj3 = 0 ;
7597 PyObject * obj4 = 0 ;
7598 char *kwnames[] = {
7599 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7600 };
7601
7602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Xor",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7604 if (SWIG_arg_fail(1)) SWIG_fail;
7605 {
7606 arg2 = (int)(SWIG_As_int(obj1));
7607 if (SWIG_arg_fail(2)) SWIG_fail;
7608 }
7609 {
7610 arg3 = (int)(SWIG_As_int(obj2));
7611 if (SWIG_arg_fail(3)) SWIG_fail;
7612 }
7613 {
7614 arg4 = (int)(SWIG_As_int(obj3));
7615 if (SWIG_arg_fail(4)) SWIG_fail;
7616 }
7617 {
7618 arg5 = (int)(SWIG_As_int(obj4));
7619 if (SWIG_arg_fail(5)) SWIG_fail;
7620 }
7621 {
7622 PyThreadState* __tstate = wxPyBeginAllowThreads();
7623 result = (bool)(arg1)->Xor(arg2,arg3,arg4,arg5);
7624
7625 wxPyEndAllowThreads(__tstate);
7626 if (PyErr_Occurred()) SWIG_fail;
7627 }
7628 {
7629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7630 }
7631 return resultobj;
7632 fail:
7633 return NULL;
7634 }
7635
7636
7637 static PyObject *_wrap_Region_XorRect(PyObject *, PyObject *args, PyObject *kwargs) {
7638 PyObject *resultobj;
7639 wxRegion *arg1 = (wxRegion *) 0 ;
7640 wxRect *arg2 = 0 ;
7641 bool result;
7642 wxRect temp2 ;
7643 PyObject * obj0 = 0 ;
7644 PyObject * obj1 = 0 ;
7645 char *kwnames[] = {
7646 (char *) "self",(char *) "rect", NULL
7647 };
7648
7649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRect",kwnames,&obj0,&obj1)) goto fail;
7650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7651 if (SWIG_arg_fail(1)) SWIG_fail;
7652 {
7653 arg2 = &temp2;
7654 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7655 }
7656 {
7657 PyThreadState* __tstate = wxPyBeginAllowThreads();
7658 result = (bool)(arg1)->Xor((wxRect const &)*arg2);
7659
7660 wxPyEndAllowThreads(__tstate);
7661 if (PyErr_Occurred()) SWIG_fail;
7662 }
7663 {
7664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7665 }
7666 return resultobj;
7667 fail:
7668 return NULL;
7669 }
7670
7671
7672 static PyObject *_wrap_Region_XorRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7673 PyObject *resultobj;
7674 wxRegion *arg1 = (wxRegion *) 0 ;
7675 wxRegion *arg2 = 0 ;
7676 bool result;
7677 PyObject * obj0 = 0 ;
7678 PyObject * obj1 = 0 ;
7679 char *kwnames[] = {
7680 (char *) "self",(char *) "region", NULL
7681 };
7682
7683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRegion",kwnames,&obj0,&obj1)) goto fail;
7684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7685 if (SWIG_arg_fail(1)) SWIG_fail;
7686 {
7687 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7688 if (SWIG_arg_fail(2)) SWIG_fail;
7689 if (arg2 == NULL) {
7690 SWIG_null_ref("wxRegion");
7691 }
7692 if (SWIG_arg_fail(2)) SWIG_fail;
7693 }
7694 {
7695 PyThreadState* __tstate = wxPyBeginAllowThreads();
7696 result = (bool)(arg1)->Xor((wxRegion const &)*arg2);
7697
7698 wxPyEndAllowThreads(__tstate);
7699 if (PyErr_Occurred()) SWIG_fail;
7700 }
7701 {
7702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7703 }
7704 return resultobj;
7705 fail:
7706 return NULL;
7707 }
7708
7709
7710 static PyObject *_wrap_Region_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7711 PyObject *resultobj;
7712 wxRegion *arg1 = (wxRegion *) 0 ;
7713 SwigValueWrapper<wxBitmap > result;
7714 PyObject * obj0 = 0 ;
7715 char *kwnames[] = {
7716 (char *) "self", NULL
7717 };
7718
7719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_ConvertToBitmap",kwnames,&obj0)) goto fail;
7720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7721 if (SWIG_arg_fail(1)) SWIG_fail;
7722 {
7723 PyThreadState* __tstate = wxPyBeginAllowThreads();
7724 result = (arg1)->ConvertToBitmap();
7725
7726 wxPyEndAllowThreads(__tstate);
7727 if (PyErr_Occurred()) SWIG_fail;
7728 }
7729 {
7730 wxBitmap * resultptr;
7731 resultptr = new wxBitmap((wxBitmap &)(result));
7732 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
7733 }
7734 return resultobj;
7735 fail:
7736 return NULL;
7737 }
7738
7739
7740 static PyObject *_wrap_Region_UnionBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7741 PyObject *resultobj;
7742 wxRegion *arg1 = (wxRegion *) 0 ;
7743 wxBitmap *arg2 = 0 ;
7744 bool result;
7745 PyObject * obj0 = 0 ;
7746 PyObject * obj1 = 0 ;
7747 char *kwnames[] = {
7748 (char *) "self",(char *) "bmp", NULL
7749 };
7750
7751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionBitmap",kwnames,&obj0,&obj1)) goto fail;
7752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7753 if (SWIG_arg_fail(1)) SWIG_fail;
7754 {
7755 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7756 if (SWIG_arg_fail(2)) SWIG_fail;
7757 if (arg2 == NULL) {
7758 SWIG_null_ref("wxBitmap");
7759 }
7760 if (SWIG_arg_fail(2)) SWIG_fail;
7761 }
7762 {
7763 PyThreadState* __tstate = wxPyBeginAllowThreads();
7764 result = (bool)(arg1)->Union((wxBitmap const &)*arg2);
7765
7766 wxPyEndAllowThreads(__tstate);
7767 if (PyErr_Occurred()) SWIG_fail;
7768 }
7769 {
7770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7771 }
7772 return resultobj;
7773 fail:
7774 return NULL;
7775 }
7776
7777
7778 static PyObject *_wrap_Region_UnionBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
7779 PyObject *resultobj;
7780 wxRegion *arg1 = (wxRegion *) 0 ;
7781 wxBitmap *arg2 = 0 ;
7782 wxColour *arg3 = 0 ;
7783 int arg4 = (int) 0 ;
7784 bool result;
7785 wxColour temp3 ;
7786 PyObject * obj0 = 0 ;
7787 PyObject * obj1 = 0 ;
7788 PyObject * obj2 = 0 ;
7789 PyObject * obj3 = 0 ;
7790 char *kwnames[] = {
7791 (char *) "self",(char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
7792 };
7793
7794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Region_UnionBitmapColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7796 if (SWIG_arg_fail(1)) SWIG_fail;
7797 {
7798 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7799 if (SWIG_arg_fail(2)) SWIG_fail;
7800 if (arg2 == NULL) {
7801 SWIG_null_ref("wxBitmap");
7802 }
7803 if (SWIG_arg_fail(2)) SWIG_fail;
7804 }
7805 {
7806 arg3 = &temp3;
7807 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
7808 }
7809 if (obj3) {
7810 {
7811 arg4 = (int)(SWIG_As_int(obj3));
7812 if (SWIG_arg_fail(4)) SWIG_fail;
7813 }
7814 }
7815 {
7816 PyThreadState* __tstate = wxPyBeginAllowThreads();
7817 result = (bool)(arg1)->Union((wxBitmap const &)*arg2,(wxColour const &)*arg3,arg4);
7818
7819 wxPyEndAllowThreads(__tstate);
7820 if (PyErr_Occurred()) SWIG_fail;
7821 }
7822 {
7823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7824 }
7825 return resultobj;
7826 fail:
7827 return NULL;
7828 }
7829
7830
7831 static PyObject * Region_swigregister(PyObject *, PyObject *args) {
7832 PyObject *obj;
7833 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7834 SWIG_TypeClientData(SWIGTYPE_p_wxRegion, obj);
7835 Py_INCREF(obj);
7836 return Py_BuildValue((char *)"");
7837 }
7838 static PyObject *_wrap_new_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7839 PyObject *resultobj;
7840 wxRegion *arg1 = 0 ;
7841 wxRegionIterator *result;
7842 PyObject * obj0 = 0 ;
7843 char *kwnames[] = {
7844 (char *) "region", NULL
7845 };
7846
7847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionIterator",kwnames,&obj0)) goto fail;
7848 {
7849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7850 if (SWIG_arg_fail(1)) SWIG_fail;
7851 if (arg1 == NULL) {
7852 SWIG_null_ref("wxRegion");
7853 }
7854 if (SWIG_arg_fail(1)) SWIG_fail;
7855 }
7856 {
7857 if (!wxPyCheckForApp()) SWIG_fail;
7858 PyThreadState* __tstate = wxPyBeginAllowThreads();
7859 result = (wxRegionIterator *)new wxRegionIterator((wxRegion const &)*arg1);
7860
7861 wxPyEndAllowThreads(__tstate);
7862 if (PyErr_Occurred()) SWIG_fail;
7863 }
7864 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegionIterator, 1);
7865 return resultobj;
7866 fail:
7867 return NULL;
7868 }
7869
7870
7871 static PyObject *_wrap_delete_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7872 PyObject *resultobj;
7873 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7874 PyObject * obj0 = 0 ;
7875 char *kwnames[] = {
7876 (char *) "self", NULL
7877 };
7878
7879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RegionIterator",kwnames,&obj0)) goto fail;
7880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7881 if (SWIG_arg_fail(1)) SWIG_fail;
7882 {
7883 PyThreadState* __tstate = wxPyBeginAllowThreads();
7884 delete arg1;
7885
7886 wxPyEndAllowThreads(__tstate);
7887 if (PyErr_Occurred()) SWIG_fail;
7888 }
7889 Py_INCREF(Py_None); resultobj = Py_None;
7890 return resultobj;
7891 fail:
7892 return NULL;
7893 }
7894
7895
7896 static PyObject *_wrap_RegionIterator_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
7897 PyObject *resultobj;
7898 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7899 int result;
7900 PyObject * obj0 = 0 ;
7901 char *kwnames[] = {
7902 (char *) "self", NULL
7903 };
7904
7905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetX",kwnames,&obj0)) goto fail;
7906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7907 if (SWIG_arg_fail(1)) SWIG_fail;
7908 {
7909 PyThreadState* __tstate = wxPyBeginAllowThreads();
7910 result = (int)(arg1)->GetX();
7911
7912 wxPyEndAllowThreads(__tstate);
7913 if (PyErr_Occurred()) SWIG_fail;
7914 }
7915 {
7916 resultobj = SWIG_From_int((int)(result));
7917 }
7918 return resultobj;
7919 fail:
7920 return NULL;
7921 }
7922
7923
7924 static PyObject *_wrap_RegionIterator_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
7925 PyObject *resultobj;
7926 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7927 int result;
7928 PyObject * obj0 = 0 ;
7929 char *kwnames[] = {
7930 (char *) "self", NULL
7931 };
7932
7933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetY",kwnames,&obj0)) goto fail;
7934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7935 if (SWIG_arg_fail(1)) SWIG_fail;
7936 {
7937 PyThreadState* __tstate = wxPyBeginAllowThreads();
7938 result = (int)(arg1)->GetY();
7939
7940 wxPyEndAllowThreads(__tstate);
7941 if (PyErr_Occurred()) SWIG_fail;
7942 }
7943 {
7944 resultobj = SWIG_From_int((int)(result));
7945 }
7946 return resultobj;
7947 fail:
7948 return NULL;
7949 }
7950
7951
7952 static PyObject *_wrap_RegionIterator_GetW(PyObject *, PyObject *args, PyObject *kwargs) {
7953 PyObject *resultobj;
7954 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7955 int result;
7956 PyObject * obj0 = 0 ;
7957 char *kwnames[] = {
7958 (char *) "self", NULL
7959 };
7960
7961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetW",kwnames,&obj0)) goto fail;
7962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7963 if (SWIG_arg_fail(1)) SWIG_fail;
7964 {
7965 PyThreadState* __tstate = wxPyBeginAllowThreads();
7966 result = (int)(arg1)->GetW();
7967
7968 wxPyEndAllowThreads(__tstate);
7969 if (PyErr_Occurred()) SWIG_fail;
7970 }
7971 {
7972 resultobj = SWIG_From_int((int)(result));
7973 }
7974 return resultobj;
7975 fail:
7976 return NULL;
7977 }
7978
7979
7980 static PyObject *_wrap_RegionIterator_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
7981 PyObject *resultobj;
7982 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7983 int result;
7984 PyObject * obj0 = 0 ;
7985 char *kwnames[] = {
7986 (char *) "self", NULL
7987 };
7988
7989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetWidth",kwnames,&obj0)) goto fail;
7990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7991 if (SWIG_arg_fail(1)) SWIG_fail;
7992 {
7993 PyThreadState* __tstate = wxPyBeginAllowThreads();
7994 result = (int)(arg1)->GetWidth();
7995
7996 wxPyEndAllowThreads(__tstate);
7997 if (PyErr_Occurred()) SWIG_fail;
7998 }
7999 {
8000 resultobj = SWIG_From_int((int)(result));
8001 }
8002 return resultobj;
8003 fail:
8004 return NULL;
8005 }
8006
8007
8008 static PyObject *_wrap_RegionIterator_GetH(PyObject *, PyObject *args, PyObject *kwargs) {
8009 PyObject *resultobj;
8010 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8011 int result;
8012 PyObject * obj0 = 0 ;
8013 char *kwnames[] = {
8014 (char *) "self", NULL
8015 };
8016
8017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetH",kwnames,&obj0)) goto fail;
8018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8019 if (SWIG_arg_fail(1)) SWIG_fail;
8020 {
8021 PyThreadState* __tstate = wxPyBeginAllowThreads();
8022 result = (int)(arg1)->GetH();
8023
8024 wxPyEndAllowThreads(__tstate);
8025 if (PyErr_Occurred()) SWIG_fail;
8026 }
8027 {
8028 resultobj = SWIG_From_int((int)(result));
8029 }
8030 return resultobj;
8031 fail:
8032 return NULL;
8033 }
8034
8035
8036 static PyObject *_wrap_RegionIterator_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
8037 PyObject *resultobj;
8038 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8039 int result;
8040 PyObject * obj0 = 0 ;
8041 char *kwnames[] = {
8042 (char *) "self", NULL
8043 };
8044
8045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetHeight",kwnames,&obj0)) goto fail;
8046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8047 if (SWIG_arg_fail(1)) SWIG_fail;
8048 {
8049 PyThreadState* __tstate = wxPyBeginAllowThreads();
8050 result = (int)(arg1)->GetHeight();
8051
8052 wxPyEndAllowThreads(__tstate);
8053 if (PyErr_Occurred()) SWIG_fail;
8054 }
8055 {
8056 resultobj = SWIG_From_int((int)(result));
8057 }
8058 return resultobj;
8059 fail:
8060 return NULL;
8061 }
8062
8063
8064 static PyObject *_wrap_RegionIterator_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
8065 PyObject *resultobj;
8066 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8067 wxRect result;
8068 PyObject * obj0 = 0 ;
8069 char *kwnames[] = {
8070 (char *) "self", NULL
8071 };
8072
8073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetRect",kwnames,&obj0)) goto fail;
8074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8075 if (SWIG_arg_fail(1)) SWIG_fail;
8076 {
8077 PyThreadState* __tstate = wxPyBeginAllowThreads();
8078 result = (arg1)->GetRect();
8079
8080 wxPyEndAllowThreads(__tstate);
8081 if (PyErr_Occurred()) SWIG_fail;
8082 }
8083 {
8084 wxRect * resultptr;
8085 resultptr = new wxRect((wxRect &)(result));
8086 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
8087 }
8088 return resultobj;
8089 fail:
8090 return NULL;
8091 }
8092
8093
8094 static PyObject *_wrap_RegionIterator_HaveRects(PyObject *, PyObject *args, PyObject *kwargs) {
8095 PyObject *resultobj;
8096 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8097 bool result;
8098 PyObject * obj0 = 0 ;
8099 char *kwnames[] = {
8100 (char *) "self", NULL
8101 };
8102
8103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_HaveRects",kwnames,&obj0)) goto fail;
8104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8105 if (SWIG_arg_fail(1)) SWIG_fail;
8106 {
8107 PyThreadState* __tstate = wxPyBeginAllowThreads();
8108 result = (bool)(arg1)->HaveRects();
8109
8110 wxPyEndAllowThreads(__tstate);
8111 if (PyErr_Occurred()) SWIG_fail;
8112 }
8113 {
8114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8115 }
8116 return resultobj;
8117 fail:
8118 return NULL;
8119 }
8120
8121
8122 static PyObject *_wrap_RegionIterator_Reset(PyObject *, PyObject *args, PyObject *kwargs) {
8123 PyObject *resultobj;
8124 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8125 PyObject * obj0 = 0 ;
8126 char *kwnames[] = {
8127 (char *) "self", NULL
8128 };
8129
8130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Reset",kwnames,&obj0)) goto fail;
8131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8132 if (SWIG_arg_fail(1)) SWIG_fail;
8133 {
8134 PyThreadState* __tstate = wxPyBeginAllowThreads();
8135 (arg1)->Reset();
8136
8137 wxPyEndAllowThreads(__tstate);
8138 if (PyErr_Occurred()) SWIG_fail;
8139 }
8140 Py_INCREF(Py_None); resultobj = Py_None;
8141 return resultobj;
8142 fail:
8143 return NULL;
8144 }
8145
8146
8147 static PyObject *_wrap_RegionIterator_Next(PyObject *, PyObject *args, PyObject *kwargs) {
8148 PyObject *resultobj;
8149 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8150 PyObject * obj0 = 0 ;
8151 char *kwnames[] = {
8152 (char *) "self", NULL
8153 };
8154
8155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Next",kwnames,&obj0)) goto fail;
8156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8157 if (SWIG_arg_fail(1)) SWIG_fail;
8158 {
8159 PyThreadState* __tstate = wxPyBeginAllowThreads();
8160 wxRegionIterator_Next(arg1);
8161
8162 wxPyEndAllowThreads(__tstate);
8163 if (PyErr_Occurred()) SWIG_fail;
8164 }
8165 Py_INCREF(Py_None); resultobj = Py_None;
8166 return resultobj;
8167 fail:
8168 return NULL;
8169 }
8170
8171
8172 static PyObject *_wrap_RegionIterator___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
8173 PyObject *resultobj;
8174 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8175 bool result;
8176 PyObject * obj0 = 0 ;
8177 char *kwnames[] = {
8178 (char *) "self", NULL
8179 };
8180
8181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator___nonzero__",kwnames,&obj0)) goto fail;
8182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8183 if (SWIG_arg_fail(1)) SWIG_fail;
8184 {
8185 PyThreadState* __tstate = wxPyBeginAllowThreads();
8186 result = (bool)wxRegionIterator___nonzero__(arg1);
8187
8188 wxPyEndAllowThreads(__tstate);
8189 if (PyErr_Occurred()) SWIG_fail;
8190 }
8191 {
8192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8193 }
8194 return resultobj;
8195 fail:
8196 return NULL;
8197 }
8198
8199
8200 static PyObject * RegionIterator_swigregister(PyObject *, PyObject *args) {
8201 PyObject *obj;
8202 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8203 SWIG_TypeClientData(SWIGTYPE_p_wxRegionIterator, obj);
8204 Py_INCREF(obj);
8205 return Py_BuildValue((char *)"");
8206 }
8207 static PyObject *_wrap_new_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8208 PyObject *resultobj;
8209 wxNativeFontInfo *result;
8210 char *kwnames[] = {
8211 NULL
8212 };
8213
8214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeFontInfo",kwnames)) goto fail;
8215 {
8216 PyThreadState* __tstate = wxPyBeginAllowThreads();
8217 result = (wxNativeFontInfo *)new wxNativeFontInfo();
8218
8219 wxPyEndAllowThreads(__tstate);
8220 if (PyErr_Occurred()) SWIG_fail;
8221 }
8222 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 1);
8223 return resultobj;
8224 fail:
8225 return NULL;
8226 }
8227
8228
8229 static PyObject *_wrap_delete_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8230 PyObject *resultobj;
8231 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8232 PyObject * obj0 = 0 ;
8233 char *kwnames[] = {
8234 (char *) "self", NULL
8235 };
8236
8237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeFontInfo",kwnames,&obj0)) goto fail;
8238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8239 if (SWIG_arg_fail(1)) SWIG_fail;
8240 {
8241 PyThreadState* __tstate = wxPyBeginAllowThreads();
8242 delete arg1;
8243
8244 wxPyEndAllowThreads(__tstate);
8245 if (PyErr_Occurred()) SWIG_fail;
8246 }
8247 Py_INCREF(Py_None); resultobj = Py_None;
8248 return resultobj;
8249 fail:
8250 return NULL;
8251 }
8252
8253
8254 static PyObject *_wrap_NativeFontInfo_Init(PyObject *, PyObject *args, PyObject *kwargs) {
8255 PyObject *resultobj;
8256 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8257 PyObject * obj0 = 0 ;
8258 char *kwnames[] = {
8259 (char *) "self", NULL
8260 };
8261
8262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_Init",kwnames,&obj0)) goto fail;
8263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8264 if (SWIG_arg_fail(1)) SWIG_fail;
8265 {
8266 PyThreadState* __tstate = wxPyBeginAllowThreads();
8267 (arg1)->Init();
8268
8269 wxPyEndAllowThreads(__tstate);
8270 if (PyErr_Occurred()) SWIG_fail;
8271 }
8272 Py_INCREF(Py_None); resultobj = Py_None;
8273 return resultobj;
8274 fail:
8275 return NULL;
8276 }
8277
8278
8279 static PyObject *_wrap_NativeFontInfo_InitFromFont(PyObject *, PyObject *args, PyObject *kwargs) {
8280 PyObject *resultobj;
8281 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8282 wxFont *arg2 = 0 ;
8283 PyObject * obj0 = 0 ;
8284 PyObject * obj1 = 0 ;
8285 char *kwnames[] = {
8286 (char *) "self",(char *) "font", NULL
8287 };
8288
8289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_InitFromFont",kwnames,&obj0,&obj1)) goto fail;
8290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8291 if (SWIG_arg_fail(1)) SWIG_fail;
8292 {
8293 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
8294 if (SWIG_arg_fail(2)) SWIG_fail;
8295 if (arg2 == NULL) {
8296 SWIG_null_ref("wxFont");
8297 }
8298 if (SWIG_arg_fail(2)) SWIG_fail;
8299 }
8300 {
8301 PyThreadState* __tstate = wxPyBeginAllowThreads();
8302 (arg1)->InitFromFont((wxFont const &)*arg2);
8303
8304 wxPyEndAllowThreads(__tstate);
8305 if (PyErr_Occurred()) SWIG_fail;
8306 }
8307 Py_INCREF(Py_None); resultobj = Py_None;
8308 return resultobj;
8309 fail:
8310 return NULL;
8311 }
8312
8313
8314 static PyObject *_wrap_NativeFontInfo_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
8315 PyObject *resultobj;
8316 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8317 int result;
8318 PyObject * obj0 = 0 ;
8319 char *kwnames[] = {
8320 (char *) "self", NULL
8321 };
8322
8323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetPointSize",kwnames,&obj0)) goto fail;
8324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8325 if (SWIG_arg_fail(1)) SWIG_fail;
8326 {
8327 PyThreadState* __tstate = wxPyBeginAllowThreads();
8328 result = (int)((wxNativeFontInfo const *)arg1)->GetPointSize();
8329
8330 wxPyEndAllowThreads(__tstate);
8331 if (PyErr_Occurred()) SWIG_fail;
8332 }
8333 {
8334 resultobj = SWIG_From_int((int)(result));
8335 }
8336 return resultobj;
8337 fail:
8338 return NULL;
8339 }
8340
8341
8342 static PyObject *_wrap_NativeFontInfo_GetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
8343 PyObject *resultobj;
8344 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8345 wxSize result;
8346 PyObject * obj0 = 0 ;
8347 char *kwnames[] = {
8348 (char *) "self", NULL
8349 };
8350
8351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetPixelSize",kwnames,&obj0)) goto fail;
8352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8353 if (SWIG_arg_fail(1)) SWIG_fail;
8354 {
8355 PyThreadState* __tstate = wxPyBeginAllowThreads();
8356 result = ((wxNativeFontInfo const *)arg1)->GetPixelSize();
8357
8358 wxPyEndAllowThreads(__tstate);
8359 if (PyErr_Occurred()) SWIG_fail;
8360 }
8361 {
8362 wxSize * resultptr;
8363 resultptr = new wxSize((wxSize &)(result));
8364 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
8365 }
8366 return resultobj;
8367 fail:
8368 return NULL;
8369 }
8370
8371
8372 static PyObject *_wrap_NativeFontInfo_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
8373 PyObject *resultobj;
8374 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8375 wxFontStyle result;
8376 PyObject * obj0 = 0 ;
8377 char *kwnames[] = {
8378 (char *) "self", NULL
8379 };
8380
8381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetStyle",kwnames,&obj0)) goto fail;
8382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8383 if (SWIG_arg_fail(1)) SWIG_fail;
8384 {
8385 PyThreadState* __tstate = wxPyBeginAllowThreads();
8386 result = (wxFontStyle)((wxNativeFontInfo const *)arg1)->GetStyle();
8387
8388 wxPyEndAllowThreads(__tstate);
8389 if (PyErr_Occurred()) SWIG_fail;
8390 }
8391 resultobj = SWIG_From_int((result));
8392 return resultobj;
8393 fail:
8394 return NULL;
8395 }
8396
8397
8398 static PyObject *_wrap_NativeFontInfo_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
8399 PyObject *resultobj;
8400 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8401 wxFontWeight result;
8402 PyObject * obj0 = 0 ;
8403 char *kwnames[] = {
8404 (char *) "self", NULL
8405 };
8406
8407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetWeight",kwnames,&obj0)) goto fail;
8408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8409 if (SWIG_arg_fail(1)) SWIG_fail;
8410 {
8411 PyThreadState* __tstate = wxPyBeginAllowThreads();
8412 result = (wxFontWeight)((wxNativeFontInfo const *)arg1)->GetWeight();
8413
8414 wxPyEndAllowThreads(__tstate);
8415 if (PyErr_Occurred()) SWIG_fail;
8416 }
8417 resultobj = SWIG_From_int((result));
8418 return resultobj;
8419 fail:
8420 return NULL;
8421 }
8422
8423
8424 static PyObject *_wrap_NativeFontInfo_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
8425 PyObject *resultobj;
8426 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8427 bool result;
8428 PyObject * obj0 = 0 ;
8429 char *kwnames[] = {
8430 (char *) "self", NULL
8431 };
8432
8433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetUnderlined",kwnames,&obj0)) goto fail;
8434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8435 if (SWIG_arg_fail(1)) SWIG_fail;
8436 {
8437 PyThreadState* __tstate = wxPyBeginAllowThreads();
8438 result = (bool)((wxNativeFontInfo const *)arg1)->GetUnderlined();
8439
8440 wxPyEndAllowThreads(__tstate);
8441 if (PyErr_Occurred()) SWIG_fail;
8442 }
8443 {
8444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8445 }
8446 return resultobj;
8447 fail:
8448 return NULL;
8449 }
8450
8451
8452 static PyObject *_wrap_NativeFontInfo_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
8453 PyObject *resultobj;
8454 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8455 wxString result;
8456 PyObject * obj0 = 0 ;
8457 char *kwnames[] = {
8458 (char *) "self", NULL
8459 };
8460
8461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFaceName",kwnames,&obj0)) goto fail;
8462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8463 if (SWIG_arg_fail(1)) SWIG_fail;
8464 {
8465 PyThreadState* __tstate = wxPyBeginAllowThreads();
8466 result = ((wxNativeFontInfo const *)arg1)->GetFaceName();
8467
8468 wxPyEndAllowThreads(__tstate);
8469 if (PyErr_Occurred()) SWIG_fail;
8470 }
8471 {
8472 #if wxUSE_UNICODE
8473 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8474 #else
8475 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8476 #endif
8477 }
8478 return resultobj;
8479 fail:
8480 return NULL;
8481 }
8482
8483
8484 static PyObject *_wrap_NativeFontInfo_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
8485 PyObject *resultobj;
8486 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8487 wxFontFamily result;
8488 PyObject * obj0 = 0 ;
8489 char *kwnames[] = {
8490 (char *) "self", NULL
8491 };
8492
8493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFamily",kwnames,&obj0)) goto fail;
8494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8495 if (SWIG_arg_fail(1)) SWIG_fail;
8496 {
8497 PyThreadState* __tstate = wxPyBeginAllowThreads();
8498 result = (wxFontFamily)((wxNativeFontInfo const *)arg1)->GetFamily();
8499
8500 wxPyEndAllowThreads(__tstate);
8501 if (PyErr_Occurred()) SWIG_fail;
8502 }
8503 resultobj = SWIG_From_int((result));
8504 return resultobj;
8505 fail:
8506 return NULL;
8507 }
8508
8509
8510 static PyObject *_wrap_NativeFontInfo_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8511 PyObject *resultobj;
8512 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8513 wxFontEncoding result;
8514 PyObject * obj0 = 0 ;
8515 char *kwnames[] = {
8516 (char *) "self", NULL
8517 };
8518
8519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetEncoding",kwnames,&obj0)) goto fail;
8520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8521 if (SWIG_arg_fail(1)) SWIG_fail;
8522 {
8523 PyThreadState* __tstate = wxPyBeginAllowThreads();
8524 result = (wxFontEncoding)((wxNativeFontInfo const *)arg1)->GetEncoding();
8525
8526 wxPyEndAllowThreads(__tstate);
8527 if (PyErr_Occurred()) SWIG_fail;
8528 }
8529 resultobj = SWIG_From_int((result));
8530 return resultobj;
8531 fail:
8532 return NULL;
8533 }
8534
8535
8536 static PyObject *_wrap_NativeFontInfo_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
8537 PyObject *resultobj;
8538 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8539 int arg2 ;
8540 PyObject * obj0 = 0 ;
8541 PyObject * obj1 = 0 ;
8542 char *kwnames[] = {
8543 (char *) "self",(char *) "pointsize", NULL
8544 };
8545
8546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
8547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8548 if (SWIG_arg_fail(1)) SWIG_fail;
8549 {
8550 arg2 = (int)(SWIG_As_int(obj1));
8551 if (SWIG_arg_fail(2)) SWIG_fail;
8552 }
8553 {
8554 PyThreadState* __tstate = wxPyBeginAllowThreads();
8555 (arg1)->SetPointSize(arg2);
8556
8557 wxPyEndAllowThreads(__tstate);
8558 if (PyErr_Occurred()) SWIG_fail;
8559 }
8560 Py_INCREF(Py_None); resultobj = Py_None;
8561 return resultobj;
8562 fail:
8563 return NULL;
8564 }
8565
8566
8567 static PyObject *_wrap_NativeFontInfo_SetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
8568 PyObject *resultobj;
8569 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8570 wxSize *arg2 = 0 ;
8571 wxSize temp2 ;
8572 PyObject * obj0 = 0 ;
8573 PyObject * obj1 = 0 ;
8574 char *kwnames[] = {
8575 (char *) "self",(char *) "pixelSize", NULL
8576 };
8577
8578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetPixelSize",kwnames,&obj0,&obj1)) goto fail;
8579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8580 if (SWIG_arg_fail(1)) SWIG_fail;
8581 {
8582 arg2 = &temp2;
8583 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8584 }
8585 {
8586 PyThreadState* __tstate = wxPyBeginAllowThreads();
8587 (arg1)->SetPixelSize((wxSize const &)*arg2);
8588
8589 wxPyEndAllowThreads(__tstate);
8590 if (PyErr_Occurred()) SWIG_fail;
8591 }
8592 Py_INCREF(Py_None); resultobj = Py_None;
8593 return resultobj;
8594 fail:
8595 return NULL;
8596 }
8597
8598
8599 static PyObject *_wrap_NativeFontInfo_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
8600 PyObject *resultobj;
8601 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8602 wxFontStyle arg2 ;
8603 PyObject * obj0 = 0 ;
8604 PyObject * obj1 = 0 ;
8605 char *kwnames[] = {
8606 (char *) "self",(char *) "style", NULL
8607 };
8608
8609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetStyle",kwnames,&obj0,&obj1)) goto fail;
8610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8611 if (SWIG_arg_fail(1)) SWIG_fail;
8612 {
8613 arg2 = (wxFontStyle)(SWIG_As_int(obj1));
8614 if (SWIG_arg_fail(2)) SWIG_fail;
8615 }
8616 {
8617 PyThreadState* __tstate = wxPyBeginAllowThreads();
8618 (arg1)->SetStyle((wxFontStyle )arg2);
8619
8620 wxPyEndAllowThreads(__tstate);
8621 if (PyErr_Occurred()) SWIG_fail;
8622 }
8623 Py_INCREF(Py_None); resultobj = Py_None;
8624 return resultobj;
8625 fail:
8626 return NULL;
8627 }
8628
8629
8630 static PyObject *_wrap_NativeFontInfo_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
8631 PyObject *resultobj;
8632 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8633 wxFontWeight arg2 ;
8634 PyObject * obj0 = 0 ;
8635 PyObject * obj1 = 0 ;
8636 char *kwnames[] = {
8637 (char *) "self",(char *) "weight", NULL
8638 };
8639
8640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetWeight",kwnames,&obj0,&obj1)) goto fail;
8641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8642 if (SWIG_arg_fail(1)) SWIG_fail;
8643 {
8644 arg2 = (wxFontWeight)(SWIG_As_int(obj1));
8645 if (SWIG_arg_fail(2)) SWIG_fail;
8646 }
8647 {
8648 PyThreadState* __tstate = wxPyBeginAllowThreads();
8649 (arg1)->SetWeight((wxFontWeight )arg2);
8650
8651 wxPyEndAllowThreads(__tstate);
8652 if (PyErr_Occurred()) SWIG_fail;
8653 }
8654 Py_INCREF(Py_None); resultobj = Py_None;
8655 return resultobj;
8656 fail:
8657 return NULL;
8658 }
8659
8660
8661 static PyObject *_wrap_NativeFontInfo_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
8662 PyObject *resultobj;
8663 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8664 bool arg2 ;
8665 PyObject * obj0 = 0 ;
8666 PyObject * obj1 = 0 ;
8667 char *kwnames[] = {
8668 (char *) "self",(char *) "underlined", NULL
8669 };
8670
8671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
8672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8673 if (SWIG_arg_fail(1)) SWIG_fail;
8674 {
8675 arg2 = (bool)(SWIG_As_bool(obj1));
8676 if (SWIG_arg_fail(2)) SWIG_fail;
8677 }
8678 {
8679 PyThreadState* __tstate = wxPyBeginAllowThreads();
8680 (arg1)->SetUnderlined(arg2);
8681
8682 wxPyEndAllowThreads(__tstate);
8683 if (PyErr_Occurred()) SWIG_fail;
8684 }
8685 Py_INCREF(Py_None); resultobj = Py_None;
8686 return resultobj;
8687 fail:
8688 return NULL;
8689 }
8690
8691
8692 static PyObject *_wrap_NativeFontInfo_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
8693 PyObject *resultobj;
8694 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8695 wxString arg2 ;
8696 PyObject * obj0 = 0 ;
8697 PyObject * obj1 = 0 ;
8698 char *kwnames[] = {
8699 (char *) "self",(char *) "facename", NULL
8700 };
8701
8702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
8703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8704 if (SWIG_arg_fail(1)) SWIG_fail;
8705 {
8706 wxString* sptr = wxString_in_helper(obj1);
8707 if (sptr == NULL) SWIG_fail;
8708 arg2 = *sptr;
8709 delete sptr;
8710 }
8711 {
8712 PyThreadState* __tstate = wxPyBeginAllowThreads();
8713 (arg1)->SetFaceName(arg2);
8714
8715 wxPyEndAllowThreads(__tstate);
8716 if (PyErr_Occurred()) SWIG_fail;
8717 }
8718 Py_INCREF(Py_None); resultobj = Py_None;
8719 return resultobj;
8720 fail:
8721 return NULL;
8722 }
8723
8724
8725 static PyObject *_wrap_NativeFontInfo_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
8726 PyObject *resultobj;
8727 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8728 wxFontFamily arg2 ;
8729 PyObject * obj0 = 0 ;
8730 PyObject * obj1 = 0 ;
8731 char *kwnames[] = {
8732 (char *) "self",(char *) "family", NULL
8733 };
8734
8735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFamily",kwnames,&obj0,&obj1)) goto fail;
8736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8737 if (SWIG_arg_fail(1)) SWIG_fail;
8738 {
8739 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
8740 if (SWIG_arg_fail(2)) SWIG_fail;
8741 }
8742 {
8743 PyThreadState* __tstate = wxPyBeginAllowThreads();
8744 (arg1)->SetFamily((wxFontFamily )arg2);
8745
8746 wxPyEndAllowThreads(__tstate);
8747 if (PyErr_Occurred()) SWIG_fail;
8748 }
8749 Py_INCREF(Py_None); resultobj = Py_None;
8750 return resultobj;
8751 fail:
8752 return NULL;
8753 }
8754
8755
8756 static PyObject *_wrap_NativeFontInfo_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8757 PyObject *resultobj;
8758 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8759 wxFontEncoding arg2 ;
8760 PyObject * obj0 = 0 ;
8761 PyObject * obj1 = 0 ;
8762 char *kwnames[] = {
8763 (char *) "self",(char *) "encoding", NULL
8764 };
8765
8766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
8767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8768 if (SWIG_arg_fail(1)) SWIG_fail;
8769 {
8770 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8771 if (SWIG_arg_fail(2)) SWIG_fail;
8772 }
8773 {
8774 PyThreadState* __tstate = wxPyBeginAllowThreads();
8775 (arg1)->SetEncoding((wxFontEncoding )arg2);
8776
8777 wxPyEndAllowThreads(__tstate);
8778 if (PyErr_Occurred()) SWIG_fail;
8779 }
8780 Py_INCREF(Py_None); resultobj = Py_None;
8781 return resultobj;
8782 fail:
8783 return NULL;
8784 }
8785
8786
8787 static PyObject *_wrap_NativeFontInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
8788 PyObject *resultobj;
8789 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8790 wxString *arg2 = 0 ;
8791 bool result;
8792 bool temp2 = false ;
8793 PyObject * obj0 = 0 ;
8794 PyObject * obj1 = 0 ;
8795 char *kwnames[] = {
8796 (char *) "self",(char *) "s", NULL
8797 };
8798
8799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
8800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8801 if (SWIG_arg_fail(1)) SWIG_fail;
8802 {
8803 arg2 = wxString_in_helper(obj1);
8804 if (arg2 == NULL) SWIG_fail;
8805 temp2 = true;
8806 }
8807 {
8808 PyThreadState* __tstate = wxPyBeginAllowThreads();
8809 result = (bool)(arg1)->FromString((wxString const &)*arg2);
8810
8811 wxPyEndAllowThreads(__tstate);
8812 if (PyErr_Occurred()) SWIG_fail;
8813 }
8814 {
8815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8816 }
8817 {
8818 if (temp2)
8819 delete arg2;
8820 }
8821 return resultobj;
8822 fail:
8823 {
8824 if (temp2)
8825 delete arg2;
8826 }
8827 return NULL;
8828 }
8829
8830
8831 static PyObject *_wrap_NativeFontInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
8832 PyObject *resultobj;
8833 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8834 wxString result;
8835 PyObject * obj0 = 0 ;
8836 char *kwnames[] = {
8837 (char *) "self", NULL
8838 };
8839
8840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToString",kwnames,&obj0)) goto fail;
8841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8842 if (SWIG_arg_fail(1)) SWIG_fail;
8843 {
8844 PyThreadState* __tstate = wxPyBeginAllowThreads();
8845 result = ((wxNativeFontInfo const *)arg1)->ToString();
8846
8847 wxPyEndAllowThreads(__tstate);
8848 if (PyErr_Occurred()) SWIG_fail;
8849 }
8850 {
8851 #if wxUSE_UNICODE
8852 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8853 #else
8854 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8855 #endif
8856 }
8857 return resultobj;
8858 fail:
8859 return NULL;
8860 }
8861
8862
8863 static PyObject *_wrap_NativeFontInfo___str__(PyObject *, PyObject *args, PyObject *kwargs) {
8864 PyObject *resultobj;
8865 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8866 wxString result;
8867 PyObject * obj0 = 0 ;
8868 char *kwnames[] = {
8869 (char *) "self", NULL
8870 };
8871
8872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo___str__",kwnames,&obj0)) goto fail;
8873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8874 if (SWIG_arg_fail(1)) SWIG_fail;
8875 {
8876 PyThreadState* __tstate = wxPyBeginAllowThreads();
8877 result = wxNativeFontInfo___str__(arg1);
8878
8879 wxPyEndAllowThreads(__tstate);
8880 if (PyErr_Occurred()) SWIG_fail;
8881 }
8882 {
8883 #if wxUSE_UNICODE
8884 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8885 #else
8886 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8887 #endif
8888 }
8889 return resultobj;
8890 fail:
8891 return NULL;
8892 }
8893
8894
8895 static PyObject *_wrap_NativeFontInfo_FromUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8896 PyObject *resultobj;
8897 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8898 wxString *arg2 = 0 ;
8899 bool result;
8900 bool temp2 = false ;
8901 PyObject * obj0 = 0 ;
8902 PyObject * obj1 = 0 ;
8903 char *kwnames[] = {
8904 (char *) "self",(char *) "s", NULL
8905 };
8906
8907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromUserString",kwnames,&obj0,&obj1)) goto fail;
8908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8909 if (SWIG_arg_fail(1)) SWIG_fail;
8910 {
8911 arg2 = wxString_in_helper(obj1);
8912 if (arg2 == NULL) SWIG_fail;
8913 temp2 = true;
8914 }
8915 {
8916 PyThreadState* __tstate = wxPyBeginAllowThreads();
8917 result = (bool)(arg1)->FromUserString((wxString const &)*arg2);
8918
8919 wxPyEndAllowThreads(__tstate);
8920 if (PyErr_Occurred()) SWIG_fail;
8921 }
8922 {
8923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8924 }
8925 {
8926 if (temp2)
8927 delete arg2;
8928 }
8929 return resultobj;
8930 fail:
8931 {
8932 if (temp2)
8933 delete arg2;
8934 }
8935 return NULL;
8936 }
8937
8938
8939 static PyObject *_wrap_NativeFontInfo_ToUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8940 PyObject *resultobj;
8941 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8942 wxString result;
8943 PyObject * obj0 = 0 ;
8944 char *kwnames[] = {
8945 (char *) "self", NULL
8946 };
8947
8948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToUserString",kwnames,&obj0)) goto fail;
8949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8950 if (SWIG_arg_fail(1)) SWIG_fail;
8951 {
8952 PyThreadState* __tstate = wxPyBeginAllowThreads();
8953 result = ((wxNativeFontInfo const *)arg1)->ToUserString();
8954
8955 wxPyEndAllowThreads(__tstate);
8956 if (PyErr_Occurred()) SWIG_fail;
8957 }
8958 {
8959 #if wxUSE_UNICODE
8960 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8961 #else
8962 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8963 #endif
8964 }
8965 return resultobj;
8966 fail:
8967 return NULL;
8968 }
8969
8970
8971 static PyObject * NativeFontInfo_swigregister(PyObject *, PyObject *args) {
8972 PyObject *obj;
8973 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8974 SWIG_TypeClientData(SWIGTYPE_p_wxNativeFontInfo, obj);
8975 Py_INCREF(obj);
8976 return Py_BuildValue((char *)"");
8977 }
8978 static PyObject *_wrap_NativeEncodingInfo_facename_set(PyObject *, PyObject *args, PyObject *kwargs) {
8979 PyObject *resultobj;
8980 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8981 wxString *arg2 = (wxString *) 0 ;
8982 bool temp2 = false ;
8983 PyObject * obj0 = 0 ;
8984 PyObject * obj1 = 0 ;
8985 char *kwnames[] = {
8986 (char *) "self",(char *) "facename", NULL
8987 };
8988
8989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_facename_set",kwnames,&obj0,&obj1)) goto fail;
8990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8991 if (SWIG_arg_fail(1)) SWIG_fail;
8992 {
8993 arg2 = wxString_in_helper(obj1);
8994 if (arg2 == NULL) SWIG_fail;
8995 temp2 = true;
8996 }
8997 if (arg1) (arg1)->facename = *arg2;
8998
8999 Py_INCREF(Py_None); resultobj = Py_None;
9000 {
9001 if (temp2)
9002 delete arg2;
9003 }
9004 return resultobj;
9005 fail:
9006 {
9007 if (temp2)
9008 delete arg2;
9009 }
9010 return NULL;
9011 }
9012
9013
9014 static PyObject *_wrap_NativeEncodingInfo_facename_get(PyObject *, PyObject *args, PyObject *kwargs) {
9015 PyObject *resultobj;
9016 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
9017 wxString *result;
9018 PyObject * obj0 = 0 ;
9019 char *kwnames[] = {
9020 (char *) "self", NULL
9021 };
9022
9023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_facename_get",kwnames,&obj0)) goto fail;
9024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9025 if (SWIG_arg_fail(1)) SWIG_fail;
9026 result = (wxString *)& ((arg1)->facename);
9027
9028 {
9029 #if wxUSE_UNICODE
9030 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9031 #else
9032 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9033 #endif
9034 }
9035 return resultobj;
9036 fail:
9037 return NULL;
9038 }
9039
9040
9041 static PyObject *_wrap_NativeEncodingInfo_encoding_set(PyObject *, PyObject *args, PyObject *kwargs) {
9042 PyObject *resultobj;
9043 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
9044 wxFontEncoding arg2 ;
9045 PyObject * obj0 = 0 ;
9046 PyObject * obj1 = 0 ;
9047 char *kwnames[] = {
9048 (char *) "self",(char *) "encoding", NULL
9049 };
9050
9051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_encoding_set",kwnames,&obj0,&obj1)) goto fail;
9052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9053 if (SWIG_arg_fail(1)) SWIG_fail;
9054 {
9055 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9056 if (SWIG_arg_fail(2)) SWIG_fail;
9057 }
9058 if (arg1) (arg1)->encoding = (wxFontEncoding )arg2;
9059
9060 Py_INCREF(Py_None); resultobj = Py_None;
9061 return resultobj;
9062 fail:
9063 return NULL;
9064 }
9065
9066
9067 static PyObject *_wrap_NativeEncodingInfo_encoding_get(PyObject *, PyObject *args, PyObject *kwargs) {
9068 PyObject *resultobj;
9069 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
9070 wxFontEncoding result;
9071 PyObject * obj0 = 0 ;
9072 char *kwnames[] = {
9073 (char *) "self", NULL
9074 };
9075
9076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_encoding_get",kwnames,&obj0)) goto fail;
9077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9078 if (SWIG_arg_fail(1)) SWIG_fail;
9079 result = (wxFontEncoding) ((arg1)->encoding);
9080
9081 resultobj = SWIG_From_int((result));
9082 return resultobj;
9083 fail:
9084 return NULL;
9085 }
9086
9087
9088 static PyObject *_wrap_new_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9089 PyObject *resultobj;
9090 wxNativeEncodingInfo *result;
9091 char *kwnames[] = {
9092 NULL
9093 };
9094
9095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeEncodingInfo",kwnames)) goto fail;
9096 {
9097 PyThreadState* __tstate = wxPyBeginAllowThreads();
9098 result = (wxNativeEncodingInfo *)new wxNativeEncodingInfo();
9099
9100 wxPyEndAllowThreads(__tstate);
9101 if (PyErr_Occurred()) SWIG_fail;
9102 }
9103 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 1);
9104 return resultobj;
9105 fail:
9106 return NULL;
9107 }
9108
9109
9110 static PyObject *_wrap_delete_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9111 PyObject *resultobj;
9112 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
9113 PyObject * obj0 = 0 ;
9114 char *kwnames[] = {
9115 (char *) "self", NULL
9116 };
9117
9118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeEncodingInfo",kwnames,&obj0)) goto fail;
9119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9120 if (SWIG_arg_fail(1)) SWIG_fail;
9121 {
9122 PyThreadState* __tstate = wxPyBeginAllowThreads();
9123 delete arg1;
9124
9125 wxPyEndAllowThreads(__tstate);
9126 if (PyErr_Occurred()) SWIG_fail;
9127 }
9128 Py_INCREF(Py_None); resultobj = Py_None;
9129 return resultobj;
9130 fail:
9131 return NULL;
9132 }
9133
9134
9135 static PyObject *_wrap_NativeEncodingInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
9136 PyObject *resultobj;
9137 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
9138 wxString *arg2 = 0 ;
9139 bool result;
9140 bool temp2 = false ;
9141 PyObject * obj0 = 0 ;
9142 PyObject * obj1 = 0 ;
9143 char *kwnames[] = {
9144 (char *) "self",(char *) "s", NULL
9145 };
9146
9147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
9148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9149 if (SWIG_arg_fail(1)) SWIG_fail;
9150 {
9151 arg2 = wxString_in_helper(obj1);
9152 if (arg2 == NULL) SWIG_fail;
9153 temp2 = true;
9154 }
9155 {
9156 PyThreadState* __tstate = wxPyBeginAllowThreads();
9157 result = (bool)(arg1)->FromString((wxString const &)*arg2);
9158
9159 wxPyEndAllowThreads(__tstate);
9160 if (PyErr_Occurred()) SWIG_fail;
9161 }
9162 {
9163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9164 }
9165 {
9166 if (temp2)
9167 delete arg2;
9168 }
9169 return resultobj;
9170 fail:
9171 {
9172 if (temp2)
9173 delete arg2;
9174 }
9175 return NULL;
9176 }
9177
9178
9179 static PyObject *_wrap_NativeEncodingInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
9180 PyObject *resultobj;
9181 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
9182 wxString result;
9183 PyObject * obj0 = 0 ;
9184 char *kwnames[] = {
9185 (char *) "self", NULL
9186 };
9187
9188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_ToString",kwnames,&obj0)) goto fail;
9189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9190 if (SWIG_arg_fail(1)) SWIG_fail;
9191 {
9192 PyThreadState* __tstate = wxPyBeginAllowThreads();
9193 result = ((wxNativeEncodingInfo const *)arg1)->ToString();
9194
9195 wxPyEndAllowThreads(__tstate);
9196 if (PyErr_Occurred()) SWIG_fail;
9197 }
9198 {
9199 #if wxUSE_UNICODE
9200 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9201 #else
9202 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9203 #endif
9204 }
9205 return resultobj;
9206 fail:
9207 return NULL;
9208 }
9209
9210
9211 static PyObject * NativeEncodingInfo_swigregister(PyObject *, PyObject *args) {
9212 PyObject *obj;
9213 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9214 SWIG_TypeClientData(SWIGTYPE_p_wxNativeEncodingInfo, obj);
9215 Py_INCREF(obj);
9216 return Py_BuildValue((char *)"");
9217 }
9218 static PyObject *_wrap_GetNativeFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9219 PyObject *resultobj;
9220 wxFontEncoding arg1 ;
9221 wxNativeEncodingInfo *result;
9222 PyObject * obj0 = 0 ;
9223 char *kwnames[] = {
9224 (char *) "encoding", NULL
9225 };
9226
9227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetNativeFontEncoding",kwnames,&obj0)) goto fail;
9228 {
9229 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
9230 if (SWIG_arg_fail(1)) SWIG_fail;
9231 }
9232 {
9233 PyThreadState* __tstate = wxPyBeginAllowThreads();
9234 result = (wxNativeEncodingInfo *)wxGetNativeFontEncoding((wxFontEncoding )arg1);
9235
9236 wxPyEndAllowThreads(__tstate);
9237 if (PyErr_Occurred()) SWIG_fail;
9238 }
9239 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 0);
9240 return resultobj;
9241 fail:
9242 return NULL;
9243 }
9244
9245
9246 static PyObject *_wrap_TestFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9247 PyObject *resultobj;
9248 wxNativeEncodingInfo *arg1 = 0 ;
9249 bool result;
9250 PyObject * obj0 = 0 ;
9251 char *kwnames[] = {
9252 (char *) "info", NULL
9253 };
9254
9255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TestFontEncoding",kwnames,&obj0)) goto fail;
9256 {
9257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9258 if (SWIG_arg_fail(1)) SWIG_fail;
9259 if (arg1 == NULL) {
9260 SWIG_null_ref("wxNativeEncodingInfo");
9261 }
9262 if (SWIG_arg_fail(1)) SWIG_fail;
9263 }
9264 {
9265 PyThreadState* __tstate = wxPyBeginAllowThreads();
9266 result = (bool)wxTestFontEncoding((wxNativeEncodingInfo const &)*arg1);
9267
9268 wxPyEndAllowThreads(__tstate);
9269 if (PyErr_Occurred()) SWIG_fail;
9270 }
9271 {
9272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9273 }
9274 return resultobj;
9275 fail:
9276 return NULL;
9277 }
9278
9279
9280 static PyObject *_wrap_new_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
9281 PyObject *resultobj;
9282 wxFontMapper *result;
9283 char *kwnames[] = {
9284 NULL
9285 };
9286
9287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontMapper",kwnames)) goto fail;
9288 {
9289 PyThreadState* __tstate = wxPyBeginAllowThreads();
9290 result = (wxFontMapper *)new wxFontMapper();
9291
9292 wxPyEndAllowThreads(__tstate);
9293 if (PyErr_Occurred()) SWIG_fail;
9294 }
9295 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 1);
9296 return resultobj;
9297 fail:
9298 return NULL;
9299 }
9300
9301
9302 static PyObject *_wrap_delete_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
9303 PyObject *resultobj;
9304 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9305 PyObject * obj0 = 0 ;
9306 char *kwnames[] = {
9307 (char *) "self", NULL
9308 };
9309
9310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontMapper",kwnames,&obj0)) goto fail;
9311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9312 if (SWIG_arg_fail(1)) SWIG_fail;
9313 {
9314 PyThreadState* __tstate = wxPyBeginAllowThreads();
9315 delete arg1;
9316
9317 wxPyEndAllowThreads(__tstate);
9318 if (PyErr_Occurred()) SWIG_fail;
9319 }
9320 Py_INCREF(Py_None); resultobj = Py_None;
9321 return resultobj;
9322 fail:
9323 return NULL;
9324 }
9325
9326
9327 static PyObject *_wrap_FontMapper_Get(PyObject *, PyObject *args, PyObject *kwargs) {
9328 PyObject *resultobj;
9329 wxFontMapper *result;
9330 char *kwnames[] = {
9331 NULL
9332 };
9333
9334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_Get",kwnames)) goto fail;
9335 {
9336 PyThreadState* __tstate = wxPyBeginAllowThreads();
9337 result = (wxFontMapper *)wxFontMapper::Get();
9338
9339 wxPyEndAllowThreads(__tstate);
9340 if (PyErr_Occurred()) SWIG_fail;
9341 }
9342 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
9343 return resultobj;
9344 fail:
9345 return NULL;
9346 }
9347
9348
9349 static PyObject *_wrap_FontMapper_Set(PyObject *, PyObject *args, PyObject *kwargs) {
9350 PyObject *resultobj;
9351 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9352 wxFontMapper *result;
9353 PyObject * obj0 = 0 ;
9354 char *kwnames[] = {
9355 (char *) "mapper", NULL
9356 };
9357
9358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_Set",kwnames,&obj0)) goto fail;
9359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9360 if (SWIG_arg_fail(1)) SWIG_fail;
9361 {
9362 PyThreadState* __tstate = wxPyBeginAllowThreads();
9363 result = (wxFontMapper *)wxFontMapper::Set(arg1);
9364
9365 wxPyEndAllowThreads(__tstate);
9366 if (PyErr_Occurred()) SWIG_fail;
9367 }
9368 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
9369 return resultobj;
9370 fail:
9371 return NULL;
9372 }
9373
9374
9375 static PyObject *_wrap_FontMapper_CharsetToEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9376 PyObject *resultobj;
9377 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9378 wxString *arg2 = 0 ;
9379 bool arg3 = (bool) true ;
9380 wxFontEncoding result;
9381 bool temp2 = false ;
9382 PyObject * obj0 = 0 ;
9383 PyObject * obj1 = 0 ;
9384 PyObject * obj2 = 0 ;
9385 char *kwnames[] = {
9386 (char *) "self",(char *) "charset",(char *) "interactive", NULL
9387 };
9388
9389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_CharsetToEncoding",kwnames,&obj0,&obj1,&obj2)) goto fail;
9390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9391 if (SWIG_arg_fail(1)) SWIG_fail;
9392 {
9393 arg2 = wxString_in_helper(obj1);
9394 if (arg2 == NULL) SWIG_fail;
9395 temp2 = true;
9396 }
9397 if (obj2) {
9398 {
9399 arg3 = (bool)(SWIG_As_bool(obj2));
9400 if (SWIG_arg_fail(3)) SWIG_fail;
9401 }
9402 }
9403 {
9404 PyThreadState* __tstate = wxPyBeginAllowThreads();
9405 result = (wxFontEncoding)(arg1)->CharsetToEncoding((wxString const &)*arg2,arg3);
9406
9407 wxPyEndAllowThreads(__tstate);
9408 if (PyErr_Occurred()) SWIG_fail;
9409 }
9410 resultobj = SWIG_From_int((result));
9411 {
9412 if (temp2)
9413 delete arg2;
9414 }
9415 return resultobj;
9416 fail:
9417 {
9418 if (temp2)
9419 delete arg2;
9420 }
9421 return NULL;
9422 }
9423
9424
9425 static PyObject *_wrap_FontMapper_GetSupportedEncodingsCount(PyObject *, PyObject *args, PyObject *kwargs) {
9426 PyObject *resultobj;
9427 size_t result;
9428 char *kwnames[] = {
9429 NULL
9430 };
9431
9432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetSupportedEncodingsCount",kwnames)) goto fail;
9433 {
9434 PyThreadState* __tstate = wxPyBeginAllowThreads();
9435 result = (size_t)wxFontMapper::GetSupportedEncodingsCount();
9436
9437 wxPyEndAllowThreads(__tstate);
9438 if (PyErr_Occurred()) SWIG_fail;
9439 }
9440 {
9441 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9442 }
9443 return resultobj;
9444 fail:
9445 return NULL;
9446 }
9447
9448
9449 static PyObject *_wrap_FontMapper_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9450 PyObject *resultobj;
9451 size_t arg1 ;
9452 wxFontEncoding result;
9453 PyObject * obj0 = 0 ;
9454 char *kwnames[] = {
9455 (char *) "n", NULL
9456 };
9457
9458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncoding",kwnames,&obj0)) goto fail;
9459 {
9460 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
9461 if (SWIG_arg_fail(1)) SWIG_fail;
9462 }
9463 {
9464 PyThreadState* __tstate = wxPyBeginAllowThreads();
9465 result = (wxFontEncoding)wxFontMapper::GetEncoding(arg1);
9466
9467 wxPyEndAllowThreads(__tstate);
9468 if (PyErr_Occurred()) SWIG_fail;
9469 }
9470 resultobj = SWIG_From_int((result));
9471 return resultobj;
9472 fail:
9473 return NULL;
9474 }
9475
9476
9477 static PyObject *_wrap_FontMapper_GetEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
9478 PyObject *resultobj;
9479 wxFontEncoding arg1 ;
9480 wxString result;
9481 PyObject * obj0 = 0 ;
9482 char *kwnames[] = {
9483 (char *) "encoding", NULL
9484 };
9485
9486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingName",kwnames,&obj0)) goto fail;
9487 {
9488 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
9489 if (SWIG_arg_fail(1)) SWIG_fail;
9490 }
9491 {
9492 PyThreadState* __tstate = wxPyBeginAllowThreads();
9493 result = wxFontMapper::GetEncodingName((wxFontEncoding )arg1);
9494
9495 wxPyEndAllowThreads(__tstate);
9496 if (PyErr_Occurred()) SWIG_fail;
9497 }
9498 {
9499 #if wxUSE_UNICODE
9500 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9501 #else
9502 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9503 #endif
9504 }
9505 return resultobj;
9506 fail:
9507 return NULL;
9508 }
9509
9510
9511 static PyObject *_wrap_FontMapper_GetEncodingDescription(PyObject *, PyObject *args, PyObject *kwargs) {
9512 PyObject *resultobj;
9513 wxFontEncoding arg1 ;
9514 wxString result;
9515 PyObject * obj0 = 0 ;
9516 char *kwnames[] = {
9517 (char *) "encoding", NULL
9518 };
9519
9520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingDescription",kwnames,&obj0)) goto fail;
9521 {
9522 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
9523 if (SWIG_arg_fail(1)) SWIG_fail;
9524 }
9525 {
9526 PyThreadState* __tstate = wxPyBeginAllowThreads();
9527 result = wxFontMapper::GetEncodingDescription((wxFontEncoding )arg1);
9528
9529 wxPyEndAllowThreads(__tstate);
9530 if (PyErr_Occurred()) SWIG_fail;
9531 }
9532 {
9533 #if wxUSE_UNICODE
9534 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9535 #else
9536 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9537 #endif
9538 }
9539 return resultobj;
9540 fail:
9541 return NULL;
9542 }
9543
9544
9545 static PyObject *_wrap_FontMapper_GetEncodingFromName(PyObject *, PyObject *args, PyObject *kwargs) {
9546 PyObject *resultobj;
9547 wxString *arg1 = 0 ;
9548 wxFontEncoding result;
9549 bool temp1 = false ;
9550 PyObject * obj0 = 0 ;
9551 char *kwnames[] = {
9552 (char *) "name", NULL
9553 };
9554
9555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingFromName",kwnames,&obj0)) goto fail;
9556 {
9557 arg1 = wxString_in_helper(obj0);
9558 if (arg1 == NULL) SWIG_fail;
9559 temp1 = true;
9560 }
9561 {
9562 PyThreadState* __tstate = wxPyBeginAllowThreads();
9563 result = (wxFontEncoding)wxFontMapper::GetEncodingFromName((wxString const &)*arg1);
9564
9565 wxPyEndAllowThreads(__tstate);
9566 if (PyErr_Occurred()) SWIG_fail;
9567 }
9568 resultobj = SWIG_From_int((result));
9569 {
9570 if (temp1)
9571 delete arg1;
9572 }
9573 return resultobj;
9574 fail:
9575 {
9576 if (temp1)
9577 delete arg1;
9578 }
9579 return NULL;
9580 }
9581
9582
9583 static PyObject *_wrap_FontMapper_SetConfig(PyObject *, PyObject *args, PyObject *kwargs) {
9584 PyObject *resultobj;
9585 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9586 wxConfigBase *arg2 = (wxConfigBase *) 0 ;
9587 PyObject * obj0 = 0 ;
9588 PyObject * obj1 = 0 ;
9589 char *kwnames[] = {
9590 (char *) "self",(char *) "config", NULL
9591 };
9592
9593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfig",kwnames,&obj0,&obj1)) goto fail;
9594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9595 if (SWIG_arg_fail(1)) SWIG_fail;
9596 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
9597 if (SWIG_arg_fail(2)) SWIG_fail;
9598 {
9599 PyThreadState* __tstate = wxPyBeginAllowThreads();
9600 (arg1)->SetConfig(arg2);
9601
9602 wxPyEndAllowThreads(__tstate);
9603 if (PyErr_Occurred()) SWIG_fail;
9604 }
9605 Py_INCREF(Py_None); resultobj = Py_None;
9606 return resultobj;
9607 fail:
9608 return NULL;
9609 }
9610
9611
9612 static PyObject *_wrap_FontMapper_SetConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
9613 PyObject *resultobj;
9614 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9615 wxString *arg2 = 0 ;
9616 bool temp2 = false ;
9617 PyObject * obj0 = 0 ;
9618 PyObject * obj1 = 0 ;
9619 char *kwnames[] = {
9620 (char *) "self",(char *) "prefix", NULL
9621 };
9622
9623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfigPath",kwnames,&obj0,&obj1)) goto fail;
9624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9625 if (SWIG_arg_fail(1)) SWIG_fail;
9626 {
9627 arg2 = wxString_in_helper(obj1);
9628 if (arg2 == NULL) SWIG_fail;
9629 temp2 = true;
9630 }
9631 {
9632 PyThreadState* __tstate = wxPyBeginAllowThreads();
9633 (arg1)->SetConfigPath((wxString const &)*arg2);
9634
9635 wxPyEndAllowThreads(__tstate);
9636 if (PyErr_Occurred()) SWIG_fail;
9637 }
9638 Py_INCREF(Py_None); resultobj = Py_None;
9639 {
9640 if (temp2)
9641 delete arg2;
9642 }
9643 return resultobj;
9644 fail:
9645 {
9646 if (temp2)
9647 delete arg2;
9648 }
9649 return NULL;
9650 }
9651
9652
9653 static PyObject *_wrap_FontMapper_GetDefaultConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
9654 PyObject *resultobj;
9655 wxString result;
9656 char *kwnames[] = {
9657 NULL
9658 };
9659
9660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetDefaultConfigPath",kwnames)) goto fail;
9661 {
9662 PyThreadState* __tstate = wxPyBeginAllowThreads();
9663 result = wxFontMapper::GetDefaultConfigPath();
9664
9665 wxPyEndAllowThreads(__tstate);
9666 if (PyErr_Occurred()) SWIG_fail;
9667 }
9668 {
9669 #if wxUSE_UNICODE
9670 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9671 #else
9672 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9673 #endif
9674 }
9675 return resultobj;
9676 fail:
9677 return NULL;
9678 }
9679
9680
9681 static PyObject *_wrap_FontMapper_GetAltForEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9682 PyObject *resultobj;
9683 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9684 wxFontEncoding arg2 ;
9685 wxString const &arg3_defvalue = wxPyEmptyString ;
9686 wxString *arg3 = (wxString *) &arg3_defvalue ;
9687 bool arg4 = (bool) true ;
9688 PyObject *result;
9689 bool temp3 = false ;
9690 PyObject * obj0 = 0 ;
9691 PyObject * obj1 = 0 ;
9692 PyObject * obj2 = 0 ;
9693 PyObject * obj3 = 0 ;
9694 char *kwnames[] = {
9695 (char *) "self",(char *) "encoding",(char *) "facename",(char *) "interactive", NULL
9696 };
9697
9698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:FontMapper_GetAltForEncoding",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9700 if (SWIG_arg_fail(1)) SWIG_fail;
9701 {
9702 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9703 if (SWIG_arg_fail(2)) SWIG_fail;
9704 }
9705 if (obj2) {
9706 {
9707 arg3 = wxString_in_helper(obj2);
9708 if (arg3 == NULL) SWIG_fail;
9709 temp3 = true;
9710 }
9711 }
9712 if (obj3) {
9713 {
9714 arg4 = (bool)(SWIG_As_bool(obj3));
9715 if (SWIG_arg_fail(4)) SWIG_fail;
9716 }
9717 }
9718 {
9719 PyThreadState* __tstate = wxPyBeginAllowThreads();
9720 result = (PyObject *)wxFontMapper_GetAltForEncoding(arg1,(wxFontEncoding )arg2,(wxString const &)*arg3,arg4);
9721
9722 wxPyEndAllowThreads(__tstate);
9723 if (PyErr_Occurred()) SWIG_fail;
9724 }
9725 resultobj = result;
9726 {
9727 if (temp3)
9728 delete arg3;
9729 }
9730 return resultobj;
9731 fail:
9732 {
9733 if (temp3)
9734 delete arg3;
9735 }
9736 return NULL;
9737 }
9738
9739
9740 static PyObject *_wrap_FontMapper_IsEncodingAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
9741 PyObject *resultobj;
9742 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9743 wxFontEncoding arg2 ;
9744 wxString const &arg3_defvalue = wxPyEmptyString ;
9745 wxString *arg3 = (wxString *) &arg3_defvalue ;
9746 bool result;
9747 bool temp3 = false ;
9748 PyObject * obj0 = 0 ;
9749 PyObject * obj1 = 0 ;
9750 PyObject * obj2 = 0 ;
9751 char *kwnames[] = {
9752 (char *) "self",(char *) "encoding",(char *) "facename", NULL
9753 };
9754
9755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_IsEncodingAvailable",kwnames,&obj0,&obj1,&obj2)) goto fail;
9756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9757 if (SWIG_arg_fail(1)) SWIG_fail;
9758 {
9759 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9760 if (SWIG_arg_fail(2)) SWIG_fail;
9761 }
9762 if (obj2) {
9763 {
9764 arg3 = wxString_in_helper(obj2);
9765 if (arg3 == NULL) SWIG_fail;
9766 temp3 = true;
9767 }
9768 }
9769 {
9770 PyThreadState* __tstate = wxPyBeginAllowThreads();
9771 result = (bool)(arg1)->IsEncodingAvailable((wxFontEncoding )arg2,(wxString const &)*arg3);
9772
9773 wxPyEndAllowThreads(__tstate);
9774 if (PyErr_Occurred()) SWIG_fail;
9775 }
9776 {
9777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9778 }
9779 {
9780 if (temp3)
9781 delete arg3;
9782 }
9783 return resultobj;
9784 fail:
9785 {
9786 if (temp3)
9787 delete arg3;
9788 }
9789 return NULL;
9790 }
9791
9792
9793 static PyObject *_wrap_FontMapper_SetDialogParent(PyObject *, PyObject *args, PyObject *kwargs) {
9794 PyObject *resultobj;
9795 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9796 wxWindow *arg2 = (wxWindow *) 0 ;
9797 PyObject * obj0 = 0 ;
9798 PyObject * obj1 = 0 ;
9799 char *kwnames[] = {
9800 (char *) "self",(char *) "parent", NULL
9801 };
9802
9803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogParent",kwnames,&obj0,&obj1)) goto fail;
9804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9805 if (SWIG_arg_fail(1)) SWIG_fail;
9806 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
9807 if (SWIG_arg_fail(2)) SWIG_fail;
9808 {
9809 PyThreadState* __tstate = wxPyBeginAllowThreads();
9810 (arg1)->SetDialogParent(arg2);
9811
9812 wxPyEndAllowThreads(__tstate);
9813 if (PyErr_Occurred()) SWIG_fail;
9814 }
9815 Py_INCREF(Py_None); resultobj = Py_None;
9816 return resultobj;
9817 fail:
9818 return NULL;
9819 }
9820
9821
9822 static PyObject *_wrap_FontMapper_SetDialogTitle(PyObject *, PyObject *args, PyObject *kwargs) {
9823 PyObject *resultobj;
9824 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9825 wxString *arg2 = 0 ;
9826 bool temp2 = false ;
9827 PyObject * obj0 = 0 ;
9828 PyObject * obj1 = 0 ;
9829 char *kwnames[] = {
9830 (char *) "self",(char *) "title", NULL
9831 };
9832
9833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogTitle",kwnames,&obj0,&obj1)) goto fail;
9834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9835 if (SWIG_arg_fail(1)) SWIG_fail;
9836 {
9837 arg2 = wxString_in_helper(obj1);
9838 if (arg2 == NULL) SWIG_fail;
9839 temp2 = true;
9840 }
9841 {
9842 PyThreadState* __tstate = wxPyBeginAllowThreads();
9843 (arg1)->SetDialogTitle((wxString const &)*arg2);
9844
9845 wxPyEndAllowThreads(__tstate);
9846 if (PyErr_Occurred()) SWIG_fail;
9847 }
9848 Py_INCREF(Py_None); resultobj = Py_None;
9849 {
9850 if (temp2)
9851 delete arg2;
9852 }
9853 return resultobj;
9854 fail:
9855 {
9856 if (temp2)
9857 delete arg2;
9858 }
9859 return NULL;
9860 }
9861
9862
9863 static PyObject * FontMapper_swigregister(PyObject *, PyObject *args) {
9864 PyObject *obj;
9865 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9866 SWIG_TypeClientData(SWIGTYPE_p_wxFontMapper, obj);
9867 Py_INCREF(obj);
9868 return Py_BuildValue((char *)"");
9869 }
9870 static PyObject *_wrap_new_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9871 PyObject *resultobj;
9872 int arg1 ;
9873 int arg2 ;
9874 int arg3 ;
9875 int arg4 ;
9876 bool arg5 = (bool) false ;
9877 wxString const &arg6_defvalue = wxPyEmptyString ;
9878 wxString *arg6 = (wxString *) &arg6_defvalue ;
9879 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9880 wxFont *result;
9881 bool temp6 = false ;
9882 PyObject * obj0 = 0 ;
9883 PyObject * obj1 = 0 ;
9884 PyObject * obj2 = 0 ;
9885 PyObject * obj3 = 0 ;
9886 PyObject * obj4 = 0 ;
9887 PyObject * obj5 = 0 ;
9888 PyObject * obj6 = 0 ;
9889 char *kwnames[] = {
9890 (char *) "pointSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "face",(char *) "encoding", NULL
9891 };
9892
9893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_Font",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9894 {
9895 arg1 = (int)(SWIG_As_int(obj0));
9896 if (SWIG_arg_fail(1)) SWIG_fail;
9897 }
9898 {
9899 arg2 = (int)(SWIG_As_int(obj1));
9900 if (SWIG_arg_fail(2)) SWIG_fail;
9901 }
9902 {
9903 arg3 = (int)(SWIG_As_int(obj2));
9904 if (SWIG_arg_fail(3)) SWIG_fail;
9905 }
9906 {
9907 arg4 = (int)(SWIG_As_int(obj3));
9908 if (SWIG_arg_fail(4)) SWIG_fail;
9909 }
9910 if (obj4) {
9911 {
9912 arg5 = (bool)(SWIG_As_bool(obj4));
9913 if (SWIG_arg_fail(5)) SWIG_fail;
9914 }
9915 }
9916 if (obj5) {
9917 {
9918 arg6 = wxString_in_helper(obj5);
9919 if (arg6 == NULL) SWIG_fail;
9920 temp6 = true;
9921 }
9922 }
9923 if (obj6) {
9924 {
9925 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
9926 if (SWIG_arg_fail(7)) SWIG_fail;
9927 }
9928 }
9929 {
9930 if (!wxPyCheckForApp()) SWIG_fail;
9931 PyThreadState* __tstate = wxPyBeginAllowThreads();
9932 result = (wxFont *)new wxFont(arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
9933
9934 wxPyEndAllowThreads(__tstate);
9935 if (PyErr_Occurred()) SWIG_fail;
9936 }
9937 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9938 {
9939 if (temp6)
9940 delete arg6;
9941 }
9942 return resultobj;
9943 fail:
9944 {
9945 if (temp6)
9946 delete arg6;
9947 }
9948 return NULL;
9949 }
9950
9951
9952 static PyObject *_wrap_delete_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9953 PyObject *resultobj;
9954 wxFont *arg1 = (wxFont *) 0 ;
9955 PyObject * obj0 = 0 ;
9956 char *kwnames[] = {
9957 (char *) "self", NULL
9958 };
9959
9960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Font",kwnames,&obj0)) goto fail;
9961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9962 if (SWIG_arg_fail(1)) SWIG_fail;
9963 {
9964 PyThreadState* __tstate = wxPyBeginAllowThreads();
9965 delete arg1;
9966
9967 wxPyEndAllowThreads(__tstate);
9968 if (PyErr_Occurred()) SWIG_fail;
9969 }
9970 Py_INCREF(Py_None); resultobj = Py_None;
9971 return resultobj;
9972 fail:
9973 return NULL;
9974 }
9975
9976
9977 static PyObject *_wrap_new_FontFromNativeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9978 PyObject *resultobj;
9979 wxNativeFontInfo *arg1 = 0 ;
9980 wxFont *result;
9981 PyObject * obj0 = 0 ;
9982 char *kwnames[] = {
9983 (char *) "info", NULL
9984 };
9985
9986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfo",kwnames,&obj0)) goto fail;
9987 {
9988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
9989 if (SWIG_arg_fail(1)) SWIG_fail;
9990 if (arg1 == NULL) {
9991 SWIG_null_ref("wxNativeFontInfo");
9992 }
9993 if (SWIG_arg_fail(1)) SWIG_fail;
9994 }
9995 {
9996 if (!wxPyCheckForApp()) SWIG_fail;
9997 PyThreadState* __tstate = wxPyBeginAllowThreads();
9998 result = (wxFont *)new wxFont((wxNativeFontInfo const &)*arg1);
9999
10000 wxPyEndAllowThreads(__tstate);
10001 if (PyErr_Occurred()) SWIG_fail;
10002 }
10003 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
10004 return resultobj;
10005 fail:
10006 return NULL;
10007 }
10008
10009
10010 static PyObject *_wrap_new_FontFromNativeInfoString(PyObject *, PyObject *args, PyObject *kwargs) {
10011 PyObject *resultobj;
10012 wxString *arg1 = 0 ;
10013 wxFont *result;
10014 bool temp1 = false ;
10015 PyObject * obj0 = 0 ;
10016 char *kwnames[] = {
10017 (char *) "info", NULL
10018 };
10019
10020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfoString",kwnames,&obj0)) goto fail;
10021 {
10022 arg1 = wxString_in_helper(obj0);
10023 if (arg1 == NULL) SWIG_fail;
10024 temp1 = true;
10025 }
10026 {
10027 if (!wxPyCheckForApp()) SWIG_fail;
10028 PyThreadState* __tstate = wxPyBeginAllowThreads();
10029 result = (wxFont *)new_wxFont((wxString const &)*arg1);
10030
10031 wxPyEndAllowThreads(__tstate);
10032 if (PyErr_Occurred()) SWIG_fail;
10033 }
10034 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
10035 {
10036 if (temp1)
10037 delete arg1;
10038 }
10039 return resultobj;
10040 fail:
10041 {
10042 if (temp1)
10043 delete arg1;
10044 }
10045 return NULL;
10046 }
10047
10048
10049 static PyObject *_wrap_new_FFont(PyObject *, PyObject *args, PyObject *kwargs) {
10050 PyObject *resultobj;
10051 int arg1 ;
10052 wxFontFamily arg2 ;
10053 int arg3 = (int) wxFONTFLAG_DEFAULT ;
10054 wxString const &arg4_defvalue = wxPyEmptyString ;
10055 wxString *arg4 = (wxString *) &arg4_defvalue ;
10056 wxFontEncoding arg5 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
10057 wxFont *result;
10058 bool temp4 = false ;
10059 PyObject * obj0 = 0 ;
10060 PyObject * obj1 = 0 ;
10061 PyObject * obj2 = 0 ;
10062 PyObject * obj3 = 0 ;
10063 PyObject * obj4 = 0 ;
10064 char *kwnames[] = {
10065 (char *) "pointSize",(char *) "family",(char *) "flags",(char *) "face",(char *) "encoding", NULL
10066 };
10067
10068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_FFont",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
10069 {
10070 arg1 = (int)(SWIG_As_int(obj0));
10071 if (SWIG_arg_fail(1)) SWIG_fail;
10072 }
10073 {
10074 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
10075 if (SWIG_arg_fail(2)) SWIG_fail;
10076 }
10077 if (obj2) {
10078 {
10079 arg3 = (int)(SWIG_As_int(obj2));
10080 if (SWIG_arg_fail(3)) SWIG_fail;
10081 }
10082 }
10083 if (obj3) {
10084 {
10085 arg4 = wxString_in_helper(obj3);
10086 if (arg4 == NULL) SWIG_fail;
10087 temp4 = true;
10088 }
10089 }
10090 if (obj4) {
10091 {
10092 arg5 = (wxFontEncoding)(SWIG_As_int(obj4));
10093 if (SWIG_arg_fail(5)) SWIG_fail;
10094 }
10095 }
10096 {
10097 if (!wxPyCheckForApp()) SWIG_fail;
10098 PyThreadState* __tstate = wxPyBeginAllowThreads();
10099 result = (wxFont *)new_wxFont(arg1,(wxFontFamily )arg2,arg3,(wxString const &)*arg4,(wxFontEncoding )arg5);
10100
10101 wxPyEndAllowThreads(__tstate);
10102 if (PyErr_Occurred()) SWIG_fail;
10103 }
10104 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
10105 {
10106 if (temp4)
10107 delete arg4;
10108 }
10109 return resultobj;
10110 fail:
10111 {
10112 if (temp4)
10113 delete arg4;
10114 }
10115 return NULL;
10116 }
10117
10118
10119 static PyObject *_wrap_new_FontFromPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
10120 PyObject *resultobj;
10121 wxSize *arg1 = 0 ;
10122 int arg2 ;
10123 int arg3 ;
10124 int arg4 ;
10125 bool arg5 = (bool) false ;
10126 wxString const &arg6_defvalue = wxEmptyString ;
10127 wxString *arg6 = (wxString *) &arg6_defvalue ;
10128 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
10129 wxFont *result;
10130 wxSize temp1 ;
10131 bool temp6 = false ;
10132 PyObject * obj0 = 0 ;
10133 PyObject * obj1 = 0 ;
10134 PyObject * obj2 = 0 ;
10135 PyObject * obj3 = 0 ;
10136 PyObject * obj4 = 0 ;
10137 PyObject * obj5 = 0 ;
10138 PyObject * obj6 = 0 ;
10139 char *kwnames[] = {
10140 (char *) "pixelSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underlined",(char *) "face",(char *) "encoding", NULL
10141 };
10142
10143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_FontFromPixelSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
10144 {
10145 arg1 = &temp1;
10146 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
10147 }
10148 {
10149 arg2 = (int)(SWIG_As_int(obj1));
10150 if (SWIG_arg_fail(2)) SWIG_fail;
10151 }
10152 {
10153 arg3 = (int)(SWIG_As_int(obj2));
10154 if (SWIG_arg_fail(3)) SWIG_fail;
10155 }
10156 {
10157 arg4 = (int)(SWIG_As_int(obj3));
10158 if (SWIG_arg_fail(4)) SWIG_fail;
10159 }
10160 if (obj4) {
10161 {
10162 arg5 = (bool)(SWIG_As_bool(obj4));
10163 if (SWIG_arg_fail(5)) SWIG_fail;
10164 }
10165 }
10166 if (obj5) {
10167 {
10168 arg6 = wxString_in_helper(obj5);
10169 if (arg6 == NULL) SWIG_fail;
10170 temp6 = true;
10171 }
10172 }
10173 if (obj6) {
10174 {
10175 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
10176 if (SWIG_arg_fail(7)) SWIG_fail;
10177 }
10178 }
10179 {
10180 if (!wxPyCheckForApp()) SWIG_fail;
10181 PyThreadState* __tstate = wxPyBeginAllowThreads();
10182 result = (wxFont *)new_wxFont((wxSize const &)*arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
10183
10184 wxPyEndAllowThreads(__tstate);
10185 if (PyErr_Occurred()) SWIG_fail;
10186 }
10187 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
10188 {
10189 if (temp6)
10190 delete arg6;
10191 }
10192 return resultobj;
10193 fail:
10194 {
10195 if (temp6)
10196 delete arg6;
10197 }
10198 return NULL;
10199 }
10200
10201
10202 static PyObject *_wrap_new_FFontFromPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
10203 PyObject *resultobj;
10204 wxSize *arg1 = 0 ;
10205 wxFontFamily arg2 ;
10206 int arg3 = (int) wxFONTFLAG_DEFAULT ;
10207 wxString const &arg4_defvalue = wxEmptyString ;
10208 wxString *arg4 = (wxString *) &arg4_defvalue ;
10209 wxFontEncoding arg5 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
10210 wxFont *result;
10211 wxSize temp1 ;
10212 bool temp4 = false ;
10213 PyObject * obj0 = 0 ;
10214 PyObject * obj1 = 0 ;
10215 PyObject * obj2 = 0 ;
10216 PyObject * obj3 = 0 ;
10217 PyObject * obj4 = 0 ;
10218 char *kwnames[] = {
10219 (char *) "pixelSize",(char *) "family",(char *) "flags",(char *) "face",(char *) "encoding", NULL
10220 };
10221
10222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_FFontFromPixelSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
10223 {
10224 arg1 = &temp1;
10225 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
10226 }
10227 {
10228 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
10229 if (SWIG_arg_fail(2)) SWIG_fail;
10230 }
10231 if (obj2) {
10232 {
10233 arg3 = (int)(SWIG_As_int(obj2));
10234 if (SWIG_arg_fail(3)) SWIG_fail;
10235 }
10236 }
10237 if (obj3) {
10238 {
10239 arg4 = wxString_in_helper(obj3);
10240 if (arg4 == NULL) SWIG_fail;
10241 temp4 = true;
10242 }
10243 }
10244 if (obj4) {
10245 {
10246 arg5 = (wxFontEncoding)(SWIG_As_int(obj4));
10247 if (SWIG_arg_fail(5)) SWIG_fail;
10248 }
10249 }
10250 {
10251 if (!wxPyCheckForApp()) SWIG_fail;
10252 PyThreadState* __tstate = wxPyBeginAllowThreads();
10253 result = (wxFont *)new_wxFont((wxSize const &)*arg1,(wxFontFamily )arg2,arg3,(wxString const &)*arg4,(wxFontEncoding )arg5);
10254
10255 wxPyEndAllowThreads(__tstate);
10256 if (PyErr_Occurred()) SWIG_fail;
10257 }
10258 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
10259 {
10260 if (temp4)
10261 delete arg4;
10262 }
10263 return resultobj;
10264 fail:
10265 {
10266 if (temp4)
10267 delete arg4;
10268 }
10269 return NULL;
10270 }
10271
10272
10273 static PyObject *_wrap_Font_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
10274 PyObject *resultobj;
10275 wxFont *arg1 = (wxFont *) 0 ;
10276 bool result;
10277 PyObject * obj0 = 0 ;
10278 char *kwnames[] = {
10279 (char *) "self", NULL
10280 };
10281
10282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_Ok",kwnames,&obj0)) goto fail;
10283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10284 if (SWIG_arg_fail(1)) SWIG_fail;
10285 {
10286 PyThreadState* __tstate = wxPyBeginAllowThreads();
10287 result = (bool)((wxFont const *)arg1)->Ok();
10288
10289 wxPyEndAllowThreads(__tstate);
10290 if (PyErr_Occurred()) SWIG_fail;
10291 }
10292 {
10293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10294 }
10295 return resultobj;
10296 fail:
10297 return NULL;
10298 }
10299
10300
10301 static PyObject *_wrap_Font___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
10302 PyObject *resultobj;
10303 wxFont *arg1 = (wxFont *) 0 ;
10304 wxFont *arg2 = (wxFont *) 0 ;
10305 bool result;
10306 PyObject * obj0 = 0 ;
10307 PyObject * obj1 = 0 ;
10308 char *kwnames[] = {
10309 (char *) "self",(char *) "other", NULL
10310 };
10311
10312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___eq__",kwnames,&obj0,&obj1)) goto fail;
10313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10314 if (SWIG_arg_fail(1)) SWIG_fail;
10315 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10316 if (SWIG_arg_fail(2)) SWIG_fail;
10317 {
10318 PyThreadState* __tstate = wxPyBeginAllowThreads();
10319 result = (bool)wxFont___eq__(arg1,(wxFont const *)arg2);
10320
10321 wxPyEndAllowThreads(__tstate);
10322 if (PyErr_Occurred()) SWIG_fail;
10323 }
10324 {
10325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10326 }
10327 return resultobj;
10328 fail:
10329 return NULL;
10330 }
10331
10332
10333 static PyObject *_wrap_Font___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
10334 PyObject *resultobj;
10335 wxFont *arg1 = (wxFont *) 0 ;
10336 wxFont *arg2 = (wxFont *) 0 ;
10337 bool result;
10338 PyObject * obj0 = 0 ;
10339 PyObject * obj1 = 0 ;
10340 char *kwnames[] = {
10341 (char *) "self",(char *) "other", NULL
10342 };
10343
10344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___ne__",kwnames,&obj0,&obj1)) goto fail;
10345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10346 if (SWIG_arg_fail(1)) SWIG_fail;
10347 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10348 if (SWIG_arg_fail(2)) SWIG_fail;
10349 {
10350 PyThreadState* __tstate = wxPyBeginAllowThreads();
10351 result = (bool)wxFont___ne__(arg1,(wxFont const *)arg2);
10352
10353 wxPyEndAllowThreads(__tstate);
10354 if (PyErr_Occurred()) SWIG_fail;
10355 }
10356 {
10357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10358 }
10359 return resultobj;
10360 fail:
10361 return NULL;
10362 }
10363
10364
10365 static PyObject *_wrap_Font_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
10366 PyObject *resultobj;
10367 wxFont *arg1 = (wxFont *) 0 ;
10368 int result;
10369 PyObject * obj0 = 0 ;
10370 char *kwnames[] = {
10371 (char *) "self", NULL
10372 };
10373
10374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPointSize",kwnames,&obj0)) goto fail;
10375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10376 if (SWIG_arg_fail(1)) SWIG_fail;
10377 {
10378 PyThreadState* __tstate = wxPyBeginAllowThreads();
10379 result = (int)((wxFont const *)arg1)->GetPointSize();
10380
10381 wxPyEndAllowThreads(__tstate);
10382 if (PyErr_Occurred()) SWIG_fail;
10383 }
10384 {
10385 resultobj = SWIG_From_int((int)(result));
10386 }
10387 return resultobj;
10388 fail:
10389 return NULL;
10390 }
10391
10392
10393 static PyObject *_wrap_Font_GetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
10394 PyObject *resultobj;
10395 wxFont *arg1 = (wxFont *) 0 ;
10396 wxSize result;
10397 PyObject * obj0 = 0 ;
10398 char *kwnames[] = {
10399 (char *) "self", NULL
10400 };
10401
10402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPixelSize",kwnames,&obj0)) goto fail;
10403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10404 if (SWIG_arg_fail(1)) SWIG_fail;
10405 {
10406 PyThreadState* __tstate = wxPyBeginAllowThreads();
10407 result = ((wxFont const *)arg1)->GetPixelSize();
10408
10409 wxPyEndAllowThreads(__tstate);
10410 if (PyErr_Occurred()) SWIG_fail;
10411 }
10412 {
10413 wxSize * resultptr;
10414 resultptr = new wxSize((wxSize &)(result));
10415 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
10416 }
10417 return resultobj;
10418 fail:
10419 return NULL;
10420 }
10421
10422
10423 static PyObject *_wrap_Font_IsUsingSizeInPixels(PyObject *, PyObject *args, PyObject *kwargs) {
10424 PyObject *resultobj;
10425 wxFont *arg1 = (wxFont *) 0 ;
10426 bool result;
10427 PyObject * obj0 = 0 ;
10428 char *kwnames[] = {
10429 (char *) "self", NULL
10430 };
10431
10432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsUsingSizeInPixels",kwnames,&obj0)) goto fail;
10433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10434 if (SWIG_arg_fail(1)) SWIG_fail;
10435 {
10436 PyThreadState* __tstate = wxPyBeginAllowThreads();
10437 result = (bool)((wxFont const *)arg1)->IsUsingSizeInPixels();
10438
10439 wxPyEndAllowThreads(__tstate);
10440 if (PyErr_Occurred()) SWIG_fail;
10441 }
10442 {
10443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10444 }
10445 return resultobj;
10446 fail:
10447 return NULL;
10448 }
10449
10450
10451 static PyObject *_wrap_Font_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
10452 PyObject *resultobj;
10453 wxFont *arg1 = (wxFont *) 0 ;
10454 int result;
10455 PyObject * obj0 = 0 ;
10456 char *kwnames[] = {
10457 (char *) "self", NULL
10458 };
10459
10460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamily",kwnames,&obj0)) goto fail;
10461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10462 if (SWIG_arg_fail(1)) SWIG_fail;
10463 {
10464 PyThreadState* __tstate = wxPyBeginAllowThreads();
10465 result = (int)((wxFont const *)arg1)->GetFamily();
10466
10467 wxPyEndAllowThreads(__tstate);
10468 if (PyErr_Occurred()) SWIG_fail;
10469 }
10470 {
10471 resultobj = SWIG_From_int((int)(result));
10472 }
10473 return resultobj;
10474 fail:
10475 return NULL;
10476 }
10477
10478
10479 static PyObject *_wrap_Font_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
10480 PyObject *resultobj;
10481 wxFont *arg1 = (wxFont *) 0 ;
10482 int result;
10483 PyObject * obj0 = 0 ;
10484 char *kwnames[] = {
10485 (char *) "self", NULL
10486 };
10487
10488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyle",kwnames,&obj0)) goto fail;
10489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10490 if (SWIG_arg_fail(1)) SWIG_fail;
10491 {
10492 PyThreadState* __tstate = wxPyBeginAllowThreads();
10493 result = (int)((wxFont const *)arg1)->GetStyle();
10494
10495 wxPyEndAllowThreads(__tstate);
10496 if (PyErr_Occurred()) SWIG_fail;
10497 }
10498 {
10499 resultobj = SWIG_From_int((int)(result));
10500 }
10501 return resultobj;
10502 fail:
10503 return NULL;
10504 }
10505
10506
10507 static PyObject *_wrap_Font_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
10508 PyObject *resultobj;
10509 wxFont *arg1 = (wxFont *) 0 ;
10510 int result;
10511 PyObject * obj0 = 0 ;
10512 char *kwnames[] = {
10513 (char *) "self", NULL
10514 };
10515
10516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeight",kwnames,&obj0)) goto fail;
10517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10518 if (SWIG_arg_fail(1)) SWIG_fail;
10519 {
10520 PyThreadState* __tstate = wxPyBeginAllowThreads();
10521 result = (int)((wxFont const *)arg1)->GetWeight();
10522
10523 wxPyEndAllowThreads(__tstate);
10524 if (PyErr_Occurred()) SWIG_fail;
10525 }
10526 {
10527 resultobj = SWIG_From_int((int)(result));
10528 }
10529 return resultobj;
10530 fail:
10531 return NULL;
10532 }
10533
10534
10535 static PyObject *_wrap_Font_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
10536 PyObject *resultobj;
10537 wxFont *arg1 = (wxFont *) 0 ;
10538 bool result;
10539 PyObject * obj0 = 0 ;
10540 char *kwnames[] = {
10541 (char *) "self", NULL
10542 };
10543
10544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetUnderlined",kwnames,&obj0)) goto fail;
10545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10546 if (SWIG_arg_fail(1)) SWIG_fail;
10547 {
10548 PyThreadState* __tstate = wxPyBeginAllowThreads();
10549 result = (bool)((wxFont const *)arg1)->GetUnderlined();
10550
10551 wxPyEndAllowThreads(__tstate);
10552 if (PyErr_Occurred()) SWIG_fail;
10553 }
10554 {
10555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10556 }
10557 return resultobj;
10558 fail:
10559 return NULL;
10560 }
10561
10562
10563 static PyObject *_wrap_Font_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
10564 PyObject *resultobj;
10565 wxFont *arg1 = (wxFont *) 0 ;
10566 wxString result;
10567 PyObject * obj0 = 0 ;
10568 char *kwnames[] = {
10569 (char *) "self", NULL
10570 };
10571
10572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFaceName",kwnames,&obj0)) goto fail;
10573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10574 if (SWIG_arg_fail(1)) SWIG_fail;
10575 {
10576 PyThreadState* __tstate = wxPyBeginAllowThreads();
10577 result = ((wxFont const *)arg1)->GetFaceName();
10578
10579 wxPyEndAllowThreads(__tstate);
10580 if (PyErr_Occurred()) SWIG_fail;
10581 }
10582 {
10583 #if wxUSE_UNICODE
10584 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10585 #else
10586 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10587 #endif
10588 }
10589 return resultobj;
10590 fail:
10591 return NULL;
10592 }
10593
10594
10595 static PyObject *_wrap_Font_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10596 PyObject *resultobj;
10597 wxFont *arg1 = (wxFont *) 0 ;
10598 wxFontEncoding result;
10599 PyObject * obj0 = 0 ;
10600 char *kwnames[] = {
10601 (char *) "self", NULL
10602 };
10603
10604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetEncoding",kwnames,&obj0)) goto fail;
10605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10606 if (SWIG_arg_fail(1)) SWIG_fail;
10607 {
10608 PyThreadState* __tstate = wxPyBeginAllowThreads();
10609 result = (wxFontEncoding)((wxFont const *)arg1)->GetEncoding();
10610
10611 wxPyEndAllowThreads(__tstate);
10612 if (PyErr_Occurred()) SWIG_fail;
10613 }
10614 resultobj = SWIG_From_int((result));
10615 return resultobj;
10616 fail:
10617 return NULL;
10618 }
10619
10620
10621 static PyObject *_wrap_Font_GetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10622 PyObject *resultobj;
10623 wxFont *arg1 = (wxFont *) 0 ;
10624 wxNativeFontInfo *result;
10625 PyObject * obj0 = 0 ;
10626 char *kwnames[] = {
10627 (char *) "self", NULL
10628 };
10629
10630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfo",kwnames,&obj0)) goto fail;
10631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10632 if (SWIG_arg_fail(1)) SWIG_fail;
10633 {
10634 PyThreadState* __tstate = wxPyBeginAllowThreads();
10635 result = (wxNativeFontInfo *)((wxFont const *)arg1)->GetNativeFontInfo();
10636
10637 wxPyEndAllowThreads(__tstate);
10638 if (PyErr_Occurred()) SWIG_fail;
10639 }
10640 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 0);
10641 return resultobj;
10642 fail:
10643 return NULL;
10644 }
10645
10646
10647 static PyObject *_wrap_Font_IsFixedWidth(PyObject *, PyObject *args, PyObject *kwargs) {
10648 PyObject *resultobj;
10649 wxFont *arg1 = (wxFont *) 0 ;
10650 bool result;
10651 PyObject * obj0 = 0 ;
10652 char *kwnames[] = {
10653 (char *) "self", NULL
10654 };
10655
10656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsFixedWidth",kwnames,&obj0)) goto fail;
10657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10658 if (SWIG_arg_fail(1)) SWIG_fail;
10659 {
10660 PyThreadState* __tstate = wxPyBeginAllowThreads();
10661 result = (bool)((wxFont const *)arg1)->IsFixedWidth();
10662
10663 wxPyEndAllowThreads(__tstate);
10664 if (PyErr_Occurred()) SWIG_fail;
10665 }
10666 {
10667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10668 }
10669 return resultobj;
10670 fail:
10671 return NULL;
10672 }
10673
10674
10675 static PyObject *_wrap_Font_GetNativeFontInfoDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10676 PyObject *resultobj;
10677 wxFont *arg1 = (wxFont *) 0 ;
10678 wxString result;
10679 PyObject * obj0 = 0 ;
10680 char *kwnames[] = {
10681 (char *) "self", NULL
10682 };
10683
10684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoDesc",kwnames,&obj0)) goto fail;
10685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10686 if (SWIG_arg_fail(1)) SWIG_fail;
10687 {
10688 PyThreadState* __tstate = wxPyBeginAllowThreads();
10689 result = ((wxFont const *)arg1)->GetNativeFontInfoDesc();
10690
10691 wxPyEndAllowThreads(__tstate);
10692 if (PyErr_Occurred()) SWIG_fail;
10693 }
10694 {
10695 #if wxUSE_UNICODE
10696 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10697 #else
10698 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10699 #endif
10700 }
10701 return resultobj;
10702 fail:
10703 return NULL;
10704 }
10705
10706
10707 static PyObject *_wrap_Font_GetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10708 PyObject *resultobj;
10709 wxFont *arg1 = (wxFont *) 0 ;
10710 wxString result;
10711 PyObject * obj0 = 0 ;
10712 char *kwnames[] = {
10713 (char *) "self", NULL
10714 };
10715
10716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoUserDesc",kwnames,&obj0)) goto fail;
10717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10718 if (SWIG_arg_fail(1)) SWIG_fail;
10719 {
10720 PyThreadState* __tstate = wxPyBeginAllowThreads();
10721 result = ((wxFont const *)arg1)->GetNativeFontInfoUserDesc();
10722
10723 wxPyEndAllowThreads(__tstate);
10724 if (PyErr_Occurred()) SWIG_fail;
10725 }
10726 {
10727 #if wxUSE_UNICODE
10728 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10729 #else
10730 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10731 #endif
10732 }
10733 return resultobj;
10734 fail:
10735 return NULL;
10736 }
10737
10738
10739 static PyObject *_wrap_Font_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
10740 PyObject *resultobj;
10741 wxFont *arg1 = (wxFont *) 0 ;
10742 int arg2 ;
10743 PyObject * obj0 = 0 ;
10744 PyObject * obj1 = 0 ;
10745 char *kwnames[] = {
10746 (char *) "self",(char *) "pointSize", NULL
10747 };
10748
10749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
10750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10751 if (SWIG_arg_fail(1)) SWIG_fail;
10752 {
10753 arg2 = (int)(SWIG_As_int(obj1));
10754 if (SWIG_arg_fail(2)) SWIG_fail;
10755 }
10756 {
10757 PyThreadState* __tstate = wxPyBeginAllowThreads();
10758 (arg1)->SetPointSize(arg2);
10759
10760 wxPyEndAllowThreads(__tstate);
10761 if (PyErr_Occurred()) SWIG_fail;
10762 }
10763 Py_INCREF(Py_None); resultobj = Py_None;
10764 return resultobj;
10765 fail:
10766 return NULL;
10767 }
10768
10769
10770 static PyObject *_wrap_Font_SetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
10771 PyObject *resultobj;
10772 wxFont *arg1 = (wxFont *) 0 ;
10773 wxSize *arg2 = 0 ;
10774 wxSize temp2 ;
10775 PyObject * obj0 = 0 ;
10776 PyObject * obj1 = 0 ;
10777 char *kwnames[] = {
10778 (char *) "self",(char *) "pixelSize", NULL
10779 };
10780
10781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPixelSize",kwnames,&obj0,&obj1)) goto fail;
10782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10783 if (SWIG_arg_fail(1)) SWIG_fail;
10784 {
10785 arg2 = &temp2;
10786 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
10787 }
10788 {
10789 PyThreadState* __tstate = wxPyBeginAllowThreads();
10790 (arg1)->SetPixelSize((wxSize const &)*arg2);
10791
10792 wxPyEndAllowThreads(__tstate);
10793 if (PyErr_Occurred()) SWIG_fail;
10794 }
10795 Py_INCREF(Py_None); resultobj = Py_None;
10796 return resultobj;
10797 fail:
10798 return NULL;
10799 }
10800
10801
10802 static PyObject *_wrap_Font_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
10803 PyObject *resultobj;
10804 wxFont *arg1 = (wxFont *) 0 ;
10805 int arg2 ;
10806 PyObject * obj0 = 0 ;
10807 PyObject * obj1 = 0 ;
10808 char *kwnames[] = {
10809 (char *) "self",(char *) "family", NULL
10810 };
10811
10812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFamily",kwnames,&obj0,&obj1)) goto fail;
10813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10814 if (SWIG_arg_fail(1)) SWIG_fail;
10815 {
10816 arg2 = (int)(SWIG_As_int(obj1));
10817 if (SWIG_arg_fail(2)) SWIG_fail;
10818 }
10819 {
10820 PyThreadState* __tstate = wxPyBeginAllowThreads();
10821 (arg1)->SetFamily(arg2);
10822
10823 wxPyEndAllowThreads(__tstate);
10824 if (PyErr_Occurred()) SWIG_fail;
10825 }
10826 Py_INCREF(Py_None); resultobj = Py_None;
10827 return resultobj;
10828 fail:
10829 return NULL;
10830 }
10831
10832
10833 static PyObject *_wrap_Font_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
10834 PyObject *resultobj;
10835 wxFont *arg1 = (wxFont *) 0 ;
10836 int arg2 ;
10837 PyObject * obj0 = 0 ;
10838 PyObject * obj1 = 0 ;
10839 char *kwnames[] = {
10840 (char *) "self",(char *) "style", NULL
10841 };
10842
10843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetStyle",kwnames,&obj0,&obj1)) goto fail;
10844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10845 if (SWIG_arg_fail(1)) SWIG_fail;
10846 {
10847 arg2 = (int)(SWIG_As_int(obj1));
10848 if (SWIG_arg_fail(2)) SWIG_fail;
10849 }
10850 {
10851 PyThreadState* __tstate = wxPyBeginAllowThreads();
10852 (arg1)->SetStyle(arg2);
10853
10854 wxPyEndAllowThreads(__tstate);
10855 if (PyErr_Occurred()) SWIG_fail;
10856 }
10857 Py_INCREF(Py_None); resultobj = Py_None;
10858 return resultobj;
10859 fail:
10860 return NULL;
10861 }
10862
10863
10864 static PyObject *_wrap_Font_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
10865 PyObject *resultobj;
10866 wxFont *arg1 = (wxFont *) 0 ;
10867 int arg2 ;
10868 PyObject * obj0 = 0 ;
10869 PyObject * obj1 = 0 ;
10870 char *kwnames[] = {
10871 (char *) "self",(char *) "weight", NULL
10872 };
10873
10874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetWeight",kwnames,&obj0,&obj1)) goto fail;
10875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10876 if (SWIG_arg_fail(1)) SWIG_fail;
10877 {
10878 arg2 = (int)(SWIG_As_int(obj1));
10879 if (SWIG_arg_fail(2)) SWIG_fail;
10880 }
10881 {
10882 PyThreadState* __tstate = wxPyBeginAllowThreads();
10883 (arg1)->SetWeight(arg2);
10884
10885 wxPyEndAllowThreads(__tstate);
10886 if (PyErr_Occurred()) SWIG_fail;
10887 }
10888 Py_INCREF(Py_None); resultobj = Py_None;
10889 return resultobj;
10890 fail:
10891 return NULL;
10892 }
10893
10894
10895 static PyObject *_wrap_Font_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
10896 PyObject *resultobj;
10897 wxFont *arg1 = (wxFont *) 0 ;
10898 wxString *arg2 = 0 ;
10899 bool temp2 = false ;
10900 PyObject * obj0 = 0 ;
10901 PyObject * obj1 = 0 ;
10902 char *kwnames[] = {
10903 (char *) "self",(char *) "faceName", NULL
10904 };
10905
10906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
10907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10908 if (SWIG_arg_fail(1)) SWIG_fail;
10909 {
10910 arg2 = wxString_in_helper(obj1);
10911 if (arg2 == NULL) SWIG_fail;
10912 temp2 = true;
10913 }
10914 {
10915 PyThreadState* __tstate = wxPyBeginAllowThreads();
10916 (arg1)->SetFaceName((wxString const &)*arg2);
10917
10918 wxPyEndAllowThreads(__tstate);
10919 if (PyErr_Occurred()) SWIG_fail;
10920 }
10921 Py_INCREF(Py_None); resultobj = Py_None;
10922 {
10923 if (temp2)
10924 delete arg2;
10925 }
10926 return resultobj;
10927 fail:
10928 {
10929 if (temp2)
10930 delete arg2;
10931 }
10932 return NULL;
10933 }
10934
10935
10936 static PyObject *_wrap_Font_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
10937 PyObject *resultobj;
10938 wxFont *arg1 = (wxFont *) 0 ;
10939 bool arg2 ;
10940 PyObject * obj0 = 0 ;
10941 PyObject * obj1 = 0 ;
10942 char *kwnames[] = {
10943 (char *) "self",(char *) "underlined", NULL
10944 };
10945
10946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
10947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10948 if (SWIG_arg_fail(1)) SWIG_fail;
10949 {
10950 arg2 = (bool)(SWIG_As_bool(obj1));
10951 if (SWIG_arg_fail(2)) SWIG_fail;
10952 }
10953 {
10954 PyThreadState* __tstate = wxPyBeginAllowThreads();
10955 (arg1)->SetUnderlined(arg2);
10956
10957 wxPyEndAllowThreads(__tstate);
10958 if (PyErr_Occurred()) SWIG_fail;
10959 }
10960 Py_INCREF(Py_None); resultobj = Py_None;
10961 return resultobj;
10962 fail:
10963 return NULL;
10964 }
10965
10966
10967 static PyObject *_wrap_Font_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10968 PyObject *resultobj;
10969 wxFont *arg1 = (wxFont *) 0 ;
10970 wxFontEncoding arg2 ;
10971 PyObject * obj0 = 0 ;
10972 PyObject * obj1 = 0 ;
10973 char *kwnames[] = {
10974 (char *) "self",(char *) "encoding", NULL
10975 };
10976
10977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
10978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10979 if (SWIG_arg_fail(1)) SWIG_fail;
10980 {
10981 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
10982 if (SWIG_arg_fail(2)) SWIG_fail;
10983 }
10984 {
10985 PyThreadState* __tstate = wxPyBeginAllowThreads();
10986 (arg1)->SetEncoding((wxFontEncoding )arg2);
10987
10988 wxPyEndAllowThreads(__tstate);
10989 if (PyErr_Occurred()) SWIG_fail;
10990 }
10991 Py_INCREF(Py_None); resultobj = Py_None;
10992 return resultobj;
10993 fail:
10994 return NULL;
10995 }
10996
10997
10998 static PyObject *_wrap_Font_SetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10999 PyObject *resultobj;
11000 wxFont *arg1 = (wxFont *) 0 ;
11001 wxNativeFontInfo *arg2 = 0 ;
11002 PyObject * obj0 = 0 ;
11003 PyObject * obj1 = 0 ;
11004 char *kwnames[] = {
11005 (char *) "self",(char *) "info", NULL
11006 };
11007
11008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfo",kwnames,&obj0,&obj1)) goto fail;
11009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11010 if (SWIG_arg_fail(1)) SWIG_fail;
11011 {
11012 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
11013 if (SWIG_arg_fail(2)) SWIG_fail;
11014 if (arg2 == NULL) {
11015 SWIG_null_ref("wxNativeFontInfo");
11016 }
11017 if (SWIG_arg_fail(2)) SWIG_fail;
11018 }
11019 {
11020 PyThreadState* __tstate = wxPyBeginAllowThreads();
11021 (arg1)->SetNativeFontInfo((wxNativeFontInfo const &)*arg2);
11022
11023 wxPyEndAllowThreads(__tstate);
11024 if (PyErr_Occurred()) SWIG_fail;
11025 }
11026 Py_INCREF(Py_None); resultobj = Py_None;
11027 return resultobj;
11028 fail:
11029 return NULL;
11030 }
11031
11032
11033 static PyObject *_wrap_Font_SetNativeFontInfoFromString(PyObject *, PyObject *args, PyObject *kwargs) {
11034 PyObject *resultobj;
11035 wxFont *arg1 = (wxFont *) 0 ;
11036 wxString *arg2 = 0 ;
11037 bool temp2 = false ;
11038 PyObject * obj0 = 0 ;
11039 PyObject * obj1 = 0 ;
11040 char *kwnames[] = {
11041 (char *) "self",(char *) "info", NULL
11042 };
11043
11044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoFromString",kwnames,&obj0,&obj1)) goto fail;
11045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11046 if (SWIG_arg_fail(1)) SWIG_fail;
11047 {
11048 arg2 = wxString_in_helper(obj1);
11049 if (arg2 == NULL) SWIG_fail;
11050 temp2 = true;
11051 }
11052 {
11053 PyThreadState* __tstate = wxPyBeginAllowThreads();
11054 (arg1)->SetNativeFontInfo((wxString const &)*arg2);
11055
11056 wxPyEndAllowThreads(__tstate);
11057 if (PyErr_Occurred()) SWIG_fail;
11058 }
11059 Py_INCREF(Py_None); resultobj = Py_None;
11060 {
11061 if (temp2)
11062 delete arg2;
11063 }
11064 return resultobj;
11065 fail:
11066 {
11067 if (temp2)
11068 delete arg2;
11069 }
11070 return NULL;
11071 }
11072
11073
11074 static PyObject *_wrap_Font_SetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
11075 PyObject *resultobj;
11076 wxFont *arg1 = (wxFont *) 0 ;
11077 wxString *arg2 = 0 ;
11078 bool temp2 = false ;
11079 PyObject * obj0 = 0 ;
11080 PyObject * obj1 = 0 ;
11081 char *kwnames[] = {
11082 (char *) "self",(char *) "info", NULL
11083 };
11084
11085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoUserDesc",kwnames,&obj0,&obj1)) goto fail;
11086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11087 if (SWIG_arg_fail(1)) SWIG_fail;
11088 {
11089 arg2 = wxString_in_helper(obj1);
11090 if (arg2 == NULL) SWIG_fail;
11091 temp2 = true;
11092 }
11093 {
11094 PyThreadState* __tstate = wxPyBeginAllowThreads();
11095 (arg1)->SetNativeFontInfoUserDesc((wxString const &)*arg2);
11096
11097 wxPyEndAllowThreads(__tstate);
11098 if (PyErr_Occurred()) SWIG_fail;
11099 }
11100 Py_INCREF(Py_None); resultobj = Py_None;
11101 {
11102 if (temp2)
11103 delete arg2;
11104 }
11105 return resultobj;
11106 fail:
11107 {
11108 if (temp2)
11109 delete arg2;
11110 }
11111 return NULL;
11112 }
11113
11114
11115 static PyObject *_wrap_Font_GetFamilyString(PyObject *, PyObject *args, PyObject *kwargs) {
11116 PyObject *resultobj;
11117 wxFont *arg1 = (wxFont *) 0 ;
11118 wxString result;
11119 PyObject * obj0 = 0 ;
11120 char *kwnames[] = {
11121 (char *) "self", NULL
11122 };
11123
11124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamilyString",kwnames,&obj0)) goto fail;
11125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11126 if (SWIG_arg_fail(1)) SWIG_fail;
11127 {
11128 PyThreadState* __tstate = wxPyBeginAllowThreads();
11129 result = ((wxFont const *)arg1)->GetFamilyString();
11130
11131 wxPyEndAllowThreads(__tstate);
11132 if (PyErr_Occurred()) SWIG_fail;
11133 }
11134 {
11135 #if wxUSE_UNICODE
11136 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11137 #else
11138 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11139 #endif
11140 }
11141 return resultobj;
11142 fail:
11143 return NULL;
11144 }
11145
11146
11147 static PyObject *_wrap_Font_GetStyleString(PyObject *, PyObject *args, PyObject *kwargs) {
11148 PyObject *resultobj;
11149 wxFont *arg1 = (wxFont *) 0 ;
11150 wxString result;
11151 PyObject * obj0 = 0 ;
11152 char *kwnames[] = {
11153 (char *) "self", NULL
11154 };
11155
11156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyleString",kwnames,&obj0)) goto fail;
11157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11158 if (SWIG_arg_fail(1)) SWIG_fail;
11159 {
11160 PyThreadState* __tstate = wxPyBeginAllowThreads();
11161 result = ((wxFont const *)arg1)->GetStyleString();
11162
11163 wxPyEndAllowThreads(__tstate);
11164 if (PyErr_Occurred()) SWIG_fail;
11165 }
11166 {
11167 #if wxUSE_UNICODE
11168 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11169 #else
11170 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11171 #endif
11172 }
11173 return resultobj;
11174 fail:
11175 return NULL;
11176 }
11177
11178
11179 static PyObject *_wrap_Font_GetWeightString(PyObject *, PyObject *args, PyObject *kwargs) {
11180 PyObject *resultobj;
11181 wxFont *arg1 = (wxFont *) 0 ;
11182 wxString result;
11183 PyObject * obj0 = 0 ;
11184 char *kwnames[] = {
11185 (char *) "self", NULL
11186 };
11187
11188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeightString",kwnames,&obj0)) goto fail;
11189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11190 if (SWIG_arg_fail(1)) SWIG_fail;
11191 {
11192 PyThreadState* __tstate = wxPyBeginAllowThreads();
11193 result = ((wxFont const *)arg1)->GetWeightString();
11194
11195 wxPyEndAllowThreads(__tstate);
11196 if (PyErr_Occurred()) SWIG_fail;
11197 }
11198 {
11199 #if wxUSE_UNICODE
11200 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11201 #else
11202 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11203 #endif
11204 }
11205 return resultobj;
11206 fail:
11207 return NULL;
11208 }
11209
11210
11211 static PyObject *_wrap_Font_SetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
11212 PyObject *resultobj;
11213 wxFont *arg1 = (wxFont *) 0 ;
11214 bool arg2 = (bool) true ;
11215 PyObject * obj0 = 0 ;
11216 PyObject * obj1 = 0 ;
11217 char *kwnames[] = {
11218 (char *) "self",(char *) "no", NULL
11219 };
11220
11221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Font_SetNoAntiAliasing",kwnames,&obj0,&obj1)) goto fail;
11222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11223 if (SWIG_arg_fail(1)) SWIG_fail;
11224 if (obj1) {
11225 {
11226 arg2 = (bool)(SWIG_As_bool(obj1));
11227 if (SWIG_arg_fail(2)) SWIG_fail;
11228 }
11229 }
11230 {
11231 PyThreadState* __tstate = wxPyBeginAllowThreads();
11232 (arg1)->SetNoAntiAliasing(arg2);
11233
11234 wxPyEndAllowThreads(__tstate);
11235 if (PyErr_Occurred()) SWIG_fail;
11236 }
11237 Py_INCREF(Py_None); resultobj = Py_None;
11238 return resultobj;
11239 fail:
11240 return NULL;
11241 }
11242
11243
11244 static PyObject *_wrap_Font_GetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
11245 PyObject *resultobj;
11246 wxFont *arg1 = (wxFont *) 0 ;
11247 bool result;
11248 PyObject * obj0 = 0 ;
11249 char *kwnames[] = {
11250 (char *) "self", NULL
11251 };
11252
11253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNoAntiAliasing",kwnames,&obj0)) goto fail;
11254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11255 if (SWIG_arg_fail(1)) SWIG_fail;
11256 {
11257 PyThreadState* __tstate = wxPyBeginAllowThreads();
11258 result = (bool)((wxFont const *)arg1)->GetNoAntiAliasing();
11259
11260 wxPyEndAllowThreads(__tstate);
11261 if (PyErr_Occurred()) SWIG_fail;
11262 }
11263 {
11264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11265 }
11266 return resultobj;
11267 fail:
11268 return NULL;
11269 }
11270
11271
11272 static PyObject *_wrap_Font_GetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
11273 PyObject *resultobj;
11274 wxFontEncoding result;
11275 char *kwnames[] = {
11276 NULL
11277 };
11278
11279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Font_GetDefaultEncoding",kwnames)) goto fail;
11280 {
11281 if (!wxPyCheckForApp()) SWIG_fail;
11282 PyThreadState* __tstate = wxPyBeginAllowThreads();
11283 result = (wxFontEncoding)wxFont::GetDefaultEncoding();
11284
11285 wxPyEndAllowThreads(__tstate);
11286 if (PyErr_Occurred()) SWIG_fail;
11287 }
11288 resultobj = SWIG_From_int((result));
11289 return resultobj;
11290 fail:
11291 return NULL;
11292 }
11293
11294
11295 static PyObject *_wrap_Font_SetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
11296 PyObject *resultobj;
11297 wxFontEncoding arg1 ;
11298 PyObject * obj0 = 0 ;
11299 char *kwnames[] = {
11300 (char *) "encoding", NULL
11301 };
11302
11303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_SetDefaultEncoding",kwnames,&obj0)) goto fail;
11304 {
11305 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
11306 if (SWIG_arg_fail(1)) SWIG_fail;
11307 }
11308 {
11309 if (!wxPyCheckForApp()) SWIG_fail;
11310 PyThreadState* __tstate = wxPyBeginAllowThreads();
11311 wxFont::SetDefaultEncoding((wxFontEncoding )arg1);
11312
11313 wxPyEndAllowThreads(__tstate);
11314 if (PyErr_Occurred()) SWIG_fail;
11315 }
11316 Py_INCREF(Py_None); resultobj = Py_None;
11317 return resultobj;
11318 fail:
11319 return NULL;
11320 }
11321
11322
11323 static PyObject * Font_swigregister(PyObject *, PyObject *args) {
11324 PyObject *obj;
11325 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11326 SWIG_TypeClientData(SWIGTYPE_p_wxFont, obj);
11327 Py_INCREF(obj);
11328 return Py_BuildValue((char *)"");
11329 }
11330 static PyObject *_wrap_new_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
11331 PyObject *resultobj;
11332 wxPyFontEnumerator *result;
11333 char *kwnames[] = {
11334 NULL
11335 };
11336
11337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontEnumerator",kwnames)) goto fail;
11338 {
11339 if (!wxPyCheckForApp()) SWIG_fail;
11340 PyThreadState* __tstate = wxPyBeginAllowThreads();
11341 result = (wxPyFontEnumerator *)new wxPyFontEnumerator();
11342
11343 wxPyEndAllowThreads(__tstate);
11344 if (PyErr_Occurred()) SWIG_fail;
11345 }
11346 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFontEnumerator, 1);
11347 return resultobj;
11348 fail:
11349 return NULL;
11350 }
11351
11352
11353 static PyObject *_wrap_delete_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
11354 PyObject *resultobj;
11355 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11356 PyObject * obj0 = 0 ;
11357 char *kwnames[] = {
11358 (char *) "self", NULL
11359 };
11360
11361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontEnumerator",kwnames,&obj0)) goto fail;
11362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11363 if (SWIG_arg_fail(1)) SWIG_fail;
11364 {
11365 PyThreadState* __tstate = wxPyBeginAllowThreads();
11366 delete arg1;
11367
11368 wxPyEndAllowThreads(__tstate);
11369 if (PyErr_Occurred()) SWIG_fail;
11370 }
11371 Py_INCREF(Py_None); resultobj = Py_None;
11372 return resultobj;
11373 fail:
11374 return NULL;
11375 }
11376
11377
11378 static PyObject *_wrap_FontEnumerator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11379 PyObject *resultobj;
11380 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11381 PyObject *arg2 = (PyObject *) 0 ;
11382 PyObject *arg3 = (PyObject *) 0 ;
11383 bool arg4 ;
11384 PyObject * obj0 = 0 ;
11385 PyObject * obj1 = 0 ;
11386 PyObject * obj2 = 0 ;
11387 PyObject * obj3 = 0 ;
11388 char *kwnames[] = {
11389 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
11390 };
11391
11392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FontEnumerator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11394 if (SWIG_arg_fail(1)) SWIG_fail;
11395 arg2 = obj1;
11396 arg3 = obj2;
11397 {
11398 arg4 = (bool)(SWIG_As_bool(obj3));
11399 if (SWIG_arg_fail(4)) SWIG_fail;
11400 }
11401 {
11402 PyThreadState* __tstate = wxPyBeginAllowThreads();
11403 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
11404
11405 wxPyEndAllowThreads(__tstate);
11406 if (PyErr_Occurred()) SWIG_fail;
11407 }
11408 Py_INCREF(Py_None); resultobj = Py_None;
11409 return resultobj;
11410 fail:
11411 return NULL;
11412 }
11413
11414
11415 static PyObject *_wrap_FontEnumerator_EnumerateFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
11416 PyObject *resultobj;
11417 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11418 wxFontEncoding arg2 = (wxFontEncoding) wxFONTENCODING_SYSTEM ;
11419 bool arg3 = (bool) false ;
11420 bool result;
11421 PyObject * obj0 = 0 ;
11422 PyObject * obj1 = 0 ;
11423 PyObject * obj2 = 0 ;
11424 char *kwnames[] = {
11425 (char *) "self",(char *) "encoding",(char *) "fixedWidthOnly", NULL
11426 };
11427
11428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FontEnumerator_EnumerateFacenames",kwnames,&obj0,&obj1,&obj2)) goto fail;
11429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11430 if (SWIG_arg_fail(1)) SWIG_fail;
11431 if (obj1) {
11432 {
11433 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
11434 if (SWIG_arg_fail(2)) SWIG_fail;
11435 }
11436 }
11437 if (obj2) {
11438 {
11439 arg3 = (bool)(SWIG_As_bool(obj2));
11440 if (SWIG_arg_fail(3)) SWIG_fail;
11441 }
11442 }
11443 {
11444 PyThreadState* __tstate = wxPyBeginAllowThreads();
11445 result = (bool)(arg1)->EnumerateFacenames((wxFontEncoding )arg2,arg3);
11446
11447 wxPyEndAllowThreads(__tstate);
11448 if (PyErr_Occurred()) SWIG_fail;
11449 }
11450 {
11451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11452 }
11453 return resultobj;
11454 fail:
11455 return NULL;
11456 }
11457
11458
11459 static PyObject *_wrap_FontEnumerator_EnumerateEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
11460 PyObject *resultobj;
11461 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11462 wxString const &arg2_defvalue = wxPyEmptyString ;
11463 wxString *arg2 = (wxString *) &arg2_defvalue ;
11464 bool result;
11465 bool temp2 = false ;
11466 PyObject * obj0 = 0 ;
11467 PyObject * obj1 = 0 ;
11468 char *kwnames[] = {
11469 (char *) "self",(char *) "facename", NULL
11470 };
11471
11472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FontEnumerator_EnumerateEncodings",kwnames,&obj0,&obj1)) goto fail;
11473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11474 if (SWIG_arg_fail(1)) SWIG_fail;
11475 if (obj1) {
11476 {
11477 arg2 = wxString_in_helper(obj1);
11478 if (arg2 == NULL) SWIG_fail;
11479 temp2 = true;
11480 }
11481 }
11482 {
11483 PyThreadState* __tstate = wxPyBeginAllowThreads();
11484 result = (bool)(arg1)->EnumerateEncodings((wxString const &)*arg2);
11485
11486 wxPyEndAllowThreads(__tstate);
11487 if (PyErr_Occurred()) SWIG_fail;
11488 }
11489 {
11490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11491 }
11492 {
11493 if (temp2)
11494 delete arg2;
11495 }
11496 return resultobj;
11497 fail:
11498 {
11499 if (temp2)
11500 delete arg2;
11501 }
11502 return NULL;
11503 }
11504
11505
11506 static PyObject *_wrap_FontEnumerator_GetEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
11507 PyObject *resultobj;
11508 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11509 PyObject *result;
11510 PyObject * obj0 = 0 ;
11511 char *kwnames[] = {
11512 (char *) "self", NULL
11513 };
11514
11515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetEncodings",kwnames,&obj0)) goto fail;
11516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11517 if (SWIG_arg_fail(1)) SWIG_fail;
11518 {
11519 PyThreadState* __tstate = wxPyBeginAllowThreads();
11520 result = (PyObject *)wxPyFontEnumerator_GetEncodings(arg1);
11521
11522 wxPyEndAllowThreads(__tstate);
11523 if (PyErr_Occurred()) SWIG_fail;
11524 }
11525 resultobj = result;
11526 return resultobj;
11527 fail:
11528 return NULL;
11529 }
11530
11531
11532 static PyObject *_wrap_FontEnumerator_GetFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
11533 PyObject *resultobj;
11534 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11535 PyObject *result;
11536 PyObject * obj0 = 0 ;
11537 char *kwnames[] = {
11538 (char *) "self", NULL
11539 };
11540
11541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetFacenames",kwnames,&obj0)) goto fail;
11542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11543 if (SWIG_arg_fail(1)) SWIG_fail;
11544 {
11545 PyThreadState* __tstate = wxPyBeginAllowThreads();
11546 result = (PyObject *)wxPyFontEnumerator_GetFacenames(arg1);
11547
11548 wxPyEndAllowThreads(__tstate);
11549 if (PyErr_Occurred()) SWIG_fail;
11550 }
11551 resultobj = result;
11552 return resultobj;
11553 fail:
11554 return NULL;
11555 }
11556
11557
11558 static PyObject * FontEnumerator_swigregister(PyObject *, PyObject *args) {
11559 PyObject *obj;
11560 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11561 SWIG_TypeClientData(SWIGTYPE_p_wxPyFontEnumerator, obj);
11562 Py_INCREF(obj);
11563 return Py_BuildValue((char *)"");
11564 }
11565 static PyObject *_wrap_LanguageInfo_Language_set(PyObject *, PyObject *args, PyObject *kwargs) {
11566 PyObject *resultobj;
11567 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11568 int arg2 ;
11569 PyObject * obj0 = 0 ;
11570 PyObject * obj1 = 0 ;
11571 char *kwnames[] = {
11572 (char *) "self",(char *) "Language", NULL
11573 };
11574
11575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Language_set",kwnames,&obj0,&obj1)) goto fail;
11576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11577 if (SWIG_arg_fail(1)) SWIG_fail;
11578 {
11579 arg2 = (int)(SWIG_As_int(obj1));
11580 if (SWIG_arg_fail(2)) SWIG_fail;
11581 }
11582 if (arg1) (arg1)->Language = arg2;
11583
11584 Py_INCREF(Py_None); resultobj = Py_None;
11585 return resultobj;
11586 fail:
11587 return NULL;
11588 }
11589
11590
11591 static PyObject *_wrap_LanguageInfo_Language_get(PyObject *, PyObject *args, PyObject *kwargs) {
11592 PyObject *resultobj;
11593 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11594 int result;
11595 PyObject * obj0 = 0 ;
11596 char *kwnames[] = {
11597 (char *) "self", NULL
11598 };
11599
11600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Language_get",kwnames,&obj0)) goto fail;
11601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11602 if (SWIG_arg_fail(1)) SWIG_fail;
11603 result = (int) ((arg1)->Language);
11604
11605 {
11606 resultobj = SWIG_From_int((int)(result));
11607 }
11608 return resultobj;
11609 fail:
11610 return NULL;
11611 }
11612
11613
11614 static PyObject *_wrap_LanguageInfo_CanonicalName_set(PyObject *, PyObject *args, PyObject *kwargs) {
11615 PyObject *resultobj;
11616 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11617 wxString *arg2 = (wxString *) 0 ;
11618 bool temp2 = false ;
11619 PyObject * obj0 = 0 ;
11620 PyObject * obj1 = 0 ;
11621 char *kwnames[] = {
11622 (char *) "self",(char *) "CanonicalName", NULL
11623 };
11624
11625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_CanonicalName_set",kwnames,&obj0,&obj1)) goto fail;
11626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11627 if (SWIG_arg_fail(1)) SWIG_fail;
11628 {
11629 arg2 = wxString_in_helper(obj1);
11630 if (arg2 == NULL) SWIG_fail;
11631 temp2 = true;
11632 }
11633 if (arg1) (arg1)->CanonicalName = *arg2;
11634
11635 Py_INCREF(Py_None); resultobj = Py_None;
11636 {
11637 if (temp2)
11638 delete arg2;
11639 }
11640 return resultobj;
11641 fail:
11642 {
11643 if (temp2)
11644 delete arg2;
11645 }
11646 return NULL;
11647 }
11648
11649
11650 static PyObject *_wrap_LanguageInfo_CanonicalName_get(PyObject *, PyObject *args, PyObject *kwargs) {
11651 PyObject *resultobj;
11652 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11653 wxString *result;
11654 PyObject * obj0 = 0 ;
11655 char *kwnames[] = {
11656 (char *) "self", NULL
11657 };
11658
11659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_CanonicalName_get",kwnames,&obj0)) goto fail;
11660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11661 if (SWIG_arg_fail(1)) SWIG_fail;
11662 result = (wxString *)& ((arg1)->CanonicalName);
11663
11664 {
11665 #if wxUSE_UNICODE
11666 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
11667 #else
11668 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
11669 #endif
11670 }
11671 return resultobj;
11672 fail:
11673 return NULL;
11674 }
11675
11676
11677 static PyObject *_wrap_LanguageInfo_Description_set(PyObject *, PyObject *args, PyObject *kwargs) {
11678 PyObject *resultobj;
11679 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11680 wxString *arg2 = (wxString *) 0 ;
11681 bool temp2 = false ;
11682 PyObject * obj0 = 0 ;
11683 PyObject * obj1 = 0 ;
11684 char *kwnames[] = {
11685 (char *) "self",(char *) "Description", NULL
11686 };
11687
11688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Description_set",kwnames,&obj0,&obj1)) goto fail;
11689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11690 if (SWIG_arg_fail(1)) SWIG_fail;
11691 {
11692 arg2 = wxString_in_helper(obj1);
11693 if (arg2 == NULL) SWIG_fail;
11694 temp2 = true;
11695 }
11696 if (arg1) (arg1)->Description = *arg2;
11697
11698 Py_INCREF(Py_None); resultobj = Py_None;
11699 {
11700 if (temp2)
11701 delete arg2;
11702 }
11703 return resultobj;
11704 fail:
11705 {
11706 if (temp2)
11707 delete arg2;
11708 }
11709 return NULL;
11710 }
11711
11712
11713 static PyObject *_wrap_LanguageInfo_Description_get(PyObject *, PyObject *args, PyObject *kwargs) {
11714 PyObject *resultobj;
11715 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11716 wxString *result;
11717 PyObject * obj0 = 0 ;
11718 char *kwnames[] = {
11719 (char *) "self", NULL
11720 };
11721
11722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Description_get",kwnames,&obj0)) goto fail;
11723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11724 if (SWIG_arg_fail(1)) SWIG_fail;
11725 result = (wxString *)& ((arg1)->Description);
11726
11727 {
11728 #if wxUSE_UNICODE
11729 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
11730 #else
11731 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
11732 #endif
11733 }
11734 return resultobj;
11735 fail:
11736 return NULL;
11737 }
11738
11739
11740 static PyObject * LanguageInfo_swigregister(PyObject *, PyObject *args) {
11741 PyObject *obj;
11742 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11743 SWIG_TypeClientData(SWIGTYPE_p_wxLanguageInfo, obj);
11744 Py_INCREF(obj);
11745 return Py_BuildValue((char *)"");
11746 }
11747 static PyObject *_wrap_new_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
11748 PyObject *resultobj;
11749 int arg1 = (int) -1 ;
11750 int arg2 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
11751 wxLocale *result;
11752 PyObject * obj0 = 0 ;
11753 PyObject * obj1 = 0 ;
11754 char *kwnames[] = {
11755 (char *) "language",(char *) "flags", NULL
11756 };
11757
11758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Locale",kwnames,&obj0,&obj1)) goto fail;
11759 if (obj0) {
11760 {
11761 arg1 = (int)(SWIG_As_int(obj0));
11762 if (SWIG_arg_fail(1)) SWIG_fail;
11763 }
11764 }
11765 if (obj1) {
11766 {
11767 arg2 = (int)(SWIG_As_int(obj1));
11768 if (SWIG_arg_fail(2)) SWIG_fail;
11769 }
11770 }
11771 {
11772 PyThreadState* __tstate = wxPyBeginAllowThreads();
11773 result = (wxLocale *)new_wxLocale(arg1,arg2);
11774
11775 wxPyEndAllowThreads(__tstate);
11776 if (PyErr_Occurred()) SWIG_fail;
11777 }
11778 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 1);
11779 return resultobj;
11780 fail:
11781 return NULL;
11782 }
11783
11784
11785 static PyObject *_wrap_delete_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
11786 PyObject *resultobj;
11787 wxLocale *arg1 = (wxLocale *) 0 ;
11788 PyObject * obj0 = 0 ;
11789 char *kwnames[] = {
11790 (char *) "self", NULL
11791 };
11792
11793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Locale",kwnames,&obj0)) goto fail;
11794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11795 if (SWIG_arg_fail(1)) SWIG_fail;
11796 {
11797 PyThreadState* __tstate = wxPyBeginAllowThreads();
11798 delete arg1;
11799
11800 wxPyEndAllowThreads(__tstate);
11801 if (PyErr_Occurred()) SWIG_fail;
11802 }
11803 Py_INCREF(Py_None); resultobj = Py_None;
11804 return resultobj;
11805 fail:
11806 return NULL;
11807 }
11808
11809
11810 static PyObject *_wrap_Locale_Init1(PyObject *, PyObject *args, PyObject *kwargs) {
11811 PyObject *resultobj;
11812 wxLocale *arg1 = (wxLocale *) 0 ;
11813 wxString *arg2 = 0 ;
11814 wxString const &arg3_defvalue = wxPyEmptyString ;
11815 wxString *arg3 = (wxString *) &arg3_defvalue ;
11816 wxString const &arg4_defvalue = wxPyEmptyString ;
11817 wxString *arg4 = (wxString *) &arg4_defvalue ;
11818 bool arg5 = (bool) true ;
11819 bool arg6 = (bool) false ;
11820 bool result;
11821 bool temp2 = false ;
11822 bool temp3 = false ;
11823 bool temp4 = false ;
11824 PyObject * obj0 = 0 ;
11825 PyObject * obj1 = 0 ;
11826 PyObject * obj2 = 0 ;
11827 PyObject * obj3 = 0 ;
11828 PyObject * obj4 = 0 ;
11829 PyObject * obj5 = 0 ;
11830 char *kwnames[] = {
11831 (char *) "self",(char *) "szName",(char *) "szShort",(char *) "szLocale",(char *) "bLoadDefault",(char *) "bConvertEncoding", NULL
11832 };
11833
11834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Locale_Init1",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11836 if (SWIG_arg_fail(1)) SWIG_fail;
11837 {
11838 arg2 = wxString_in_helper(obj1);
11839 if (arg2 == NULL) SWIG_fail;
11840 temp2 = true;
11841 }
11842 if (obj2) {
11843 {
11844 arg3 = wxString_in_helper(obj2);
11845 if (arg3 == NULL) SWIG_fail;
11846 temp3 = true;
11847 }
11848 }
11849 if (obj3) {
11850 {
11851 arg4 = wxString_in_helper(obj3);
11852 if (arg4 == NULL) SWIG_fail;
11853 temp4 = true;
11854 }
11855 }
11856 if (obj4) {
11857 {
11858 arg5 = (bool)(SWIG_As_bool(obj4));
11859 if (SWIG_arg_fail(5)) SWIG_fail;
11860 }
11861 }
11862 if (obj5) {
11863 {
11864 arg6 = (bool)(SWIG_As_bool(obj5));
11865 if (SWIG_arg_fail(6)) SWIG_fail;
11866 }
11867 }
11868 {
11869 PyThreadState* __tstate = wxPyBeginAllowThreads();
11870 result = (bool)wxLocale_Init1(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
11871
11872 wxPyEndAllowThreads(__tstate);
11873 if (PyErr_Occurred()) SWIG_fail;
11874 }
11875 {
11876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11877 }
11878 {
11879 if (temp2)
11880 delete arg2;
11881 }
11882 {
11883 if (temp3)
11884 delete arg3;
11885 }
11886 {
11887 if (temp4)
11888 delete arg4;
11889 }
11890 return resultobj;
11891 fail:
11892 {
11893 if (temp2)
11894 delete arg2;
11895 }
11896 {
11897 if (temp3)
11898 delete arg3;
11899 }
11900 {
11901 if (temp4)
11902 delete arg4;
11903 }
11904 return NULL;
11905 }
11906
11907
11908 static PyObject *_wrap_Locale_Init2(PyObject *, PyObject *args, PyObject *kwargs) {
11909 PyObject *resultobj;
11910 wxLocale *arg1 = (wxLocale *) 0 ;
11911 int arg2 = (int) wxLANGUAGE_DEFAULT ;
11912 int arg3 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
11913 bool result;
11914 PyObject * obj0 = 0 ;
11915 PyObject * obj1 = 0 ;
11916 PyObject * obj2 = 0 ;
11917 char *kwnames[] = {
11918 (char *) "self",(char *) "language",(char *) "flags", NULL
11919 };
11920
11921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Locale_Init2",kwnames,&obj0,&obj1,&obj2)) goto fail;
11922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11923 if (SWIG_arg_fail(1)) SWIG_fail;
11924 if (obj1) {
11925 {
11926 arg2 = (int)(SWIG_As_int(obj1));
11927 if (SWIG_arg_fail(2)) SWIG_fail;
11928 }
11929 }
11930 if (obj2) {
11931 {
11932 arg3 = (int)(SWIG_As_int(obj2));
11933 if (SWIG_arg_fail(3)) SWIG_fail;
11934 }
11935 }
11936 {
11937 PyThreadState* __tstate = wxPyBeginAllowThreads();
11938 result = (bool)wxLocale_Init2(arg1,arg2,arg3);
11939
11940 wxPyEndAllowThreads(__tstate);
11941 if (PyErr_Occurred()) SWIG_fail;
11942 }
11943 {
11944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11945 }
11946 return resultobj;
11947 fail:
11948 return NULL;
11949 }
11950
11951
11952 static PyObject *_wrap_Locale_GetSystemLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11953 PyObject *resultobj;
11954 int result;
11955 char *kwnames[] = {
11956 NULL
11957 };
11958
11959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemLanguage",kwnames)) goto fail;
11960 {
11961 PyThreadState* __tstate = wxPyBeginAllowThreads();
11962 result = (int)wxLocale::GetSystemLanguage();
11963
11964 wxPyEndAllowThreads(__tstate);
11965 if (PyErr_Occurred()) SWIG_fail;
11966 }
11967 {
11968 resultobj = SWIG_From_int((int)(result));
11969 }
11970 return resultobj;
11971 fail:
11972 return NULL;
11973 }
11974
11975
11976 static PyObject *_wrap_Locale_GetSystemEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
11977 PyObject *resultobj;
11978 wxFontEncoding result;
11979 char *kwnames[] = {
11980 NULL
11981 };
11982
11983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncoding",kwnames)) goto fail;
11984 {
11985 PyThreadState* __tstate = wxPyBeginAllowThreads();
11986 result = (wxFontEncoding)wxLocale::GetSystemEncoding();
11987
11988 wxPyEndAllowThreads(__tstate);
11989 if (PyErr_Occurred()) SWIG_fail;
11990 }
11991 resultobj = SWIG_From_int((result));
11992 return resultobj;
11993 fail:
11994 return NULL;
11995 }
11996
11997
11998 static PyObject *_wrap_Locale_GetSystemEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
11999 PyObject *resultobj;
12000 wxString result;
12001 char *kwnames[] = {
12002 NULL
12003 };
12004
12005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncodingName",kwnames)) goto fail;
12006 {
12007 PyThreadState* __tstate = wxPyBeginAllowThreads();
12008 result = wxLocale::GetSystemEncodingName();
12009
12010 wxPyEndAllowThreads(__tstate);
12011 if (PyErr_Occurred()) SWIG_fail;
12012 }
12013 {
12014 #if wxUSE_UNICODE
12015 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12016 #else
12017 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12018 #endif
12019 }
12020 return resultobj;
12021 fail:
12022 return NULL;
12023 }
12024
12025
12026 static PyObject *_wrap_Locale_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
12027 PyObject *resultobj;
12028 wxLocale *arg1 = (wxLocale *) 0 ;
12029 bool result;
12030 PyObject * obj0 = 0 ;
12031 char *kwnames[] = {
12032 (char *) "self", NULL
12033 };
12034
12035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_IsOk",kwnames,&obj0)) goto fail;
12036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12037 if (SWIG_arg_fail(1)) SWIG_fail;
12038 {
12039 PyThreadState* __tstate = wxPyBeginAllowThreads();
12040 result = (bool)((wxLocale const *)arg1)->IsOk();
12041
12042 wxPyEndAllowThreads(__tstate);
12043 if (PyErr_Occurred()) SWIG_fail;
12044 }
12045 {
12046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12047 }
12048 return resultobj;
12049 fail:
12050 return NULL;
12051 }
12052
12053
12054 static PyObject *_wrap_Locale_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
12055 PyObject *resultobj;
12056 wxLocale *arg1 = (wxLocale *) 0 ;
12057 wxString result;
12058 PyObject * obj0 = 0 ;
12059 char *kwnames[] = {
12060 (char *) "self", NULL
12061 };
12062
12063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLocale",kwnames,&obj0)) goto fail;
12064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12065 if (SWIG_arg_fail(1)) SWIG_fail;
12066 {
12067 PyThreadState* __tstate = wxPyBeginAllowThreads();
12068 result = ((wxLocale const *)arg1)->GetLocale();
12069
12070 wxPyEndAllowThreads(__tstate);
12071 if (PyErr_Occurred()) SWIG_fail;
12072 }
12073 {
12074 #if wxUSE_UNICODE
12075 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12076 #else
12077 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12078 #endif
12079 }
12080 return resultobj;
12081 fail:
12082 return NULL;
12083 }
12084
12085
12086 static PyObject *_wrap_Locale_GetLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
12087 PyObject *resultobj;
12088 wxLocale *arg1 = (wxLocale *) 0 ;
12089 int result;
12090 PyObject * obj0 = 0 ;
12091 char *kwnames[] = {
12092 (char *) "self", NULL
12093 };
12094
12095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguage",kwnames,&obj0)) goto fail;
12096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12097 if (SWIG_arg_fail(1)) SWIG_fail;
12098 {
12099 PyThreadState* __tstate = wxPyBeginAllowThreads();
12100 result = (int)((wxLocale const *)arg1)->GetLanguage();
12101
12102 wxPyEndAllowThreads(__tstate);
12103 if (PyErr_Occurred()) SWIG_fail;
12104 }
12105 {
12106 resultobj = SWIG_From_int((int)(result));
12107 }
12108 return resultobj;
12109 fail:
12110 return NULL;
12111 }
12112
12113
12114 static PyObject *_wrap_Locale_GetSysName(PyObject *, PyObject *args, PyObject *kwargs) {
12115 PyObject *resultobj;
12116 wxLocale *arg1 = (wxLocale *) 0 ;
12117 wxString result;
12118 PyObject * obj0 = 0 ;
12119 char *kwnames[] = {
12120 (char *) "self", NULL
12121 };
12122
12123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetSysName",kwnames,&obj0)) goto fail;
12124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12125 if (SWIG_arg_fail(1)) SWIG_fail;
12126 {
12127 PyThreadState* __tstate = wxPyBeginAllowThreads();
12128 result = ((wxLocale const *)arg1)->GetSysName();
12129
12130 wxPyEndAllowThreads(__tstate);
12131 if (PyErr_Occurred()) SWIG_fail;
12132 }
12133 {
12134 #if wxUSE_UNICODE
12135 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12136 #else
12137 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12138 #endif
12139 }
12140 return resultobj;
12141 fail:
12142 return NULL;
12143 }
12144
12145
12146 static PyObject *_wrap_Locale_GetCanonicalName(PyObject *, PyObject *args, PyObject *kwargs) {
12147 PyObject *resultobj;
12148 wxLocale *arg1 = (wxLocale *) 0 ;
12149 wxString result;
12150 PyObject * obj0 = 0 ;
12151 char *kwnames[] = {
12152 (char *) "self", NULL
12153 };
12154
12155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetCanonicalName",kwnames,&obj0)) goto fail;
12156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12157 if (SWIG_arg_fail(1)) SWIG_fail;
12158 {
12159 PyThreadState* __tstate = wxPyBeginAllowThreads();
12160 result = ((wxLocale const *)arg1)->GetCanonicalName();
12161
12162 wxPyEndAllowThreads(__tstate);
12163 if (PyErr_Occurred()) SWIG_fail;
12164 }
12165 {
12166 #if wxUSE_UNICODE
12167 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12168 #else
12169 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12170 #endif
12171 }
12172 return resultobj;
12173 fail:
12174 return NULL;
12175 }
12176
12177
12178 static PyObject *_wrap_Locale_AddCatalogLookupPathPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
12179 PyObject *resultobj;
12180 wxString *arg1 = 0 ;
12181 bool temp1 = false ;
12182 PyObject * obj0 = 0 ;
12183 char *kwnames[] = {
12184 (char *) "prefix", NULL
12185 };
12186
12187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddCatalogLookupPathPrefix",kwnames,&obj0)) goto fail;
12188 {
12189 arg1 = wxString_in_helper(obj0);
12190 if (arg1 == NULL) SWIG_fail;
12191 temp1 = true;
12192 }
12193 {
12194 PyThreadState* __tstate = wxPyBeginAllowThreads();
12195 wxLocale::AddCatalogLookupPathPrefix((wxString const &)*arg1);
12196
12197 wxPyEndAllowThreads(__tstate);
12198 if (PyErr_Occurred()) SWIG_fail;
12199 }
12200 Py_INCREF(Py_None); resultobj = Py_None;
12201 {
12202 if (temp1)
12203 delete arg1;
12204 }
12205 return resultobj;
12206 fail:
12207 {
12208 if (temp1)
12209 delete arg1;
12210 }
12211 return NULL;
12212 }
12213
12214
12215 static PyObject *_wrap_Locale_AddCatalog(PyObject *, PyObject *args, PyObject *kwargs) {
12216 PyObject *resultobj;
12217 wxLocale *arg1 = (wxLocale *) 0 ;
12218 wxString *arg2 = 0 ;
12219 bool result;
12220 bool temp2 = false ;
12221 PyObject * obj0 = 0 ;
12222 PyObject * obj1 = 0 ;
12223 char *kwnames[] = {
12224 (char *) "self",(char *) "szDomain", NULL
12225 };
12226
12227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_AddCatalog",kwnames,&obj0,&obj1)) goto fail;
12228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12229 if (SWIG_arg_fail(1)) SWIG_fail;
12230 {
12231 arg2 = wxString_in_helper(obj1);
12232 if (arg2 == NULL) SWIG_fail;
12233 temp2 = true;
12234 }
12235 {
12236 PyThreadState* __tstate = wxPyBeginAllowThreads();
12237 result = (bool)(arg1)->AddCatalog((wxString const &)*arg2);
12238
12239 wxPyEndAllowThreads(__tstate);
12240 if (PyErr_Occurred()) SWIG_fail;
12241 }
12242 {
12243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12244 }
12245 {
12246 if (temp2)
12247 delete arg2;
12248 }
12249 return resultobj;
12250 fail:
12251 {
12252 if (temp2)
12253 delete arg2;
12254 }
12255 return NULL;
12256 }
12257
12258
12259 static PyObject *_wrap_Locale_IsLoaded(PyObject *, PyObject *args, PyObject *kwargs) {
12260 PyObject *resultobj;
12261 wxLocale *arg1 = (wxLocale *) 0 ;
12262 wxString *arg2 = 0 ;
12263 bool result;
12264 bool temp2 = false ;
12265 PyObject * obj0 = 0 ;
12266 PyObject * obj1 = 0 ;
12267 char *kwnames[] = {
12268 (char *) "self",(char *) "szDomain", NULL
12269 };
12270
12271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_IsLoaded",kwnames,&obj0,&obj1)) goto fail;
12272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12273 if (SWIG_arg_fail(1)) SWIG_fail;
12274 {
12275 arg2 = wxString_in_helper(obj1);
12276 if (arg2 == NULL) SWIG_fail;
12277 temp2 = true;
12278 }
12279 {
12280 PyThreadState* __tstate = wxPyBeginAllowThreads();
12281 result = (bool)((wxLocale const *)arg1)->IsLoaded((wxString const &)*arg2);
12282
12283 wxPyEndAllowThreads(__tstate);
12284 if (PyErr_Occurred()) SWIG_fail;
12285 }
12286 {
12287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12288 }
12289 {
12290 if (temp2)
12291 delete arg2;
12292 }
12293 return resultobj;
12294 fail:
12295 {
12296 if (temp2)
12297 delete arg2;
12298 }
12299 return NULL;
12300 }
12301
12302
12303 static PyObject *_wrap_Locale_GetLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
12304 PyObject *resultobj;
12305 int arg1 ;
12306 wxLanguageInfo *result;
12307 PyObject * obj0 = 0 ;
12308 char *kwnames[] = {
12309 (char *) "lang", NULL
12310 };
12311
12312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageInfo",kwnames,&obj0)) goto fail;
12313 {
12314 arg1 = (int)(SWIG_As_int(obj0));
12315 if (SWIG_arg_fail(1)) SWIG_fail;
12316 }
12317 {
12318 PyThreadState* __tstate = wxPyBeginAllowThreads();
12319 result = (wxLanguageInfo *)wxLocale::GetLanguageInfo(arg1);
12320
12321 wxPyEndAllowThreads(__tstate);
12322 if (PyErr_Occurred()) SWIG_fail;
12323 }
12324 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
12325 return resultobj;
12326 fail:
12327 return NULL;
12328 }
12329
12330
12331 static PyObject *_wrap_Locale_GetLanguageName(PyObject *, PyObject *args, PyObject *kwargs) {
12332 PyObject *resultobj;
12333 int arg1 ;
12334 wxString result;
12335 PyObject * obj0 = 0 ;
12336 char *kwnames[] = {
12337 (char *) "lang", NULL
12338 };
12339
12340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageName",kwnames,&obj0)) goto fail;
12341 {
12342 arg1 = (int)(SWIG_As_int(obj0));
12343 if (SWIG_arg_fail(1)) SWIG_fail;
12344 }
12345 {
12346 PyThreadState* __tstate = wxPyBeginAllowThreads();
12347 result = wxLocale::GetLanguageName(arg1);
12348
12349 wxPyEndAllowThreads(__tstate);
12350 if (PyErr_Occurred()) SWIG_fail;
12351 }
12352 {
12353 #if wxUSE_UNICODE
12354 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12355 #else
12356 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12357 #endif
12358 }
12359 return resultobj;
12360 fail:
12361 return NULL;
12362 }
12363
12364
12365 static PyObject *_wrap_Locale_FindLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
12366 PyObject *resultobj;
12367 wxString *arg1 = 0 ;
12368 wxLanguageInfo *result;
12369 bool temp1 = false ;
12370 PyObject * obj0 = 0 ;
12371 char *kwnames[] = {
12372 (char *) "locale", NULL
12373 };
12374
12375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_FindLanguageInfo",kwnames,&obj0)) goto fail;
12376 {
12377 arg1 = wxString_in_helper(obj0);
12378 if (arg1 == NULL) SWIG_fail;
12379 temp1 = true;
12380 }
12381 {
12382 PyThreadState* __tstate = wxPyBeginAllowThreads();
12383 result = (wxLanguageInfo *)wxLocale::FindLanguageInfo((wxString const &)*arg1);
12384
12385 wxPyEndAllowThreads(__tstate);
12386 if (PyErr_Occurred()) SWIG_fail;
12387 }
12388 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
12389 {
12390 if (temp1)
12391 delete arg1;
12392 }
12393 return resultobj;
12394 fail:
12395 {
12396 if (temp1)
12397 delete arg1;
12398 }
12399 return NULL;
12400 }
12401
12402
12403 static PyObject *_wrap_Locale_AddLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
12404 PyObject *resultobj;
12405 wxLanguageInfo *arg1 = 0 ;
12406 PyObject * obj0 = 0 ;
12407 char *kwnames[] = {
12408 (char *) "info", NULL
12409 };
12410
12411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddLanguage",kwnames,&obj0)) goto fail;
12412 {
12413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
12414 if (SWIG_arg_fail(1)) SWIG_fail;
12415 if (arg1 == NULL) {
12416 SWIG_null_ref("wxLanguageInfo");
12417 }
12418 if (SWIG_arg_fail(1)) SWIG_fail;
12419 }
12420 {
12421 PyThreadState* __tstate = wxPyBeginAllowThreads();
12422 wxLocale::AddLanguage((wxLanguageInfo const &)*arg1);
12423
12424 wxPyEndAllowThreads(__tstate);
12425 if (PyErr_Occurred()) SWIG_fail;
12426 }
12427 Py_INCREF(Py_None); resultobj = Py_None;
12428 return resultobj;
12429 fail:
12430 return NULL;
12431 }
12432
12433
12434 static PyObject *_wrap_Locale_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
12435 PyObject *resultobj;
12436 wxLocale *arg1 = (wxLocale *) 0 ;
12437 wxString *arg2 = 0 ;
12438 wxString const &arg3_defvalue = wxPyEmptyString ;
12439 wxString *arg3 = (wxString *) &arg3_defvalue ;
12440 wxString result;
12441 bool temp2 = false ;
12442 bool temp3 = false ;
12443 PyObject * obj0 = 0 ;
12444 PyObject * obj1 = 0 ;
12445 PyObject * obj2 = 0 ;
12446 char *kwnames[] = {
12447 (char *) "self",(char *) "szOrigString",(char *) "szDomain", NULL
12448 };
12449
12450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Locale_GetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
12451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12452 if (SWIG_arg_fail(1)) SWIG_fail;
12453 {
12454 arg2 = wxString_in_helper(obj1);
12455 if (arg2 == NULL) SWIG_fail;
12456 temp2 = true;
12457 }
12458 if (obj2) {
12459 {
12460 arg3 = wxString_in_helper(obj2);
12461 if (arg3 == NULL) SWIG_fail;
12462 temp3 = true;
12463 }
12464 }
12465 {
12466 PyThreadState* __tstate = wxPyBeginAllowThreads();
12467 result = ((wxLocale const *)arg1)->GetString((wxString const &)*arg2,(wxString const &)*arg3);
12468
12469 wxPyEndAllowThreads(__tstate);
12470 if (PyErr_Occurred()) SWIG_fail;
12471 }
12472 {
12473 #if wxUSE_UNICODE
12474 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12475 #else
12476 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12477 #endif
12478 }
12479 {
12480 if (temp2)
12481 delete arg2;
12482 }
12483 {
12484 if (temp3)
12485 delete arg3;
12486 }
12487 return resultobj;
12488 fail:
12489 {
12490 if (temp2)
12491 delete arg2;
12492 }
12493 {
12494 if (temp3)
12495 delete arg3;
12496 }
12497 return NULL;
12498 }
12499
12500
12501 static PyObject *_wrap_Locale_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
12502 PyObject *resultobj;
12503 wxLocale *arg1 = (wxLocale *) 0 ;
12504 wxString *result;
12505 PyObject * obj0 = 0 ;
12506 char *kwnames[] = {
12507 (char *) "self", NULL
12508 };
12509
12510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetName",kwnames,&obj0)) goto fail;
12511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12512 if (SWIG_arg_fail(1)) SWIG_fail;
12513 {
12514 PyThreadState* __tstate = wxPyBeginAllowThreads();
12515 {
12516 wxString const &_result_ref = ((wxLocale const *)arg1)->GetName();
12517 result = (wxString *) &_result_ref;
12518 }
12519
12520 wxPyEndAllowThreads(__tstate);
12521 if (PyErr_Occurred()) SWIG_fail;
12522 }
12523 {
12524 #if wxUSE_UNICODE
12525 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12526 #else
12527 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12528 #endif
12529 }
12530 return resultobj;
12531 fail:
12532 return NULL;
12533 }
12534
12535
12536 static PyObject * Locale_swigregister(PyObject *, PyObject *args) {
12537 PyObject *obj;
12538 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12539 SWIG_TypeClientData(SWIGTYPE_p_wxLocale, obj);
12540 Py_INCREF(obj);
12541 return Py_BuildValue((char *)"");
12542 }
12543 static PyObject *_wrap_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
12544 PyObject *resultobj;
12545 wxLocale *result;
12546 char *kwnames[] = {
12547 NULL
12548 };
12549
12550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocale",kwnames)) goto fail;
12551 {
12552 PyThreadState* __tstate = wxPyBeginAllowThreads();
12553 result = (wxLocale *)wxGetLocale();
12554
12555 wxPyEndAllowThreads(__tstate);
12556 if (PyErr_Occurred()) SWIG_fail;
12557 }
12558 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 0);
12559 return resultobj;
12560 fail:
12561 return NULL;
12562 }
12563
12564
12565 static PyObject *_wrap_GetTranslation__SWIG_0(PyObject *, PyObject *args) {
12566 PyObject *resultobj;
12567 wxString *arg1 = 0 ;
12568 wxString result;
12569 bool temp1 = false ;
12570 PyObject * obj0 = 0 ;
12571
12572 if(!PyArg_ParseTuple(args,(char *)"O:GetTranslation",&obj0)) goto fail;
12573 {
12574 arg1 = wxString_in_helper(obj0);
12575 if (arg1 == NULL) SWIG_fail;
12576 temp1 = true;
12577 }
12578 {
12579 PyThreadState* __tstate = wxPyBeginAllowThreads();
12580 result = wxGetTranslation((wxString const &)*arg1);
12581
12582 wxPyEndAllowThreads(__tstate);
12583 if (PyErr_Occurred()) SWIG_fail;
12584 }
12585 {
12586 #if wxUSE_UNICODE
12587 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12588 #else
12589 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12590 #endif
12591 }
12592 {
12593 if (temp1)
12594 delete arg1;
12595 }
12596 return resultobj;
12597 fail:
12598 {
12599 if (temp1)
12600 delete arg1;
12601 }
12602 return NULL;
12603 }
12604
12605
12606 static PyObject *_wrap_GetTranslation__SWIG_1(PyObject *, PyObject *args) {
12607 PyObject *resultobj;
12608 wxString *arg1 = 0 ;
12609 wxString *arg2 = 0 ;
12610 size_t arg3 ;
12611 wxString result;
12612 bool temp1 = false ;
12613 bool temp2 = false ;
12614 PyObject * obj0 = 0 ;
12615 PyObject * obj1 = 0 ;
12616 PyObject * obj2 = 0 ;
12617
12618 if(!PyArg_ParseTuple(args,(char *)"OOO:GetTranslation",&obj0,&obj1,&obj2)) goto fail;
12619 {
12620 arg1 = wxString_in_helper(obj0);
12621 if (arg1 == NULL) SWIG_fail;
12622 temp1 = true;
12623 }
12624 {
12625 arg2 = wxString_in_helper(obj1);
12626 if (arg2 == NULL) SWIG_fail;
12627 temp2 = true;
12628 }
12629 {
12630 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
12631 if (SWIG_arg_fail(3)) SWIG_fail;
12632 }
12633 {
12634 PyThreadState* __tstate = wxPyBeginAllowThreads();
12635 result = wxGetTranslation((wxString const &)*arg1,(wxString const &)*arg2,arg3);
12636
12637 wxPyEndAllowThreads(__tstate);
12638 if (PyErr_Occurred()) SWIG_fail;
12639 }
12640 {
12641 #if wxUSE_UNICODE
12642 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12643 #else
12644 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12645 #endif
12646 }
12647 {
12648 if (temp1)
12649 delete arg1;
12650 }
12651 {
12652 if (temp2)
12653 delete arg2;
12654 }
12655 return resultobj;
12656 fail:
12657 {
12658 if (temp1)
12659 delete arg1;
12660 }
12661 {
12662 if (temp2)
12663 delete arg2;
12664 }
12665 return NULL;
12666 }
12667
12668
12669 static PyObject *_wrap_GetTranslation(PyObject *self, PyObject *args) {
12670 int argc;
12671 PyObject *argv[4];
12672 int ii;
12673
12674 argc = PyObject_Length(args);
12675 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
12676 argv[ii] = PyTuple_GetItem(args,ii);
12677 }
12678 if (argc == 1) {
12679 int _v;
12680 {
12681 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12682 }
12683 if (_v) {
12684 return _wrap_GetTranslation__SWIG_0(self,args);
12685 }
12686 }
12687 if (argc == 3) {
12688 int _v;
12689 {
12690 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12691 }
12692 if (_v) {
12693 {
12694 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
12695 }
12696 if (_v) {
12697 _v = SWIG_Check_unsigned_SS_long(argv[2]);
12698 if (_v) {
12699 return _wrap_GetTranslation__SWIG_1(self,args);
12700 }
12701 }
12702 }
12703 }
12704
12705 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GetTranslation'");
12706 return NULL;
12707 }
12708
12709
12710 static PyObject *_wrap_new_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
12711 PyObject *resultobj;
12712 wxEncodingConverter *result;
12713 char *kwnames[] = {
12714 NULL
12715 };
12716
12717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EncodingConverter",kwnames)) goto fail;
12718 {
12719 PyThreadState* __tstate = wxPyBeginAllowThreads();
12720 result = (wxEncodingConverter *)new wxEncodingConverter();
12721
12722 wxPyEndAllowThreads(__tstate);
12723 if (PyErr_Occurred()) SWIG_fail;
12724 }
12725 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEncodingConverter, 1);
12726 return resultobj;
12727 fail:
12728 return NULL;
12729 }
12730
12731
12732 static PyObject *_wrap_delete_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
12733 PyObject *resultobj;
12734 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12735 PyObject * obj0 = 0 ;
12736 char *kwnames[] = {
12737 (char *) "self", NULL
12738 };
12739
12740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EncodingConverter",kwnames,&obj0)) goto fail;
12741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12742 if (SWIG_arg_fail(1)) SWIG_fail;
12743 {
12744 PyThreadState* __tstate = wxPyBeginAllowThreads();
12745 delete arg1;
12746
12747 wxPyEndAllowThreads(__tstate);
12748 if (PyErr_Occurred()) SWIG_fail;
12749 }
12750 Py_INCREF(Py_None); resultobj = Py_None;
12751 return resultobj;
12752 fail:
12753 return NULL;
12754 }
12755
12756
12757 static PyObject *_wrap_EncodingConverter_Init(PyObject *, PyObject *args, PyObject *kwargs) {
12758 PyObject *resultobj;
12759 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12760 wxFontEncoding arg2 ;
12761 wxFontEncoding arg3 ;
12762 int arg4 = (int) wxCONVERT_STRICT ;
12763 bool result;
12764 PyObject * obj0 = 0 ;
12765 PyObject * obj1 = 0 ;
12766 PyObject * obj2 = 0 ;
12767 PyObject * obj3 = 0 ;
12768 char *kwnames[] = {
12769 (char *) "self",(char *) "input_enc",(char *) "output_enc",(char *) "method", NULL
12770 };
12771
12772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:EncodingConverter_Init",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12774 if (SWIG_arg_fail(1)) SWIG_fail;
12775 {
12776 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12777 if (SWIG_arg_fail(2)) SWIG_fail;
12778 }
12779 {
12780 arg3 = (wxFontEncoding)(SWIG_As_int(obj2));
12781 if (SWIG_arg_fail(3)) SWIG_fail;
12782 }
12783 if (obj3) {
12784 {
12785 arg4 = (int)(SWIG_As_int(obj3));
12786 if (SWIG_arg_fail(4)) SWIG_fail;
12787 }
12788 }
12789 {
12790 PyThreadState* __tstate = wxPyBeginAllowThreads();
12791 result = (bool)(arg1)->Init((wxFontEncoding )arg2,(wxFontEncoding )arg3,arg4);
12792
12793 wxPyEndAllowThreads(__tstate);
12794 if (PyErr_Occurred()) SWIG_fail;
12795 }
12796 {
12797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12798 }
12799 return resultobj;
12800 fail:
12801 return NULL;
12802 }
12803
12804
12805 static PyObject *_wrap_EncodingConverter_Convert(PyObject *, PyObject *args, PyObject *kwargs) {
12806 PyObject *resultobj;
12807 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12808 wxString *arg2 = 0 ;
12809 wxString result;
12810 bool temp2 = false ;
12811 PyObject * obj0 = 0 ;
12812 PyObject * obj1 = 0 ;
12813 char *kwnames[] = {
12814 (char *) "self",(char *) "input", NULL
12815 };
12816
12817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_Convert",kwnames,&obj0,&obj1)) goto fail;
12818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12819 if (SWIG_arg_fail(1)) SWIG_fail;
12820 {
12821 arg2 = wxString_in_helper(obj1);
12822 if (arg2 == NULL) SWIG_fail;
12823 temp2 = true;
12824 }
12825 {
12826 PyThreadState* __tstate = wxPyBeginAllowThreads();
12827 result = (arg1)->Convert((wxString const &)*arg2);
12828
12829 wxPyEndAllowThreads(__tstate);
12830 if (PyErr_Occurred()) SWIG_fail;
12831 }
12832 {
12833 #if wxUSE_UNICODE
12834 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12835 #else
12836 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12837 #endif
12838 }
12839 {
12840 if (temp2)
12841 delete arg2;
12842 }
12843 return resultobj;
12844 fail:
12845 {
12846 if (temp2)
12847 delete arg2;
12848 }
12849 return NULL;
12850 }
12851
12852
12853 static PyObject *_wrap_EncodingConverter_GetPlatformEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12854 PyObject *resultobj;
12855 wxFontEncoding arg1 ;
12856 int arg2 = (int) wxPLATFORM_CURRENT ;
12857 wxFontEncodingArray result;
12858 PyObject * obj0 = 0 ;
12859 PyObject * obj1 = 0 ;
12860 char *kwnames[] = {
12861 (char *) "enc",(char *) "platform", NULL
12862 };
12863
12864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EncodingConverter_GetPlatformEquivalents",kwnames,&obj0,&obj1)) goto fail;
12865 {
12866 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12867 if (SWIG_arg_fail(1)) SWIG_fail;
12868 }
12869 if (obj1) {
12870 {
12871 arg2 = (int)(SWIG_As_int(obj1));
12872 if (SWIG_arg_fail(2)) SWIG_fail;
12873 }
12874 }
12875 {
12876 PyThreadState* __tstate = wxPyBeginAllowThreads();
12877 result = wxEncodingConverter::GetPlatformEquivalents((wxFontEncoding )arg1,arg2);
12878
12879 wxPyEndAllowThreads(__tstate);
12880 if (PyErr_Occurred()) SWIG_fail;
12881 }
12882 {
12883 resultobj = PyList_New(0);
12884 for (size_t i=0; i < (&result)->GetCount(); i++) {
12885 PyObject* number = PyInt_FromLong((&result)->Item(i));
12886 PyList_Append(resultobj, number);
12887 Py_DECREF(number);
12888 }
12889 }
12890 return resultobj;
12891 fail:
12892 return NULL;
12893 }
12894
12895
12896 static PyObject *_wrap_EncodingConverter_GetAllEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12897 PyObject *resultobj;
12898 wxFontEncoding arg1 ;
12899 wxFontEncodingArray result;
12900 PyObject * obj0 = 0 ;
12901 char *kwnames[] = {
12902 (char *) "enc", NULL
12903 };
12904
12905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EncodingConverter_GetAllEquivalents",kwnames,&obj0)) goto fail;
12906 {
12907 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12908 if (SWIG_arg_fail(1)) SWIG_fail;
12909 }
12910 {
12911 PyThreadState* __tstate = wxPyBeginAllowThreads();
12912 result = wxEncodingConverter::GetAllEquivalents((wxFontEncoding )arg1);
12913
12914 wxPyEndAllowThreads(__tstate);
12915 if (PyErr_Occurred()) SWIG_fail;
12916 }
12917 {
12918 resultobj = PyList_New(0);
12919 for (size_t i=0; i < (&result)->GetCount(); i++) {
12920 PyObject* number = PyInt_FromLong((&result)->Item(i));
12921 PyList_Append(resultobj, number);
12922 Py_DECREF(number);
12923 }
12924 }
12925 return resultobj;
12926 fail:
12927 return NULL;
12928 }
12929
12930
12931 static PyObject *_wrap_EncodingConverter_CanConvert(PyObject *, PyObject *args, PyObject *kwargs) {
12932 PyObject *resultobj;
12933 wxFontEncoding arg1 ;
12934 wxFontEncoding arg2 ;
12935 bool result;
12936 PyObject * obj0 = 0 ;
12937 PyObject * obj1 = 0 ;
12938 char *kwnames[] = {
12939 (char *) "encIn",(char *) "encOut", NULL
12940 };
12941
12942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_CanConvert",kwnames,&obj0,&obj1)) goto fail;
12943 {
12944 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12945 if (SWIG_arg_fail(1)) SWIG_fail;
12946 }
12947 {
12948 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12949 if (SWIG_arg_fail(2)) SWIG_fail;
12950 }
12951 {
12952 PyThreadState* __tstate = wxPyBeginAllowThreads();
12953 result = (bool)wxEncodingConverter::CanConvert((wxFontEncoding )arg1,(wxFontEncoding )arg2);
12954
12955 wxPyEndAllowThreads(__tstate);
12956 if (PyErr_Occurred()) SWIG_fail;
12957 }
12958 {
12959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12960 }
12961 return resultobj;
12962 fail:
12963 return NULL;
12964 }
12965
12966
12967 static PyObject * EncodingConverter_swigregister(PyObject *, PyObject *args) {
12968 PyObject *obj;
12969 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12970 SWIG_TypeClientData(SWIGTYPE_p_wxEncodingConverter, obj);
12971 Py_INCREF(obj);
12972 return Py_BuildValue((char *)"");
12973 }
12974 static PyObject *_wrap_delete_DC(PyObject *, PyObject *args, PyObject *kwargs) {
12975 PyObject *resultobj;
12976 wxDC *arg1 = (wxDC *) 0 ;
12977 PyObject * obj0 = 0 ;
12978 char *kwnames[] = {
12979 (char *) "self", NULL
12980 };
12981
12982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DC",kwnames,&obj0)) goto fail;
12983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12984 if (SWIG_arg_fail(1)) SWIG_fail;
12985 {
12986 PyThreadState* __tstate = wxPyBeginAllowThreads();
12987 delete arg1;
12988
12989 wxPyEndAllowThreads(__tstate);
12990 if (PyErr_Occurred()) SWIG_fail;
12991 }
12992 Py_INCREF(Py_None); resultobj = Py_None;
12993 return resultobj;
12994 fail:
12995 return NULL;
12996 }
12997
12998
12999 static PyObject *_wrap_DC_BeginDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
13000 PyObject *resultobj;
13001 wxDC *arg1 = (wxDC *) 0 ;
13002 PyObject * obj0 = 0 ;
13003 char *kwnames[] = {
13004 (char *) "self", NULL
13005 };
13006
13007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_BeginDrawing",kwnames,&obj0)) goto fail;
13008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13009 if (SWIG_arg_fail(1)) SWIG_fail;
13010 {
13011 PyThreadState* __tstate = wxPyBeginAllowThreads();
13012 (arg1)->BeginDrawing();
13013
13014 wxPyEndAllowThreads(__tstate);
13015 if (PyErr_Occurred()) SWIG_fail;
13016 }
13017 Py_INCREF(Py_None); resultobj = Py_None;
13018 return resultobj;
13019 fail:
13020 return NULL;
13021 }
13022
13023
13024 static PyObject *_wrap_DC_EndDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
13025 PyObject *resultobj;
13026 wxDC *arg1 = (wxDC *) 0 ;
13027 PyObject * obj0 = 0 ;
13028 char *kwnames[] = {
13029 (char *) "self", NULL
13030 };
13031
13032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDrawing",kwnames,&obj0)) goto fail;
13033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13034 if (SWIG_arg_fail(1)) SWIG_fail;
13035 {
13036 PyThreadState* __tstate = wxPyBeginAllowThreads();
13037 (arg1)->EndDrawing();
13038
13039 wxPyEndAllowThreads(__tstate);
13040 if (PyErr_Occurred()) SWIG_fail;
13041 }
13042 Py_INCREF(Py_None); resultobj = Py_None;
13043 return resultobj;
13044 fail:
13045 return NULL;
13046 }
13047
13048
13049 static PyObject *_wrap_DC_FloodFill(PyObject *, PyObject *args, PyObject *kwargs) {
13050 PyObject *resultobj;
13051 wxDC *arg1 = (wxDC *) 0 ;
13052 int arg2 ;
13053 int arg3 ;
13054 wxColour *arg4 = 0 ;
13055 int arg5 = (int) wxFLOOD_SURFACE ;
13056 bool result;
13057 wxColour temp4 ;
13058 PyObject * obj0 = 0 ;
13059 PyObject * obj1 = 0 ;
13060 PyObject * obj2 = 0 ;
13061 PyObject * obj3 = 0 ;
13062 PyObject * obj4 = 0 ;
13063 char *kwnames[] = {
13064 (char *) "self",(char *) "x",(char *) "y",(char *) "col",(char *) "style", NULL
13065 };
13066
13067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_FloodFill",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13069 if (SWIG_arg_fail(1)) SWIG_fail;
13070 {
13071 arg2 = (int)(SWIG_As_int(obj1));
13072 if (SWIG_arg_fail(2)) SWIG_fail;
13073 }
13074 {
13075 arg3 = (int)(SWIG_As_int(obj2));
13076 if (SWIG_arg_fail(3)) SWIG_fail;
13077 }
13078 {
13079 arg4 = &temp4;
13080 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
13081 }
13082 if (obj4) {
13083 {
13084 arg5 = (int)(SWIG_As_int(obj4));
13085 if (SWIG_arg_fail(5)) SWIG_fail;
13086 }
13087 }
13088 {
13089 PyThreadState* __tstate = wxPyBeginAllowThreads();
13090 result = (bool)(arg1)->FloodFill(arg2,arg3,(wxColour const &)*arg4,arg5);
13091
13092 wxPyEndAllowThreads(__tstate);
13093 if (PyErr_Occurred()) SWIG_fail;
13094 }
13095 {
13096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13097 }
13098 return resultobj;
13099 fail:
13100 return NULL;
13101 }
13102
13103
13104 static PyObject *_wrap_DC_FloodFillPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13105 PyObject *resultobj;
13106 wxDC *arg1 = (wxDC *) 0 ;
13107 wxPoint *arg2 = 0 ;
13108 wxColour *arg3 = 0 ;
13109 int arg4 = (int) wxFLOOD_SURFACE ;
13110 bool result;
13111 wxPoint temp2 ;
13112 wxColour temp3 ;
13113 PyObject * obj0 = 0 ;
13114 PyObject * obj1 = 0 ;
13115 PyObject * obj2 = 0 ;
13116 PyObject * obj3 = 0 ;
13117 char *kwnames[] = {
13118 (char *) "self",(char *) "pt",(char *) "col",(char *) "style", NULL
13119 };
13120
13121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_FloodFillPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13123 if (SWIG_arg_fail(1)) SWIG_fail;
13124 {
13125 arg2 = &temp2;
13126 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13127 }
13128 {
13129 arg3 = &temp3;
13130 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
13131 }
13132 if (obj3) {
13133 {
13134 arg4 = (int)(SWIG_As_int(obj3));
13135 if (SWIG_arg_fail(4)) SWIG_fail;
13136 }
13137 }
13138 {
13139 PyThreadState* __tstate = wxPyBeginAllowThreads();
13140 result = (bool)(arg1)->FloodFill((wxPoint const &)*arg2,(wxColour const &)*arg3,arg4);
13141
13142 wxPyEndAllowThreads(__tstate);
13143 if (PyErr_Occurred()) SWIG_fail;
13144 }
13145 {
13146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13147 }
13148 return resultobj;
13149 fail:
13150 return NULL;
13151 }
13152
13153
13154 static PyObject *_wrap_DC_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
13155 PyObject *resultobj;
13156 wxDC *arg1 = (wxDC *) 0 ;
13157 int arg2 ;
13158 int arg3 ;
13159 wxColour result;
13160 PyObject * obj0 = 0 ;
13161 PyObject * obj1 = 0 ;
13162 PyObject * obj2 = 0 ;
13163 char *kwnames[] = {
13164 (char *) "self",(char *) "x",(char *) "y", NULL
13165 };
13166
13167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_GetPixel",kwnames,&obj0,&obj1,&obj2)) goto fail;
13168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13169 if (SWIG_arg_fail(1)) SWIG_fail;
13170 {
13171 arg2 = (int)(SWIG_As_int(obj1));
13172 if (SWIG_arg_fail(2)) SWIG_fail;
13173 }
13174 {
13175 arg3 = (int)(SWIG_As_int(obj2));
13176 if (SWIG_arg_fail(3)) SWIG_fail;
13177 }
13178 {
13179 PyThreadState* __tstate = wxPyBeginAllowThreads();
13180 result = wxDC_GetPixel(arg1,arg2,arg3);
13181
13182 wxPyEndAllowThreads(__tstate);
13183 if (PyErr_Occurred()) SWIG_fail;
13184 }
13185 {
13186 wxColour * resultptr;
13187 resultptr = new wxColour((wxColour &)(result));
13188 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13189 }
13190 return resultobj;
13191 fail:
13192 return NULL;
13193 }
13194
13195
13196 static PyObject *_wrap_DC_GetPixelPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13197 PyObject *resultobj;
13198 wxDC *arg1 = (wxDC *) 0 ;
13199 wxPoint *arg2 = 0 ;
13200 wxColour result;
13201 wxPoint temp2 ;
13202 PyObject * obj0 = 0 ;
13203 PyObject * obj1 = 0 ;
13204 char *kwnames[] = {
13205 (char *) "self",(char *) "pt", NULL
13206 };
13207
13208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPixelPoint",kwnames,&obj0,&obj1)) goto fail;
13209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13210 if (SWIG_arg_fail(1)) SWIG_fail;
13211 {
13212 arg2 = &temp2;
13213 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13214 }
13215 {
13216 PyThreadState* __tstate = wxPyBeginAllowThreads();
13217 result = wxDC_GetPixelPoint(arg1,(wxPoint const &)*arg2);
13218
13219 wxPyEndAllowThreads(__tstate);
13220 if (PyErr_Occurred()) SWIG_fail;
13221 }
13222 {
13223 wxColour * resultptr;
13224 resultptr = new wxColour((wxColour &)(result));
13225 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13226 }
13227 return resultobj;
13228 fail:
13229 return NULL;
13230 }
13231
13232
13233 static PyObject *_wrap_DC_DrawLine(PyObject *, PyObject *args, PyObject *kwargs) {
13234 PyObject *resultobj;
13235 wxDC *arg1 = (wxDC *) 0 ;
13236 int arg2 ;
13237 int arg3 ;
13238 int arg4 ;
13239 int arg5 ;
13240 PyObject * obj0 = 0 ;
13241 PyObject * obj1 = 0 ;
13242 PyObject * obj2 = 0 ;
13243 PyObject * obj3 = 0 ;
13244 PyObject * obj4 = 0 ;
13245 char *kwnames[] = {
13246 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2", NULL
13247 };
13248
13249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawLine",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13251 if (SWIG_arg_fail(1)) SWIG_fail;
13252 {
13253 arg2 = (int)(SWIG_As_int(obj1));
13254 if (SWIG_arg_fail(2)) SWIG_fail;
13255 }
13256 {
13257 arg3 = (int)(SWIG_As_int(obj2));
13258 if (SWIG_arg_fail(3)) SWIG_fail;
13259 }
13260 {
13261 arg4 = (int)(SWIG_As_int(obj3));
13262 if (SWIG_arg_fail(4)) SWIG_fail;
13263 }
13264 {
13265 arg5 = (int)(SWIG_As_int(obj4));
13266 if (SWIG_arg_fail(5)) SWIG_fail;
13267 }
13268 {
13269 PyThreadState* __tstate = wxPyBeginAllowThreads();
13270 (arg1)->DrawLine(arg2,arg3,arg4,arg5);
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_DrawLinePoint(PyObject *, PyObject *args, PyObject *kwargs) {
13283 PyObject *resultobj;
13284 wxDC *arg1 = (wxDC *) 0 ;
13285 wxPoint *arg2 = 0 ;
13286 wxPoint *arg3 = 0 ;
13287 wxPoint temp2 ;
13288 wxPoint temp3 ;
13289 PyObject * obj0 = 0 ;
13290 PyObject * obj1 = 0 ;
13291 PyObject * obj2 = 0 ;
13292 char *kwnames[] = {
13293 (char *) "self",(char *) "pt1",(char *) "pt2", NULL
13294 };
13295
13296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawLinePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13298 if (SWIG_arg_fail(1)) SWIG_fail;
13299 {
13300 arg2 = &temp2;
13301 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13302 }
13303 {
13304 arg3 = &temp3;
13305 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13306 }
13307 {
13308 PyThreadState* __tstate = wxPyBeginAllowThreads();
13309 (arg1)->DrawLine((wxPoint const &)*arg2,(wxPoint const &)*arg3);
13310
13311 wxPyEndAllowThreads(__tstate);
13312 if (PyErr_Occurred()) SWIG_fail;
13313 }
13314 Py_INCREF(Py_None); resultobj = Py_None;
13315 return resultobj;
13316 fail:
13317 return NULL;
13318 }
13319
13320
13321 static PyObject *_wrap_DC_CrossHair(PyObject *, PyObject *args, PyObject *kwargs) {
13322 PyObject *resultobj;
13323 wxDC *arg1 = (wxDC *) 0 ;
13324 int arg2 ;
13325 int arg3 ;
13326 PyObject * obj0 = 0 ;
13327 PyObject * obj1 = 0 ;
13328 PyObject * obj2 = 0 ;
13329 char *kwnames[] = {
13330 (char *) "self",(char *) "x",(char *) "y", NULL
13331 };
13332
13333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CrossHair",kwnames,&obj0,&obj1,&obj2)) goto fail;
13334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13335 if (SWIG_arg_fail(1)) SWIG_fail;
13336 {
13337 arg2 = (int)(SWIG_As_int(obj1));
13338 if (SWIG_arg_fail(2)) SWIG_fail;
13339 }
13340 {
13341 arg3 = (int)(SWIG_As_int(obj2));
13342 if (SWIG_arg_fail(3)) SWIG_fail;
13343 }
13344 {
13345 PyThreadState* __tstate = wxPyBeginAllowThreads();
13346 (arg1)->CrossHair(arg2,arg3);
13347
13348 wxPyEndAllowThreads(__tstate);
13349 if (PyErr_Occurred()) SWIG_fail;
13350 }
13351 Py_INCREF(Py_None); resultobj = Py_None;
13352 return resultobj;
13353 fail:
13354 return NULL;
13355 }
13356
13357
13358 static PyObject *_wrap_DC_CrossHairPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13359 PyObject *resultobj;
13360 wxDC *arg1 = (wxDC *) 0 ;
13361 wxPoint *arg2 = 0 ;
13362 wxPoint temp2 ;
13363 PyObject * obj0 = 0 ;
13364 PyObject * obj1 = 0 ;
13365 char *kwnames[] = {
13366 (char *) "self",(char *) "pt", NULL
13367 };
13368
13369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CrossHairPoint",kwnames,&obj0,&obj1)) goto fail;
13370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13371 if (SWIG_arg_fail(1)) SWIG_fail;
13372 {
13373 arg2 = &temp2;
13374 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13375 }
13376 {
13377 PyThreadState* __tstate = wxPyBeginAllowThreads();
13378 (arg1)->CrossHair((wxPoint const &)*arg2);
13379
13380 wxPyEndAllowThreads(__tstate);
13381 if (PyErr_Occurred()) SWIG_fail;
13382 }
13383 Py_INCREF(Py_None); resultobj = Py_None;
13384 return resultobj;
13385 fail:
13386 return NULL;
13387 }
13388
13389
13390 static PyObject *_wrap_DC_DrawArc(PyObject *, PyObject *args, PyObject *kwargs) {
13391 PyObject *resultobj;
13392 wxDC *arg1 = (wxDC *) 0 ;
13393 int arg2 ;
13394 int arg3 ;
13395 int arg4 ;
13396 int arg5 ;
13397 int arg6 ;
13398 int arg7 ;
13399 PyObject * obj0 = 0 ;
13400 PyObject * obj1 = 0 ;
13401 PyObject * obj2 = 0 ;
13402 PyObject * obj3 = 0 ;
13403 PyObject * obj4 = 0 ;
13404 PyObject * obj5 = 0 ;
13405 PyObject * obj6 = 0 ;
13406 char *kwnames[] = {
13407 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2",(char *) "xc",(char *) "yc", NULL
13408 };
13409
13410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13412 if (SWIG_arg_fail(1)) SWIG_fail;
13413 {
13414 arg2 = (int)(SWIG_As_int(obj1));
13415 if (SWIG_arg_fail(2)) SWIG_fail;
13416 }
13417 {
13418 arg3 = (int)(SWIG_As_int(obj2));
13419 if (SWIG_arg_fail(3)) SWIG_fail;
13420 }
13421 {
13422 arg4 = (int)(SWIG_As_int(obj3));
13423 if (SWIG_arg_fail(4)) SWIG_fail;
13424 }
13425 {
13426 arg5 = (int)(SWIG_As_int(obj4));
13427 if (SWIG_arg_fail(5)) SWIG_fail;
13428 }
13429 {
13430 arg6 = (int)(SWIG_As_int(obj5));
13431 if (SWIG_arg_fail(6)) SWIG_fail;
13432 }
13433 {
13434 arg7 = (int)(SWIG_As_int(obj6));
13435 if (SWIG_arg_fail(7)) SWIG_fail;
13436 }
13437 {
13438 PyThreadState* __tstate = wxPyBeginAllowThreads();
13439 (arg1)->DrawArc(arg2,arg3,arg4,arg5,arg6,arg7);
13440
13441 wxPyEndAllowThreads(__tstate);
13442 if (PyErr_Occurred()) SWIG_fail;
13443 }
13444 Py_INCREF(Py_None); resultobj = Py_None;
13445 return resultobj;
13446 fail:
13447 return NULL;
13448 }
13449
13450
13451 static PyObject *_wrap_DC_DrawArcPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13452 PyObject *resultobj;
13453 wxDC *arg1 = (wxDC *) 0 ;
13454 wxPoint *arg2 = 0 ;
13455 wxPoint *arg3 = 0 ;
13456 wxPoint *arg4 = 0 ;
13457 wxPoint temp2 ;
13458 wxPoint temp3 ;
13459 wxPoint temp4 ;
13460 PyObject * obj0 = 0 ;
13461 PyObject * obj1 = 0 ;
13462 PyObject * obj2 = 0 ;
13463 PyObject * obj3 = 0 ;
13464 char *kwnames[] = {
13465 (char *) "self",(char *) "pt1",(char *) "pt2",(char *) "center", NULL
13466 };
13467
13468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawArcPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13470 if (SWIG_arg_fail(1)) SWIG_fail;
13471 {
13472 arg2 = &temp2;
13473 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13474 }
13475 {
13476 arg3 = &temp3;
13477 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13478 }
13479 {
13480 arg4 = &temp4;
13481 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
13482 }
13483 {
13484 PyThreadState* __tstate = wxPyBeginAllowThreads();
13485 (arg1)->DrawArc((wxPoint const &)*arg2,(wxPoint const &)*arg3,(wxPoint const &)*arg4);
13486
13487 wxPyEndAllowThreads(__tstate);
13488 if (PyErr_Occurred()) SWIG_fail;
13489 }
13490 Py_INCREF(Py_None); resultobj = Py_None;
13491 return resultobj;
13492 fail:
13493 return NULL;
13494 }
13495
13496
13497 static PyObject *_wrap_DC_DrawCheckMark(PyObject *, PyObject *args, PyObject *kwargs) {
13498 PyObject *resultobj;
13499 wxDC *arg1 = (wxDC *) 0 ;
13500 int arg2 ;
13501 int arg3 ;
13502 int arg4 ;
13503 int arg5 ;
13504 PyObject * obj0 = 0 ;
13505 PyObject * obj1 = 0 ;
13506 PyObject * obj2 = 0 ;
13507 PyObject * obj3 = 0 ;
13508 PyObject * obj4 = 0 ;
13509 char *kwnames[] = {
13510 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13511 };
13512
13513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawCheckMark",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13515 if (SWIG_arg_fail(1)) SWIG_fail;
13516 {
13517 arg2 = (int)(SWIG_As_int(obj1));
13518 if (SWIG_arg_fail(2)) SWIG_fail;
13519 }
13520 {
13521 arg3 = (int)(SWIG_As_int(obj2));
13522 if (SWIG_arg_fail(3)) SWIG_fail;
13523 }
13524 {
13525 arg4 = (int)(SWIG_As_int(obj3));
13526 if (SWIG_arg_fail(4)) SWIG_fail;
13527 }
13528 {
13529 arg5 = (int)(SWIG_As_int(obj4));
13530 if (SWIG_arg_fail(5)) SWIG_fail;
13531 }
13532 {
13533 PyThreadState* __tstate = wxPyBeginAllowThreads();
13534 (arg1)->DrawCheckMark(arg2,arg3,arg4,arg5);
13535
13536 wxPyEndAllowThreads(__tstate);
13537 if (PyErr_Occurred()) SWIG_fail;
13538 }
13539 Py_INCREF(Py_None); resultobj = Py_None;
13540 return resultobj;
13541 fail:
13542 return NULL;
13543 }
13544
13545
13546 static PyObject *_wrap_DC_DrawCheckMarkRect(PyObject *, PyObject *args, PyObject *kwargs) {
13547 PyObject *resultobj;
13548 wxDC *arg1 = (wxDC *) 0 ;
13549 wxRect *arg2 = 0 ;
13550 wxRect temp2 ;
13551 PyObject * obj0 = 0 ;
13552 PyObject * obj1 = 0 ;
13553 char *kwnames[] = {
13554 (char *) "self",(char *) "rect", NULL
13555 };
13556
13557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawCheckMarkRect",kwnames,&obj0,&obj1)) goto fail;
13558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13559 if (SWIG_arg_fail(1)) SWIG_fail;
13560 {
13561 arg2 = &temp2;
13562 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13563 }
13564 {
13565 PyThreadState* __tstate = wxPyBeginAllowThreads();
13566 (arg1)->DrawCheckMark((wxRect const &)*arg2);
13567
13568 wxPyEndAllowThreads(__tstate);
13569 if (PyErr_Occurred()) SWIG_fail;
13570 }
13571 Py_INCREF(Py_None); resultobj = Py_None;
13572 return resultobj;
13573 fail:
13574 return NULL;
13575 }
13576
13577
13578 static PyObject *_wrap_DC_DrawEllipticArc(PyObject *, PyObject *args, PyObject *kwargs) {
13579 PyObject *resultobj;
13580 wxDC *arg1 = (wxDC *) 0 ;
13581 int arg2 ;
13582 int arg3 ;
13583 int arg4 ;
13584 int arg5 ;
13585 double arg6 ;
13586 double arg7 ;
13587 PyObject * obj0 = 0 ;
13588 PyObject * obj1 = 0 ;
13589 PyObject * obj2 = 0 ;
13590 PyObject * obj3 = 0 ;
13591 PyObject * obj4 = 0 ;
13592 PyObject * obj5 = 0 ;
13593 PyObject * obj6 = 0 ;
13594 char *kwnames[] = {
13595 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h",(char *) "start",(char *) "end", NULL
13596 };
13597
13598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawEllipticArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13600 if (SWIG_arg_fail(1)) SWIG_fail;
13601 {
13602 arg2 = (int)(SWIG_As_int(obj1));
13603 if (SWIG_arg_fail(2)) SWIG_fail;
13604 }
13605 {
13606 arg3 = (int)(SWIG_As_int(obj2));
13607 if (SWIG_arg_fail(3)) SWIG_fail;
13608 }
13609 {
13610 arg4 = (int)(SWIG_As_int(obj3));
13611 if (SWIG_arg_fail(4)) SWIG_fail;
13612 }
13613 {
13614 arg5 = (int)(SWIG_As_int(obj4));
13615 if (SWIG_arg_fail(5)) SWIG_fail;
13616 }
13617 {
13618 arg6 = (double)(SWIG_As_double(obj5));
13619 if (SWIG_arg_fail(6)) SWIG_fail;
13620 }
13621 {
13622 arg7 = (double)(SWIG_As_double(obj6));
13623 if (SWIG_arg_fail(7)) SWIG_fail;
13624 }
13625 {
13626 PyThreadState* __tstate = wxPyBeginAllowThreads();
13627 (arg1)->DrawEllipticArc(arg2,arg3,arg4,arg5,arg6,arg7);
13628
13629 wxPyEndAllowThreads(__tstate);
13630 if (PyErr_Occurred()) SWIG_fail;
13631 }
13632 Py_INCREF(Py_None); resultobj = Py_None;
13633 return resultobj;
13634 fail:
13635 return NULL;
13636 }
13637
13638
13639 static PyObject *_wrap_DC_DrawEllipticArcPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13640 PyObject *resultobj;
13641 wxDC *arg1 = (wxDC *) 0 ;
13642 wxPoint *arg2 = 0 ;
13643 wxSize *arg3 = 0 ;
13644 double arg4 ;
13645 double arg5 ;
13646 wxPoint temp2 ;
13647 wxSize temp3 ;
13648 PyObject * obj0 = 0 ;
13649 PyObject * obj1 = 0 ;
13650 PyObject * obj2 = 0 ;
13651 PyObject * obj3 = 0 ;
13652 PyObject * obj4 = 0 ;
13653 char *kwnames[] = {
13654 (char *) "self",(char *) "pt",(char *) "sz",(char *) "start",(char *) "end", NULL
13655 };
13656
13657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipticArcPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13659 if (SWIG_arg_fail(1)) SWIG_fail;
13660 {
13661 arg2 = &temp2;
13662 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13663 }
13664 {
13665 arg3 = &temp3;
13666 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13667 }
13668 {
13669 arg4 = (double)(SWIG_As_double(obj3));
13670 if (SWIG_arg_fail(4)) SWIG_fail;
13671 }
13672 {
13673 arg5 = (double)(SWIG_As_double(obj4));
13674 if (SWIG_arg_fail(5)) SWIG_fail;
13675 }
13676 {
13677 PyThreadState* __tstate = wxPyBeginAllowThreads();
13678 (arg1)->DrawEllipticArc((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,arg5);
13679
13680 wxPyEndAllowThreads(__tstate);
13681 if (PyErr_Occurred()) SWIG_fail;
13682 }
13683 Py_INCREF(Py_None); resultobj = Py_None;
13684 return resultobj;
13685 fail:
13686 return NULL;
13687 }
13688
13689
13690 static PyObject *_wrap_DC_DrawPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13691 PyObject *resultobj;
13692 wxDC *arg1 = (wxDC *) 0 ;
13693 int arg2 ;
13694 int arg3 ;
13695 PyObject * obj0 = 0 ;
13696 PyObject * obj1 = 0 ;
13697 PyObject * obj2 = 0 ;
13698 char *kwnames[] = {
13699 (char *) "self",(char *) "x",(char *) "y", NULL
13700 };
13701
13702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13704 if (SWIG_arg_fail(1)) SWIG_fail;
13705 {
13706 arg2 = (int)(SWIG_As_int(obj1));
13707 if (SWIG_arg_fail(2)) SWIG_fail;
13708 }
13709 {
13710 arg3 = (int)(SWIG_As_int(obj2));
13711 if (SWIG_arg_fail(3)) SWIG_fail;
13712 }
13713 {
13714 PyThreadState* __tstate = wxPyBeginAllowThreads();
13715 (arg1)->DrawPoint(arg2,arg3);
13716
13717 wxPyEndAllowThreads(__tstate);
13718 if (PyErr_Occurred()) SWIG_fail;
13719 }
13720 Py_INCREF(Py_None); resultobj = Py_None;
13721 return resultobj;
13722 fail:
13723 return NULL;
13724 }
13725
13726
13727 static PyObject *_wrap_DC_DrawPointPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13728 PyObject *resultobj;
13729 wxDC *arg1 = (wxDC *) 0 ;
13730 wxPoint *arg2 = 0 ;
13731 wxPoint temp2 ;
13732 PyObject * obj0 = 0 ;
13733 PyObject * obj1 = 0 ;
13734 char *kwnames[] = {
13735 (char *) "self",(char *) "pt", NULL
13736 };
13737
13738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawPointPoint",kwnames,&obj0,&obj1)) goto fail;
13739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13740 if (SWIG_arg_fail(1)) SWIG_fail;
13741 {
13742 arg2 = &temp2;
13743 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13744 }
13745 {
13746 PyThreadState* __tstate = wxPyBeginAllowThreads();
13747 (arg1)->DrawPoint((wxPoint const &)*arg2);
13748
13749 wxPyEndAllowThreads(__tstate);
13750 if (PyErr_Occurred()) SWIG_fail;
13751 }
13752 Py_INCREF(Py_None); resultobj = Py_None;
13753 return resultobj;
13754 fail:
13755 return NULL;
13756 }
13757
13758
13759 static PyObject *_wrap_DC_DrawRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
13760 PyObject *resultobj;
13761 wxDC *arg1 = (wxDC *) 0 ;
13762 int arg2 ;
13763 int arg3 ;
13764 int arg4 ;
13765 int arg5 ;
13766 PyObject * obj0 = 0 ;
13767 PyObject * obj1 = 0 ;
13768 PyObject * obj2 = 0 ;
13769 PyObject * obj3 = 0 ;
13770 PyObject * obj4 = 0 ;
13771 char *kwnames[] = {
13772 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13773 };
13774
13775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13777 if (SWIG_arg_fail(1)) SWIG_fail;
13778 {
13779 arg2 = (int)(SWIG_As_int(obj1));
13780 if (SWIG_arg_fail(2)) SWIG_fail;
13781 }
13782 {
13783 arg3 = (int)(SWIG_As_int(obj2));
13784 if (SWIG_arg_fail(3)) SWIG_fail;
13785 }
13786 {
13787 arg4 = (int)(SWIG_As_int(obj3));
13788 if (SWIG_arg_fail(4)) SWIG_fail;
13789 }
13790 {
13791 arg5 = (int)(SWIG_As_int(obj4));
13792 if (SWIG_arg_fail(5)) SWIG_fail;
13793 }
13794 {
13795 PyThreadState* __tstate = wxPyBeginAllowThreads();
13796 (arg1)->DrawRectangle(arg2,arg3,arg4,arg5);
13797
13798 wxPyEndAllowThreads(__tstate);
13799 if (PyErr_Occurred()) SWIG_fail;
13800 }
13801 Py_INCREF(Py_None); resultobj = Py_None;
13802 return resultobj;
13803 fail:
13804 return NULL;
13805 }
13806
13807
13808 static PyObject *_wrap_DC_DrawRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13809 PyObject *resultobj;
13810 wxDC *arg1 = (wxDC *) 0 ;
13811 wxRect *arg2 = 0 ;
13812 wxRect temp2 ;
13813 PyObject * obj0 = 0 ;
13814 PyObject * obj1 = 0 ;
13815 char *kwnames[] = {
13816 (char *) "self",(char *) "rect", NULL
13817 };
13818
13819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawRectangleRect",kwnames,&obj0,&obj1)) goto fail;
13820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13821 if (SWIG_arg_fail(1)) SWIG_fail;
13822 {
13823 arg2 = &temp2;
13824 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13825 }
13826 {
13827 PyThreadState* __tstate = wxPyBeginAllowThreads();
13828 (arg1)->DrawRectangle((wxRect const &)*arg2);
13829
13830 wxPyEndAllowThreads(__tstate);
13831 if (PyErr_Occurred()) SWIG_fail;
13832 }
13833 Py_INCREF(Py_None); resultobj = Py_None;
13834 return resultobj;
13835 fail:
13836 return NULL;
13837 }
13838
13839
13840 static PyObject *_wrap_DC_DrawRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13841 PyObject *resultobj;
13842 wxDC *arg1 = (wxDC *) 0 ;
13843 wxPoint *arg2 = 0 ;
13844 wxSize *arg3 = 0 ;
13845 wxPoint temp2 ;
13846 wxSize temp3 ;
13847 PyObject * obj0 = 0 ;
13848 PyObject * obj1 = 0 ;
13849 PyObject * obj2 = 0 ;
13850 char *kwnames[] = {
13851 (char *) "self",(char *) "pt",(char *) "sz", NULL
13852 };
13853
13854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRectanglePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13856 if (SWIG_arg_fail(1)) SWIG_fail;
13857 {
13858 arg2 = &temp2;
13859 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13860 }
13861 {
13862 arg3 = &temp3;
13863 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13864 }
13865 {
13866 PyThreadState* __tstate = wxPyBeginAllowThreads();
13867 (arg1)->DrawRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3);
13868
13869 wxPyEndAllowThreads(__tstate);
13870 if (PyErr_Occurred()) SWIG_fail;
13871 }
13872 Py_INCREF(Py_None); resultobj = Py_None;
13873 return resultobj;
13874 fail:
13875 return NULL;
13876 }
13877
13878
13879 static PyObject *_wrap_DC_DrawRoundedRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
13880 PyObject *resultobj;
13881 wxDC *arg1 = (wxDC *) 0 ;
13882 int arg2 ;
13883 int arg3 ;
13884 int arg4 ;
13885 int arg5 ;
13886 double arg6 ;
13887 PyObject * obj0 = 0 ;
13888 PyObject * obj1 = 0 ;
13889 PyObject * obj2 = 0 ;
13890 PyObject * obj3 = 0 ;
13891 PyObject * obj4 = 0 ;
13892 PyObject * obj5 = 0 ;
13893 char *kwnames[] = {
13894 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "radius", NULL
13895 };
13896
13897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:DC_DrawRoundedRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
13898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13899 if (SWIG_arg_fail(1)) SWIG_fail;
13900 {
13901 arg2 = (int)(SWIG_As_int(obj1));
13902 if (SWIG_arg_fail(2)) SWIG_fail;
13903 }
13904 {
13905 arg3 = (int)(SWIG_As_int(obj2));
13906 if (SWIG_arg_fail(3)) SWIG_fail;
13907 }
13908 {
13909 arg4 = (int)(SWIG_As_int(obj3));
13910 if (SWIG_arg_fail(4)) SWIG_fail;
13911 }
13912 {
13913 arg5 = (int)(SWIG_As_int(obj4));
13914 if (SWIG_arg_fail(5)) SWIG_fail;
13915 }
13916 {
13917 arg6 = (double)(SWIG_As_double(obj5));
13918 if (SWIG_arg_fail(6)) SWIG_fail;
13919 }
13920 {
13921 PyThreadState* __tstate = wxPyBeginAllowThreads();
13922 (arg1)->DrawRoundedRectangle(arg2,arg3,arg4,arg5,arg6);
13923
13924 wxPyEndAllowThreads(__tstate);
13925 if (PyErr_Occurred()) SWIG_fail;
13926 }
13927 Py_INCREF(Py_None); resultobj = Py_None;
13928 return resultobj;
13929 fail:
13930 return NULL;
13931 }
13932
13933
13934 static PyObject *_wrap_DC_DrawRoundedRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13935 PyObject *resultobj;
13936 wxDC *arg1 = (wxDC *) 0 ;
13937 wxRect *arg2 = 0 ;
13938 double arg3 ;
13939 wxRect temp2 ;
13940 PyObject * obj0 = 0 ;
13941 PyObject * obj1 = 0 ;
13942 PyObject * obj2 = 0 ;
13943 char *kwnames[] = {
13944 (char *) "self",(char *) "r",(char *) "radius", NULL
13945 };
13946
13947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRoundedRectangleRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
13948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13949 if (SWIG_arg_fail(1)) SWIG_fail;
13950 {
13951 arg2 = &temp2;
13952 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13953 }
13954 {
13955 arg3 = (double)(SWIG_As_double(obj2));
13956 if (SWIG_arg_fail(3)) SWIG_fail;
13957 }
13958 {
13959 PyThreadState* __tstate = wxPyBeginAllowThreads();
13960 (arg1)->DrawRoundedRectangle((wxRect const &)*arg2,arg3);
13961
13962 wxPyEndAllowThreads(__tstate);
13963 if (PyErr_Occurred()) SWIG_fail;
13964 }
13965 Py_INCREF(Py_None); resultobj = Py_None;
13966 return resultobj;
13967 fail:
13968 return NULL;
13969 }
13970
13971
13972 static PyObject *_wrap_DC_DrawRoundedRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13973 PyObject *resultobj;
13974 wxDC *arg1 = (wxDC *) 0 ;
13975 wxPoint *arg2 = 0 ;
13976 wxSize *arg3 = 0 ;
13977 double arg4 ;
13978 wxPoint temp2 ;
13979 wxSize temp3 ;
13980 PyObject * obj0 = 0 ;
13981 PyObject * obj1 = 0 ;
13982 PyObject * obj2 = 0 ;
13983 PyObject * obj3 = 0 ;
13984 char *kwnames[] = {
13985 (char *) "self",(char *) "pt",(char *) "sz",(char *) "radius", NULL
13986 };
13987
13988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRoundedRectanglePointSize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13990 if (SWIG_arg_fail(1)) SWIG_fail;
13991 {
13992 arg2 = &temp2;
13993 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13994 }
13995 {
13996 arg3 = &temp3;
13997 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13998 }
13999 {
14000 arg4 = (double)(SWIG_As_double(obj3));
14001 if (SWIG_arg_fail(4)) SWIG_fail;
14002 }
14003 {
14004 PyThreadState* __tstate = wxPyBeginAllowThreads();
14005 (arg1)->DrawRoundedRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4);
14006
14007 wxPyEndAllowThreads(__tstate);
14008 if (PyErr_Occurred()) SWIG_fail;
14009 }
14010 Py_INCREF(Py_None); resultobj = Py_None;
14011 return resultobj;
14012 fail:
14013 return NULL;
14014 }
14015
14016
14017 static PyObject *_wrap_DC_DrawCircle(PyObject *, PyObject *args, PyObject *kwargs) {
14018 PyObject *resultobj;
14019 wxDC *arg1 = (wxDC *) 0 ;
14020 int arg2 ;
14021 int arg3 ;
14022 int arg4 ;
14023 PyObject * obj0 = 0 ;
14024 PyObject * obj1 = 0 ;
14025 PyObject * obj2 = 0 ;
14026 PyObject * obj3 = 0 ;
14027 char *kwnames[] = {
14028 (char *) "self",(char *) "x",(char *) "y",(char *) "radius", NULL
14029 };
14030
14031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawCircle",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14033 if (SWIG_arg_fail(1)) SWIG_fail;
14034 {
14035 arg2 = (int)(SWIG_As_int(obj1));
14036 if (SWIG_arg_fail(2)) SWIG_fail;
14037 }
14038 {
14039 arg3 = (int)(SWIG_As_int(obj2));
14040 if (SWIG_arg_fail(3)) SWIG_fail;
14041 }
14042 {
14043 arg4 = (int)(SWIG_As_int(obj3));
14044 if (SWIG_arg_fail(4)) SWIG_fail;
14045 }
14046 {
14047 PyThreadState* __tstate = wxPyBeginAllowThreads();
14048 (arg1)->DrawCircle(arg2,arg3,arg4);
14049
14050 wxPyEndAllowThreads(__tstate);
14051 if (PyErr_Occurred()) SWIG_fail;
14052 }
14053 Py_INCREF(Py_None); resultobj = Py_None;
14054 return resultobj;
14055 fail:
14056 return NULL;
14057 }
14058
14059
14060 static PyObject *_wrap_DC_DrawCirclePoint(PyObject *, PyObject *args, PyObject *kwargs) {
14061 PyObject *resultobj;
14062 wxDC *arg1 = (wxDC *) 0 ;
14063 wxPoint *arg2 = 0 ;
14064 int arg3 ;
14065 wxPoint temp2 ;
14066 PyObject * obj0 = 0 ;
14067 PyObject * obj1 = 0 ;
14068 PyObject * obj2 = 0 ;
14069 char *kwnames[] = {
14070 (char *) "self",(char *) "pt",(char *) "radius", NULL
14071 };
14072
14073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawCirclePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
14074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14075 if (SWIG_arg_fail(1)) SWIG_fail;
14076 {
14077 arg2 = &temp2;
14078 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14079 }
14080 {
14081 arg3 = (int)(SWIG_As_int(obj2));
14082 if (SWIG_arg_fail(3)) SWIG_fail;
14083 }
14084 {
14085 PyThreadState* __tstate = wxPyBeginAllowThreads();
14086 (arg1)->DrawCircle((wxPoint const &)*arg2,arg3);
14087
14088 wxPyEndAllowThreads(__tstate);
14089 if (PyErr_Occurred()) SWIG_fail;
14090 }
14091 Py_INCREF(Py_None); resultobj = Py_None;
14092 return resultobj;
14093 fail:
14094 return NULL;
14095 }
14096
14097
14098 static PyObject *_wrap_DC_DrawEllipse(PyObject *, PyObject *args, PyObject *kwargs) {
14099 PyObject *resultobj;
14100 wxDC *arg1 = (wxDC *) 0 ;
14101 int arg2 ;
14102 int arg3 ;
14103 int arg4 ;
14104 int arg5 ;
14105 PyObject * obj0 = 0 ;
14106 PyObject * obj1 = 0 ;
14107 PyObject * obj2 = 0 ;
14108 PyObject * obj3 = 0 ;
14109 PyObject * obj4 = 0 ;
14110 char *kwnames[] = {
14111 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
14112 };
14113
14114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipse",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14116 if (SWIG_arg_fail(1)) SWIG_fail;
14117 {
14118 arg2 = (int)(SWIG_As_int(obj1));
14119 if (SWIG_arg_fail(2)) SWIG_fail;
14120 }
14121 {
14122 arg3 = (int)(SWIG_As_int(obj2));
14123 if (SWIG_arg_fail(3)) SWIG_fail;
14124 }
14125 {
14126 arg4 = (int)(SWIG_As_int(obj3));
14127 if (SWIG_arg_fail(4)) SWIG_fail;
14128 }
14129 {
14130 arg5 = (int)(SWIG_As_int(obj4));
14131 if (SWIG_arg_fail(5)) SWIG_fail;
14132 }
14133 {
14134 PyThreadState* __tstate = wxPyBeginAllowThreads();
14135 (arg1)->DrawEllipse(arg2,arg3,arg4,arg5);
14136
14137 wxPyEndAllowThreads(__tstate);
14138 if (PyErr_Occurred()) SWIG_fail;
14139 }
14140 Py_INCREF(Py_None); resultobj = Py_None;
14141 return resultobj;
14142 fail:
14143 return NULL;
14144 }
14145
14146
14147 static PyObject *_wrap_DC_DrawEllipseRect(PyObject *, PyObject *args, PyObject *kwargs) {
14148 PyObject *resultobj;
14149 wxDC *arg1 = (wxDC *) 0 ;
14150 wxRect *arg2 = 0 ;
14151 wxRect temp2 ;
14152 PyObject * obj0 = 0 ;
14153 PyObject * obj1 = 0 ;
14154 char *kwnames[] = {
14155 (char *) "self",(char *) "rect", NULL
14156 };
14157
14158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawEllipseRect",kwnames,&obj0,&obj1)) goto fail;
14159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14160 if (SWIG_arg_fail(1)) SWIG_fail;
14161 {
14162 arg2 = &temp2;
14163 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14164 }
14165 {
14166 PyThreadState* __tstate = wxPyBeginAllowThreads();
14167 (arg1)->DrawEllipse((wxRect const &)*arg2);
14168
14169 wxPyEndAllowThreads(__tstate);
14170 if (PyErr_Occurred()) SWIG_fail;
14171 }
14172 Py_INCREF(Py_None); resultobj = Py_None;
14173 return resultobj;
14174 fail:
14175 return NULL;
14176 }
14177
14178
14179 static PyObject *_wrap_DC_DrawEllipsePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14180 PyObject *resultobj;
14181 wxDC *arg1 = (wxDC *) 0 ;
14182 wxPoint *arg2 = 0 ;
14183 wxSize *arg3 = 0 ;
14184 wxPoint temp2 ;
14185 wxSize temp3 ;
14186 PyObject * obj0 = 0 ;
14187 PyObject * obj1 = 0 ;
14188 PyObject * obj2 = 0 ;
14189 char *kwnames[] = {
14190 (char *) "self",(char *) "pt",(char *) "sz", NULL
14191 };
14192
14193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawEllipsePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14195 if (SWIG_arg_fail(1)) SWIG_fail;
14196 {
14197 arg2 = &temp2;
14198 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14199 }
14200 {
14201 arg3 = &temp3;
14202 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14203 }
14204 {
14205 PyThreadState* __tstate = wxPyBeginAllowThreads();
14206 (arg1)->DrawEllipse((wxPoint const &)*arg2,(wxSize const &)*arg3);
14207
14208 wxPyEndAllowThreads(__tstate);
14209 if (PyErr_Occurred()) SWIG_fail;
14210 }
14211 Py_INCREF(Py_None); resultobj = Py_None;
14212 return resultobj;
14213 fail:
14214 return NULL;
14215 }
14216
14217
14218 static PyObject *_wrap_DC_DrawIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14219 PyObject *resultobj;
14220 wxDC *arg1 = (wxDC *) 0 ;
14221 wxIcon *arg2 = 0 ;
14222 int arg3 ;
14223 int arg4 ;
14224 PyObject * obj0 = 0 ;
14225 PyObject * obj1 = 0 ;
14226 PyObject * obj2 = 0 ;
14227 PyObject * obj3 = 0 ;
14228 char *kwnames[] = {
14229 (char *) "self",(char *) "icon",(char *) "x",(char *) "y", NULL
14230 };
14231
14232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawIcon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14234 if (SWIG_arg_fail(1)) SWIG_fail;
14235 {
14236 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
14237 if (SWIG_arg_fail(2)) SWIG_fail;
14238 if (arg2 == NULL) {
14239 SWIG_null_ref("wxIcon");
14240 }
14241 if (SWIG_arg_fail(2)) SWIG_fail;
14242 }
14243 {
14244 arg3 = (int)(SWIG_As_int(obj2));
14245 if (SWIG_arg_fail(3)) SWIG_fail;
14246 }
14247 {
14248 arg4 = (int)(SWIG_As_int(obj3));
14249 if (SWIG_arg_fail(4)) SWIG_fail;
14250 }
14251 {
14252 PyThreadState* __tstate = wxPyBeginAllowThreads();
14253 (arg1)->DrawIcon((wxIcon const &)*arg2,arg3,arg4);
14254
14255 wxPyEndAllowThreads(__tstate);
14256 if (PyErr_Occurred()) SWIG_fail;
14257 }
14258 Py_INCREF(Py_None); resultobj = Py_None;
14259 return resultobj;
14260 fail:
14261 return NULL;
14262 }
14263
14264
14265 static PyObject *_wrap_DC_DrawIconPoint(PyObject *, PyObject *args, PyObject *kwargs) {
14266 PyObject *resultobj;
14267 wxDC *arg1 = (wxDC *) 0 ;
14268 wxIcon *arg2 = 0 ;
14269 wxPoint *arg3 = 0 ;
14270 wxPoint temp3 ;
14271 PyObject * obj0 = 0 ;
14272 PyObject * obj1 = 0 ;
14273 PyObject * obj2 = 0 ;
14274 char *kwnames[] = {
14275 (char *) "self",(char *) "icon",(char *) "pt", NULL
14276 };
14277
14278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawIconPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
14279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14280 if (SWIG_arg_fail(1)) SWIG_fail;
14281 {
14282 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
14283 if (SWIG_arg_fail(2)) SWIG_fail;
14284 if (arg2 == NULL) {
14285 SWIG_null_ref("wxIcon");
14286 }
14287 if (SWIG_arg_fail(2)) SWIG_fail;
14288 }
14289 {
14290 arg3 = &temp3;
14291 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14292 }
14293 {
14294 PyThreadState* __tstate = wxPyBeginAllowThreads();
14295 (arg1)->DrawIcon((wxIcon const &)*arg2,(wxPoint const &)*arg3);
14296
14297 wxPyEndAllowThreads(__tstate);
14298 if (PyErr_Occurred()) SWIG_fail;
14299 }
14300 Py_INCREF(Py_None); resultobj = Py_None;
14301 return resultobj;
14302 fail:
14303 return NULL;
14304 }
14305
14306
14307 static PyObject *_wrap_DC_DrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
14308 PyObject *resultobj;
14309 wxDC *arg1 = (wxDC *) 0 ;
14310 wxBitmap *arg2 = 0 ;
14311 int arg3 ;
14312 int arg4 ;
14313 bool arg5 = (bool) false ;
14314 PyObject * obj0 = 0 ;
14315 PyObject * obj1 = 0 ;
14316 PyObject * obj2 = 0 ;
14317 PyObject * obj3 = 0 ;
14318 PyObject * obj4 = 0 ;
14319 char *kwnames[] = {
14320 (char *) "self",(char *) "bmp",(char *) "x",(char *) "y",(char *) "useMask", NULL
14321 };
14322
14323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_DrawBitmap",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14325 if (SWIG_arg_fail(1)) SWIG_fail;
14326 {
14327 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
14328 if (SWIG_arg_fail(2)) SWIG_fail;
14329 if (arg2 == NULL) {
14330 SWIG_null_ref("wxBitmap");
14331 }
14332 if (SWIG_arg_fail(2)) SWIG_fail;
14333 }
14334 {
14335 arg3 = (int)(SWIG_As_int(obj2));
14336 if (SWIG_arg_fail(3)) SWIG_fail;
14337 }
14338 {
14339 arg4 = (int)(SWIG_As_int(obj3));
14340 if (SWIG_arg_fail(4)) SWIG_fail;
14341 }
14342 if (obj4) {
14343 {
14344 arg5 = (bool)(SWIG_As_bool(obj4));
14345 if (SWIG_arg_fail(5)) SWIG_fail;
14346 }
14347 }
14348 {
14349 PyThreadState* __tstate = wxPyBeginAllowThreads();
14350 (arg1)->DrawBitmap((wxBitmap const &)*arg2,arg3,arg4,arg5);
14351
14352 wxPyEndAllowThreads(__tstate);
14353 if (PyErr_Occurred()) SWIG_fail;
14354 }
14355 Py_INCREF(Py_None); resultobj = Py_None;
14356 return resultobj;
14357 fail:
14358 return NULL;
14359 }
14360
14361
14362 static PyObject *_wrap_DC_DrawBitmapPoint(PyObject *, PyObject *args, PyObject *kwargs) {
14363 PyObject *resultobj;
14364 wxDC *arg1 = (wxDC *) 0 ;
14365 wxBitmap *arg2 = 0 ;
14366 wxPoint *arg3 = 0 ;
14367 bool arg4 = (bool) false ;
14368 wxPoint temp3 ;
14369 PyObject * obj0 = 0 ;
14370 PyObject * obj1 = 0 ;
14371 PyObject * obj2 = 0 ;
14372 PyObject * obj3 = 0 ;
14373 char *kwnames[] = {
14374 (char *) "self",(char *) "bmp",(char *) "pt",(char *) "useMask", NULL
14375 };
14376
14377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_DrawBitmapPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14379 if (SWIG_arg_fail(1)) SWIG_fail;
14380 {
14381 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
14382 if (SWIG_arg_fail(2)) SWIG_fail;
14383 if (arg2 == NULL) {
14384 SWIG_null_ref("wxBitmap");
14385 }
14386 if (SWIG_arg_fail(2)) SWIG_fail;
14387 }
14388 {
14389 arg3 = &temp3;
14390 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14391 }
14392 if (obj3) {
14393 {
14394 arg4 = (bool)(SWIG_As_bool(obj3));
14395 if (SWIG_arg_fail(4)) SWIG_fail;
14396 }
14397 }
14398 {
14399 PyThreadState* __tstate = wxPyBeginAllowThreads();
14400 (arg1)->DrawBitmap((wxBitmap const &)*arg2,(wxPoint const &)*arg3,arg4);
14401
14402 wxPyEndAllowThreads(__tstate);
14403 if (PyErr_Occurred()) SWIG_fail;
14404 }
14405 Py_INCREF(Py_None); resultobj = Py_None;
14406 return resultobj;
14407 fail:
14408 return NULL;
14409 }
14410
14411
14412 static PyObject *_wrap_DC_DrawText(PyObject *, PyObject *args, PyObject *kwargs) {
14413 PyObject *resultobj;
14414 wxDC *arg1 = (wxDC *) 0 ;
14415 wxString *arg2 = 0 ;
14416 int arg3 ;
14417 int arg4 ;
14418 bool temp2 = false ;
14419 PyObject * obj0 = 0 ;
14420 PyObject * obj1 = 0 ;
14421 PyObject * obj2 = 0 ;
14422 PyObject * obj3 = 0 ;
14423 char *kwnames[] = {
14424 (char *) "self",(char *) "text",(char *) "x",(char *) "y", NULL
14425 };
14426
14427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawText",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14429 if (SWIG_arg_fail(1)) SWIG_fail;
14430 {
14431 arg2 = wxString_in_helper(obj1);
14432 if (arg2 == NULL) SWIG_fail;
14433 temp2 = true;
14434 }
14435 {
14436 arg3 = (int)(SWIG_As_int(obj2));
14437 if (SWIG_arg_fail(3)) SWIG_fail;
14438 }
14439 {
14440 arg4 = (int)(SWIG_As_int(obj3));
14441 if (SWIG_arg_fail(4)) SWIG_fail;
14442 }
14443 {
14444 PyThreadState* __tstate = wxPyBeginAllowThreads();
14445 (arg1)->DrawText((wxString const &)*arg2,arg3,arg4);
14446
14447 wxPyEndAllowThreads(__tstate);
14448 if (PyErr_Occurred()) SWIG_fail;
14449 }
14450 Py_INCREF(Py_None); resultobj = Py_None;
14451 {
14452 if (temp2)
14453 delete arg2;
14454 }
14455 return resultobj;
14456 fail:
14457 {
14458 if (temp2)
14459 delete arg2;
14460 }
14461 return NULL;
14462 }
14463
14464
14465 static PyObject *_wrap_DC_DrawTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
14466 PyObject *resultobj;
14467 wxDC *arg1 = (wxDC *) 0 ;
14468 wxString *arg2 = 0 ;
14469 wxPoint *arg3 = 0 ;
14470 bool temp2 = false ;
14471 wxPoint temp3 ;
14472 PyObject * obj0 = 0 ;
14473 PyObject * obj1 = 0 ;
14474 PyObject * obj2 = 0 ;
14475 char *kwnames[] = {
14476 (char *) "self",(char *) "text",(char *) "pt", NULL
14477 };
14478
14479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawTextPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
14480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14481 if (SWIG_arg_fail(1)) SWIG_fail;
14482 {
14483 arg2 = wxString_in_helper(obj1);
14484 if (arg2 == NULL) SWIG_fail;
14485 temp2 = true;
14486 }
14487 {
14488 arg3 = &temp3;
14489 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14490 }
14491 {
14492 PyThreadState* __tstate = wxPyBeginAllowThreads();
14493 (arg1)->DrawText((wxString const &)*arg2,(wxPoint const &)*arg3);
14494
14495 wxPyEndAllowThreads(__tstate);
14496 if (PyErr_Occurred()) SWIG_fail;
14497 }
14498 Py_INCREF(Py_None); resultobj = Py_None;
14499 {
14500 if (temp2)
14501 delete arg2;
14502 }
14503 return resultobj;
14504 fail:
14505 {
14506 if (temp2)
14507 delete arg2;
14508 }
14509 return NULL;
14510 }
14511
14512
14513 static PyObject *_wrap_DC_DrawRotatedText(PyObject *, PyObject *args, PyObject *kwargs) {
14514 PyObject *resultobj;
14515 wxDC *arg1 = (wxDC *) 0 ;
14516 wxString *arg2 = 0 ;
14517 int arg3 ;
14518 int arg4 ;
14519 double arg5 ;
14520 bool temp2 = false ;
14521 PyObject * obj0 = 0 ;
14522 PyObject * obj1 = 0 ;
14523 PyObject * obj2 = 0 ;
14524 PyObject * obj3 = 0 ;
14525 PyObject * obj4 = 0 ;
14526 char *kwnames[] = {
14527 (char *) "self",(char *) "text",(char *) "x",(char *) "y",(char *) "angle", NULL
14528 };
14529
14530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRotatedText",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14532 if (SWIG_arg_fail(1)) SWIG_fail;
14533 {
14534 arg2 = wxString_in_helper(obj1);
14535 if (arg2 == NULL) SWIG_fail;
14536 temp2 = true;
14537 }
14538 {
14539 arg3 = (int)(SWIG_As_int(obj2));
14540 if (SWIG_arg_fail(3)) SWIG_fail;
14541 }
14542 {
14543 arg4 = (int)(SWIG_As_int(obj3));
14544 if (SWIG_arg_fail(4)) SWIG_fail;
14545 }
14546 {
14547 arg5 = (double)(SWIG_As_double(obj4));
14548 if (SWIG_arg_fail(5)) SWIG_fail;
14549 }
14550 {
14551 PyThreadState* __tstate = wxPyBeginAllowThreads();
14552 (arg1)->DrawRotatedText((wxString const &)*arg2,arg3,arg4,arg5);
14553
14554 wxPyEndAllowThreads(__tstate);
14555 if (PyErr_Occurred()) SWIG_fail;
14556 }
14557 Py_INCREF(Py_None); resultobj = Py_None;
14558 {
14559 if (temp2)
14560 delete arg2;
14561 }
14562 return resultobj;
14563 fail:
14564 {
14565 if (temp2)
14566 delete arg2;
14567 }
14568 return NULL;
14569 }
14570
14571
14572 static PyObject *_wrap_DC_DrawRotatedTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
14573 PyObject *resultobj;
14574 wxDC *arg1 = (wxDC *) 0 ;
14575 wxString *arg2 = 0 ;
14576 wxPoint *arg3 = 0 ;
14577 double arg4 ;
14578 bool temp2 = false ;
14579 wxPoint temp3 ;
14580 PyObject * obj0 = 0 ;
14581 PyObject * obj1 = 0 ;
14582 PyObject * obj2 = 0 ;
14583 PyObject * obj3 = 0 ;
14584 char *kwnames[] = {
14585 (char *) "self",(char *) "text",(char *) "pt",(char *) "angle", NULL
14586 };
14587
14588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRotatedTextPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14590 if (SWIG_arg_fail(1)) SWIG_fail;
14591 {
14592 arg2 = wxString_in_helper(obj1);
14593 if (arg2 == NULL) SWIG_fail;
14594 temp2 = true;
14595 }
14596 {
14597 arg3 = &temp3;
14598 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14599 }
14600 {
14601 arg4 = (double)(SWIG_As_double(obj3));
14602 if (SWIG_arg_fail(4)) SWIG_fail;
14603 }
14604 {
14605 PyThreadState* __tstate = wxPyBeginAllowThreads();
14606 (arg1)->DrawRotatedText((wxString const &)*arg2,(wxPoint const &)*arg3,arg4);
14607
14608 wxPyEndAllowThreads(__tstate);
14609 if (PyErr_Occurred()) SWIG_fail;
14610 }
14611 Py_INCREF(Py_None); resultobj = Py_None;
14612 {
14613 if (temp2)
14614 delete arg2;
14615 }
14616 return resultobj;
14617 fail:
14618 {
14619 if (temp2)
14620 delete arg2;
14621 }
14622 return NULL;
14623 }
14624
14625
14626 static PyObject *_wrap_DC_Blit(PyObject *, PyObject *args, PyObject *kwargs) {
14627 PyObject *resultobj;
14628 wxDC *arg1 = (wxDC *) 0 ;
14629 int arg2 ;
14630 int arg3 ;
14631 int arg4 ;
14632 int arg5 ;
14633 wxDC *arg6 = (wxDC *) 0 ;
14634 int arg7 ;
14635 int arg8 ;
14636 int arg9 = (int) wxCOPY ;
14637 bool arg10 = (bool) false ;
14638 int arg11 = (int) -1 ;
14639 int arg12 = (int) -1 ;
14640 bool result;
14641 PyObject * obj0 = 0 ;
14642 PyObject * obj1 = 0 ;
14643 PyObject * obj2 = 0 ;
14644 PyObject * obj3 = 0 ;
14645 PyObject * obj4 = 0 ;
14646 PyObject * obj5 = 0 ;
14647 PyObject * obj6 = 0 ;
14648 PyObject * obj7 = 0 ;
14649 PyObject * obj8 = 0 ;
14650 PyObject * obj9 = 0 ;
14651 PyObject * obj10 = 0 ;
14652 PyObject * obj11 = 0 ;
14653 char *kwnames[] = {
14654 (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
14655 };
14656
14657 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;
14658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14659 if (SWIG_arg_fail(1)) SWIG_fail;
14660 {
14661 arg2 = (int)(SWIG_As_int(obj1));
14662 if (SWIG_arg_fail(2)) SWIG_fail;
14663 }
14664 {
14665 arg3 = (int)(SWIG_As_int(obj2));
14666 if (SWIG_arg_fail(3)) SWIG_fail;
14667 }
14668 {
14669 arg4 = (int)(SWIG_As_int(obj3));
14670 if (SWIG_arg_fail(4)) SWIG_fail;
14671 }
14672 {
14673 arg5 = (int)(SWIG_As_int(obj4));
14674 if (SWIG_arg_fail(5)) SWIG_fail;
14675 }
14676 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14677 if (SWIG_arg_fail(6)) SWIG_fail;
14678 {
14679 arg7 = (int)(SWIG_As_int(obj6));
14680 if (SWIG_arg_fail(7)) SWIG_fail;
14681 }
14682 {
14683 arg8 = (int)(SWIG_As_int(obj7));
14684 if (SWIG_arg_fail(8)) SWIG_fail;
14685 }
14686 if (obj8) {
14687 {
14688 arg9 = (int)(SWIG_As_int(obj8));
14689 if (SWIG_arg_fail(9)) SWIG_fail;
14690 }
14691 }
14692 if (obj9) {
14693 {
14694 arg10 = (bool)(SWIG_As_bool(obj9));
14695 if (SWIG_arg_fail(10)) SWIG_fail;
14696 }
14697 }
14698 if (obj10) {
14699 {
14700 arg11 = (int)(SWIG_As_int(obj10));
14701 if (SWIG_arg_fail(11)) SWIG_fail;
14702 }
14703 }
14704 if (obj11) {
14705 {
14706 arg12 = (int)(SWIG_As_int(obj11));
14707 if (SWIG_arg_fail(12)) SWIG_fail;
14708 }
14709 }
14710 {
14711 PyThreadState* __tstate = wxPyBeginAllowThreads();
14712 result = (bool)(arg1)->Blit(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
14713
14714 wxPyEndAllowThreads(__tstate);
14715 if (PyErr_Occurred()) SWIG_fail;
14716 }
14717 {
14718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14719 }
14720 return resultobj;
14721 fail:
14722 return NULL;
14723 }
14724
14725
14726 static PyObject *_wrap_DC_BlitPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14727 PyObject *resultobj;
14728 wxDC *arg1 = (wxDC *) 0 ;
14729 wxPoint *arg2 = 0 ;
14730 wxSize *arg3 = 0 ;
14731 wxDC *arg4 = (wxDC *) 0 ;
14732 wxPoint *arg5 = 0 ;
14733 int arg6 = (int) wxCOPY ;
14734 bool arg7 = (bool) false ;
14735 wxPoint const &arg8_defvalue = wxDefaultPosition ;
14736 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
14737 bool result;
14738 wxPoint temp2 ;
14739 wxSize temp3 ;
14740 wxPoint temp5 ;
14741 wxPoint temp8 ;
14742 PyObject * obj0 = 0 ;
14743 PyObject * obj1 = 0 ;
14744 PyObject * obj2 = 0 ;
14745 PyObject * obj3 = 0 ;
14746 PyObject * obj4 = 0 ;
14747 PyObject * obj5 = 0 ;
14748 PyObject * obj6 = 0 ;
14749 PyObject * obj7 = 0 ;
14750 char *kwnames[] = {
14751 (char *) "self",(char *) "destPt",(char *) "sz",(char *) "source",(char *) "srcPt",(char *) "rop",(char *) "useMask",(char *) "srcPtMask", NULL
14752 };
14753
14754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:DC_BlitPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
14755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14756 if (SWIG_arg_fail(1)) SWIG_fail;
14757 {
14758 arg2 = &temp2;
14759 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14760 }
14761 {
14762 arg3 = &temp3;
14763 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14764 }
14765 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14766 if (SWIG_arg_fail(4)) SWIG_fail;
14767 {
14768 arg5 = &temp5;
14769 if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
14770 }
14771 if (obj5) {
14772 {
14773 arg6 = (int)(SWIG_As_int(obj5));
14774 if (SWIG_arg_fail(6)) SWIG_fail;
14775 }
14776 }
14777 if (obj6) {
14778 {
14779 arg7 = (bool)(SWIG_As_bool(obj6));
14780 if (SWIG_arg_fail(7)) SWIG_fail;
14781 }
14782 }
14783 if (obj7) {
14784 {
14785 arg8 = &temp8;
14786 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
14787 }
14788 }
14789 {
14790 PyThreadState* __tstate = wxPyBeginAllowThreads();
14791 result = (bool)(arg1)->Blit((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,(wxPoint const &)*arg5,arg6,arg7,(wxPoint const &)*arg8);
14792
14793 wxPyEndAllowThreads(__tstate);
14794 if (PyErr_Occurred()) SWIG_fail;
14795 }
14796 {
14797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14798 }
14799 return resultobj;
14800 fail:
14801 return NULL;
14802 }
14803
14804
14805 static PyObject *_wrap_DC_SetClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14806 PyObject *resultobj;
14807 wxDC *arg1 = (wxDC *) 0 ;
14808 int arg2 ;
14809 int arg3 ;
14810 int arg4 ;
14811 int arg5 ;
14812 PyObject * obj0 = 0 ;
14813 PyObject * obj1 = 0 ;
14814 PyObject * obj2 = 0 ;
14815 PyObject * obj3 = 0 ;
14816 PyObject * obj4 = 0 ;
14817 char *kwnames[] = {
14818 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
14819 };
14820
14821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_SetClippingRegion",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14823 if (SWIG_arg_fail(1)) SWIG_fail;
14824 {
14825 arg2 = (int)(SWIG_As_int(obj1));
14826 if (SWIG_arg_fail(2)) SWIG_fail;
14827 }
14828 {
14829 arg3 = (int)(SWIG_As_int(obj2));
14830 if (SWIG_arg_fail(3)) SWIG_fail;
14831 }
14832 {
14833 arg4 = (int)(SWIG_As_int(obj3));
14834 if (SWIG_arg_fail(4)) SWIG_fail;
14835 }
14836 {
14837 arg5 = (int)(SWIG_As_int(obj4));
14838 if (SWIG_arg_fail(5)) SWIG_fail;
14839 }
14840 {
14841 PyThreadState* __tstate = wxPyBeginAllowThreads();
14842 (arg1)->SetClippingRegion(arg2,arg3,arg4,arg5);
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_SetClippingRegionPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14855 PyObject *resultobj;
14856 wxDC *arg1 = (wxDC *) 0 ;
14857 wxPoint *arg2 = 0 ;
14858 wxSize *arg3 = 0 ;
14859 wxPoint temp2 ;
14860 wxSize temp3 ;
14861 PyObject * obj0 = 0 ;
14862 PyObject * obj1 = 0 ;
14863 PyObject * obj2 = 0 ;
14864 char *kwnames[] = {
14865 (char *) "self",(char *) "pt",(char *) "sz", NULL
14866 };
14867
14868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetClippingRegionPointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14870 if (SWIG_arg_fail(1)) SWIG_fail;
14871 {
14872 arg2 = &temp2;
14873 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14874 }
14875 {
14876 arg3 = &temp3;
14877 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14878 }
14879 {
14880 PyThreadState* __tstate = wxPyBeginAllowThreads();
14881 (arg1)->SetClippingRegion((wxPoint const &)*arg2,(wxSize const &)*arg3);
14882
14883 wxPyEndAllowThreads(__tstate);
14884 if (PyErr_Occurred()) SWIG_fail;
14885 }
14886 Py_INCREF(Py_None); resultobj = Py_None;
14887 return resultobj;
14888 fail:
14889 return NULL;
14890 }
14891
14892
14893 static PyObject *_wrap_DC_SetClippingRegionAsRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14894 PyObject *resultobj;
14895 wxDC *arg1 = (wxDC *) 0 ;
14896 wxRegion *arg2 = 0 ;
14897 PyObject * obj0 = 0 ;
14898 PyObject * obj1 = 0 ;
14899 char *kwnames[] = {
14900 (char *) "self",(char *) "region", NULL
14901 };
14902
14903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRegionAsRegion",kwnames,&obj0,&obj1)) goto fail;
14904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14905 if (SWIG_arg_fail(1)) SWIG_fail;
14906 {
14907 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
14908 if (SWIG_arg_fail(2)) SWIG_fail;
14909 if (arg2 == NULL) {
14910 SWIG_null_ref("wxRegion");
14911 }
14912 if (SWIG_arg_fail(2)) SWIG_fail;
14913 }
14914 {
14915 PyThreadState* __tstate = wxPyBeginAllowThreads();
14916 (arg1)->SetClippingRegion((wxRegion const &)*arg2);
14917
14918 wxPyEndAllowThreads(__tstate);
14919 if (PyErr_Occurred()) SWIG_fail;
14920 }
14921 Py_INCREF(Py_None); resultobj = Py_None;
14922 return resultobj;
14923 fail:
14924 return NULL;
14925 }
14926
14927
14928 static PyObject *_wrap_DC_SetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
14929 PyObject *resultobj;
14930 wxDC *arg1 = (wxDC *) 0 ;
14931 wxRect *arg2 = 0 ;
14932 wxRect temp2 ;
14933 PyObject * obj0 = 0 ;
14934 PyObject * obj1 = 0 ;
14935 char *kwnames[] = {
14936 (char *) "self",(char *) "rect", NULL
14937 };
14938
14939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRect",kwnames,&obj0,&obj1)) goto fail;
14940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14941 if (SWIG_arg_fail(1)) SWIG_fail;
14942 {
14943 arg2 = &temp2;
14944 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14945 }
14946 {
14947 PyThreadState* __tstate = wxPyBeginAllowThreads();
14948 (arg1)->SetClippingRegion((wxRect const &)*arg2);
14949
14950 wxPyEndAllowThreads(__tstate);
14951 if (PyErr_Occurred()) SWIG_fail;
14952 }
14953 Py_INCREF(Py_None); resultobj = Py_None;
14954 return resultobj;
14955 fail:
14956 return NULL;
14957 }
14958
14959
14960 static PyObject *_wrap_DC_DrawLines(PyObject *, PyObject *args, PyObject *kwargs) {
14961 PyObject *resultobj;
14962 wxDC *arg1 = (wxDC *) 0 ;
14963 int arg2 ;
14964 wxPoint *arg3 = (wxPoint *) 0 ;
14965 int arg4 = (int) 0 ;
14966 int arg5 = (int) 0 ;
14967 PyObject * obj0 = 0 ;
14968 PyObject * obj1 = 0 ;
14969 PyObject * obj2 = 0 ;
14970 PyObject * obj3 = 0 ;
14971 char *kwnames[] = {
14972 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset", NULL
14973 };
14974
14975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DC_DrawLines",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14977 if (SWIG_arg_fail(1)) SWIG_fail;
14978 {
14979 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14980 if (arg3 == NULL) SWIG_fail;
14981 }
14982 if (obj2) {
14983 {
14984 arg4 = (int)(SWIG_As_int(obj2));
14985 if (SWIG_arg_fail(4)) SWIG_fail;
14986 }
14987 }
14988 if (obj3) {
14989 {
14990 arg5 = (int)(SWIG_As_int(obj3));
14991 if (SWIG_arg_fail(5)) SWIG_fail;
14992 }
14993 }
14994 {
14995 PyThreadState* __tstate = wxPyBeginAllowThreads();
14996 (arg1)->DrawLines(arg2,arg3,arg4,arg5);
14997
14998 wxPyEndAllowThreads(__tstate);
14999 if (PyErr_Occurred()) SWIG_fail;
15000 }
15001 Py_INCREF(Py_None); resultobj = Py_None;
15002 {
15003 if (arg3) delete [] arg3;
15004 }
15005 return resultobj;
15006 fail:
15007 {
15008 if (arg3) delete [] arg3;
15009 }
15010 return NULL;
15011 }
15012
15013
15014 static PyObject *_wrap_DC_DrawPolygon(PyObject *, PyObject *args, PyObject *kwargs) {
15015 PyObject *resultobj;
15016 wxDC *arg1 = (wxDC *) 0 ;
15017 int arg2 ;
15018 wxPoint *arg3 = (wxPoint *) 0 ;
15019 int arg4 = (int) 0 ;
15020 int arg5 = (int) 0 ;
15021 int arg6 = (int) wxODDEVEN_RULE ;
15022 PyObject * obj0 = 0 ;
15023 PyObject * obj1 = 0 ;
15024 PyObject * obj2 = 0 ;
15025 PyObject * obj3 = 0 ;
15026 PyObject * obj4 = 0 ;
15027 char *kwnames[] = {
15028 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset",(char *) "fillStyle", NULL
15029 };
15030
15031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DC_DrawPolygon",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
15032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15033 if (SWIG_arg_fail(1)) SWIG_fail;
15034 {
15035 arg3 = wxPoint_LIST_helper(obj1, &arg2);
15036 if (arg3 == NULL) SWIG_fail;
15037 }
15038 if (obj2) {
15039 {
15040 arg4 = (int)(SWIG_As_int(obj2));
15041 if (SWIG_arg_fail(4)) SWIG_fail;
15042 }
15043 }
15044 if (obj3) {
15045 {
15046 arg5 = (int)(SWIG_As_int(obj3));
15047 if (SWIG_arg_fail(5)) SWIG_fail;
15048 }
15049 }
15050 if (obj4) {
15051 {
15052 arg6 = (int)(SWIG_As_int(obj4));
15053 if (SWIG_arg_fail(6)) SWIG_fail;
15054 }
15055 }
15056 {
15057 PyThreadState* __tstate = wxPyBeginAllowThreads();
15058 (arg1)->DrawPolygon(arg2,arg3,arg4,arg5,arg6);
15059
15060 wxPyEndAllowThreads(__tstate);
15061 if (PyErr_Occurred()) SWIG_fail;
15062 }
15063 Py_INCREF(Py_None); resultobj = Py_None;
15064 {
15065 if (arg3) delete [] arg3;
15066 }
15067 return resultobj;
15068 fail:
15069 {
15070 if (arg3) delete [] arg3;
15071 }
15072 return NULL;
15073 }
15074
15075
15076 static PyObject *_wrap_DC_DrawLabel(PyObject *, PyObject *args, PyObject *kwargs) {
15077 PyObject *resultobj;
15078 wxDC *arg1 = (wxDC *) 0 ;
15079 wxString *arg2 = 0 ;
15080 wxRect *arg3 = 0 ;
15081 int arg4 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
15082 int arg5 = (int) -1 ;
15083 bool temp2 = false ;
15084 wxRect temp3 ;
15085 PyObject * obj0 = 0 ;
15086 PyObject * obj1 = 0 ;
15087 PyObject * obj2 = 0 ;
15088 PyObject * obj3 = 0 ;
15089 PyObject * obj4 = 0 ;
15090 char *kwnames[] = {
15091 (char *) "self",(char *) "text",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
15092 };
15093
15094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:DC_DrawLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
15095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15096 if (SWIG_arg_fail(1)) SWIG_fail;
15097 {
15098 arg2 = wxString_in_helper(obj1);
15099 if (arg2 == NULL) SWIG_fail;
15100 temp2 = true;
15101 }
15102 {
15103 arg3 = &temp3;
15104 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
15105 }
15106 if (obj3) {
15107 {
15108 arg4 = (int)(SWIG_As_int(obj3));
15109 if (SWIG_arg_fail(4)) SWIG_fail;
15110 }
15111 }
15112 if (obj4) {
15113 {
15114 arg5 = (int)(SWIG_As_int(obj4));
15115 if (SWIG_arg_fail(5)) SWIG_fail;
15116 }
15117 }
15118 {
15119 PyThreadState* __tstate = wxPyBeginAllowThreads();
15120 (arg1)->DrawLabel((wxString const &)*arg2,(wxRect const &)*arg3,arg4,arg5);
15121
15122 wxPyEndAllowThreads(__tstate);
15123 if (PyErr_Occurred()) SWIG_fail;
15124 }
15125 Py_INCREF(Py_None); resultobj = Py_None;
15126 {
15127 if (temp2)
15128 delete arg2;
15129 }
15130 return resultobj;
15131 fail:
15132 {
15133 if (temp2)
15134 delete arg2;
15135 }
15136 return NULL;
15137 }
15138
15139
15140 static PyObject *_wrap_DC_DrawImageLabel(PyObject *, PyObject *args, PyObject *kwargs) {
15141 PyObject *resultobj;
15142 wxDC *arg1 = (wxDC *) 0 ;
15143 wxString *arg2 = 0 ;
15144 wxBitmap *arg3 = 0 ;
15145 wxRect *arg4 = 0 ;
15146 int arg5 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
15147 int arg6 = (int) -1 ;
15148 wxRect result;
15149 bool temp2 = false ;
15150 wxRect temp4 ;
15151 PyObject * obj0 = 0 ;
15152 PyObject * obj1 = 0 ;
15153 PyObject * obj2 = 0 ;
15154 PyObject * obj3 = 0 ;
15155 PyObject * obj4 = 0 ;
15156 PyObject * obj5 = 0 ;
15157 char *kwnames[] = {
15158 (char *) "self",(char *) "text",(char *) "image",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
15159 };
15160
15161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:DC_DrawImageLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
15162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15163 if (SWIG_arg_fail(1)) SWIG_fail;
15164 {
15165 arg2 = wxString_in_helper(obj1);
15166 if (arg2 == NULL) SWIG_fail;
15167 temp2 = true;
15168 }
15169 {
15170 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
15171 if (SWIG_arg_fail(3)) SWIG_fail;
15172 if (arg3 == NULL) {
15173 SWIG_null_ref("wxBitmap");
15174 }
15175 if (SWIG_arg_fail(3)) SWIG_fail;
15176 }
15177 {
15178 arg4 = &temp4;
15179 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
15180 }
15181 if (obj4) {
15182 {
15183 arg5 = (int)(SWIG_As_int(obj4));
15184 if (SWIG_arg_fail(5)) SWIG_fail;
15185 }
15186 }
15187 if (obj5) {
15188 {
15189 arg6 = (int)(SWIG_As_int(obj5));
15190 if (SWIG_arg_fail(6)) SWIG_fail;
15191 }
15192 }
15193 {
15194 PyThreadState* __tstate = wxPyBeginAllowThreads();
15195 result = wxDC_DrawImageLabel(arg1,(wxString const &)*arg2,(wxBitmap const &)*arg3,(wxRect const &)*arg4,arg5,arg6);
15196
15197 wxPyEndAllowThreads(__tstate);
15198 if (PyErr_Occurred()) SWIG_fail;
15199 }
15200 {
15201 wxRect * resultptr;
15202 resultptr = new wxRect((wxRect &)(result));
15203 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
15204 }
15205 {
15206 if (temp2)
15207 delete arg2;
15208 }
15209 return resultobj;
15210 fail:
15211 {
15212 if (temp2)
15213 delete arg2;
15214 }
15215 return NULL;
15216 }
15217
15218
15219 static PyObject *_wrap_DC_DrawSpline(PyObject *, PyObject *args, PyObject *kwargs) {
15220 PyObject *resultobj;
15221 wxDC *arg1 = (wxDC *) 0 ;
15222 int arg2 ;
15223 wxPoint *arg3 = (wxPoint *) 0 ;
15224 PyObject * obj0 = 0 ;
15225 PyObject * obj1 = 0 ;
15226 char *kwnames[] = {
15227 (char *) "self",(char *) "points", NULL
15228 };
15229
15230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawSpline",kwnames,&obj0,&obj1)) goto fail;
15231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15232 if (SWIG_arg_fail(1)) SWIG_fail;
15233 {
15234 arg3 = wxPoint_LIST_helper(obj1, &arg2);
15235 if (arg3 == NULL) SWIG_fail;
15236 }
15237 {
15238 PyThreadState* __tstate = wxPyBeginAllowThreads();
15239 (arg1)->DrawSpline(arg2,arg3);
15240
15241 wxPyEndAllowThreads(__tstate);
15242 if (PyErr_Occurred()) SWIG_fail;
15243 }
15244 Py_INCREF(Py_None); resultobj = Py_None;
15245 {
15246 if (arg3) delete [] arg3;
15247 }
15248 return resultobj;
15249 fail:
15250 {
15251 if (arg3) delete [] arg3;
15252 }
15253 return NULL;
15254 }
15255
15256
15257 static PyObject *_wrap_DC_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
15258 PyObject *resultobj;
15259 wxDC *arg1 = (wxDC *) 0 ;
15260 PyObject * obj0 = 0 ;
15261 char *kwnames[] = {
15262 (char *) "self", NULL
15263 };
15264
15265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Clear",kwnames,&obj0)) goto fail;
15266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15267 if (SWIG_arg_fail(1)) SWIG_fail;
15268 {
15269 PyThreadState* __tstate = wxPyBeginAllowThreads();
15270 (arg1)->Clear();
15271
15272 wxPyEndAllowThreads(__tstate);
15273 if (PyErr_Occurred()) SWIG_fail;
15274 }
15275 Py_INCREF(Py_None); resultobj = Py_None;
15276 return resultobj;
15277 fail:
15278 return NULL;
15279 }
15280
15281
15282 static PyObject *_wrap_DC_StartDoc(PyObject *, PyObject *args, PyObject *kwargs) {
15283 PyObject *resultobj;
15284 wxDC *arg1 = (wxDC *) 0 ;
15285 wxString *arg2 = 0 ;
15286 bool result;
15287 bool temp2 = false ;
15288 PyObject * obj0 = 0 ;
15289 PyObject * obj1 = 0 ;
15290 char *kwnames[] = {
15291 (char *) "self",(char *) "message", NULL
15292 };
15293
15294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_StartDoc",kwnames,&obj0,&obj1)) goto fail;
15295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15296 if (SWIG_arg_fail(1)) SWIG_fail;
15297 {
15298 arg2 = wxString_in_helper(obj1);
15299 if (arg2 == NULL) SWIG_fail;
15300 temp2 = true;
15301 }
15302 {
15303 PyThreadState* __tstate = wxPyBeginAllowThreads();
15304 result = (bool)(arg1)->StartDoc((wxString const &)*arg2);
15305
15306 wxPyEndAllowThreads(__tstate);
15307 if (PyErr_Occurred()) SWIG_fail;
15308 }
15309 {
15310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15311 }
15312 {
15313 if (temp2)
15314 delete arg2;
15315 }
15316 return resultobj;
15317 fail:
15318 {
15319 if (temp2)
15320 delete arg2;
15321 }
15322 return NULL;
15323 }
15324
15325
15326 static PyObject *_wrap_DC_EndDoc(PyObject *, PyObject *args, PyObject *kwargs) {
15327 PyObject *resultobj;
15328 wxDC *arg1 = (wxDC *) 0 ;
15329 PyObject * obj0 = 0 ;
15330 char *kwnames[] = {
15331 (char *) "self", NULL
15332 };
15333
15334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDoc",kwnames,&obj0)) goto fail;
15335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15336 if (SWIG_arg_fail(1)) SWIG_fail;
15337 {
15338 PyThreadState* __tstate = wxPyBeginAllowThreads();
15339 (arg1)->EndDoc();
15340
15341 wxPyEndAllowThreads(__tstate);
15342 if (PyErr_Occurred()) SWIG_fail;
15343 }
15344 Py_INCREF(Py_None); resultobj = Py_None;
15345 return resultobj;
15346 fail:
15347 return NULL;
15348 }
15349
15350
15351 static PyObject *_wrap_DC_StartPage(PyObject *, PyObject *args, PyObject *kwargs) {
15352 PyObject *resultobj;
15353 wxDC *arg1 = (wxDC *) 0 ;
15354 PyObject * obj0 = 0 ;
15355 char *kwnames[] = {
15356 (char *) "self", NULL
15357 };
15358
15359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_StartPage",kwnames,&obj0)) goto fail;
15360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15361 if (SWIG_arg_fail(1)) SWIG_fail;
15362 {
15363 PyThreadState* __tstate = wxPyBeginAllowThreads();
15364 (arg1)->StartPage();
15365
15366 wxPyEndAllowThreads(__tstate);
15367 if (PyErr_Occurred()) SWIG_fail;
15368 }
15369 Py_INCREF(Py_None); resultobj = Py_None;
15370 return resultobj;
15371 fail:
15372 return NULL;
15373 }
15374
15375
15376 static PyObject *_wrap_DC_EndPage(PyObject *, PyObject *args, PyObject *kwargs) {
15377 PyObject *resultobj;
15378 wxDC *arg1 = (wxDC *) 0 ;
15379 PyObject * obj0 = 0 ;
15380 char *kwnames[] = {
15381 (char *) "self", NULL
15382 };
15383
15384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndPage",kwnames,&obj0)) goto fail;
15385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15386 if (SWIG_arg_fail(1)) SWIG_fail;
15387 {
15388 PyThreadState* __tstate = wxPyBeginAllowThreads();
15389 (arg1)->EndPage();
15390
15391 wxPyEndAllowThreads(__tstate);
15392 if (PyErr_Occurred()) SWIG_fail;
15393 }
15394 Py_INCREF(Py_None); resultobj = Py_None;
15395 return resultobj;
15396 fail:
15397 return NULL;
15398 }
15399
15400
15401 static PyObject *_wrap_DC_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
15402 PyObject *resultobj;
15403 wxDC *arg1 = (wxDC *) 0 ;
15404 wxFont *arg2 = 0 ;
15405 PyObject * obj0 = 0 ;
15406 PyObject * obj1 = 0 ;
15407 char *kwnames[] = {
15408 (char *) "self",(char *) "font", NULL
15409 };
15410
15411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetFont",kwnames,&obj0,&obj1)) goto fail;
15412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15413 if (SWIG_arg_fail(1)) SWIG_fail;
15414 {
15415 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15416 if (SWIG_arg_fail(2)) SWIG_fail;
15417 if (arg2 == NULL) {
15418 SWIG_null_ref("wxFont");
15419 }
15420 if (SWIG_arg_fail(2)) SWIG_fail;
15421 }
15422 {
15423 PyThreadState* __tstate = wxPyBeginAllowThreads();
15424 (arg1)->SetFont((wxFont const &)*arg2);
15425
15426 wxPyEndAllowThreads(__tstate);
15427 if (PyErr_Occurred()) SWIG_fail;
15428 }
15429 Py_INCREF(Py_None); resultobj = Py_None;
15430 return resultobj;
15431 fail:
15432 return NULL;
15433 }
15434
15435
15436 static PyObject *_wrap_DC_SetPen(PyObject *, PyObject *args, PyObject *kwargs) {
15437 PyObject *resultobj;
15438 wxDC *arg1 = (wxDC *) 0 ;
15439 wxPen *arg2 = 0 ;
15440 PyObject * obj0 = 0 ;
15441 PyObject * obj1 = 0 ;
15442 char *kwnames[] = {
15443 (char *) "self",(char *) "pen", NULL
15444 };
15445
15446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPen",kwnames,&obj0,&obj1)) goto fail;
15447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15448 if (SWIG_arg_fail(1)) SWIG_fail;
15449 {
15450 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
15451 if (SWIG_arg_fail(2)) SWIG_fail;
15452 if (arg2 == NULL) {
15453 SWIG_null_ref("wxPen");
15454 }
15455 if (SWIG_arg_fail(2)) SWIG_fail;
15456 }
15457 {
15458 PyThreadState* __tstate = wxPyBeginAllowThreads();
15459 (arg1)->SetPen((wxPen const &)*arg2);
15460
15461 wxPyEndAllowThreads(__tstate);
15462 if (PyErr_Occurred()) SWIG_fail;
15463 }
15464 Py_INCREF(Py_None); resultobj = Py_None;
15465 return resultobj;
15466 fail:
15467 return NULL;
15468 }
15469
15470
15471 static PyObject *_wrap_DC_SetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
15472 PyObject *resultobj;
15473 wxDC *arg1 = (wxDC *) 0 ;
15474 wxBrush *arg2 = 0 ;
15475 PyObject * obj0 = 0 ;
15476 PyObject * obj1 = 0 ;
15477 char *kwnames[] = {
15478 (char *) "self",(char *) "brush", NULL
15479 };
15480
15481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBrush",kwnames,&obj0,&obj1)) goto fail;
15482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15483 if (SWIG_arg_fail(1)) SWIG_fail;
15484 {
15485 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
15486 if (SWIG_arg_fail(2)) SWIG_fail;
15487 if (arg2 == NULL) {
15488 SWIG_null_ref("wxBrush");
15489 }
15490 if (SWIG_arg_fail(2)) SWIG_fail;
15491 }
15492 {
15493 PyThreadState* __tstate = wxPyBeginAllowThreads();
15494 (arg1)->SetBrush((wxBrush const &)*arg2);
15495
15496 wxPyEndAllowThreads(__tstate);
15497 if (PyErr_Occurred()) SWIG_fail;
15498 }
15499 Py_INCREF(Py_None); resultobj = Py_None;
15500 return resultobj;
15501 fail:
15502 return NULL;
15503 }
15504
15505
15506 static PyObject *_wrap_DC_SetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
15507 PyObject *resultobj;
15508 wxDC *arg1 = (wxDC *) 0 ;
15509 wxBrush *arg2 = 0 ;
15510 PyObject * obj0 = 0 ;
15511 PyObject * obj1 = 0 ;
15512 char *kwnames[] = {
15513 (char *) "self",(char *) "brush", NULL
15514 };
15515
15516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackground",kwnames,&obj0,&obj1)) goto fail;
15517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15518 if (SWIG_arg_fail(1)) SWIG_fail;
15519 {
15520 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
15521 if (SWIG_arg_fail(2)) SWIG_fail;
15522 if (arg2 == NULL) {
15523 SWIG_null_ref("wxBrush");
15524 }
15525 if (SWIG_arg_fail(2)) SWIG_fail;
15526 }
15527 {
15528 PyThreadState* __tstate = wxPyBeginAllowThreads();
15529 (arg1)->SetBackground((wxBrush const &)*arg2);
15530
15531 wxPyEndAllowThreads(__tstate);
15532 if (PyErr_Occurred()) SWIG_fail;
15533 }
15534 Py_INCREF(Py_None); resultobj = Py_None;
15535 return resultobj;
15536 fail:
15537 return NULL;
15538 }
15539
15540
15541 static PyObject *_wrap_DC_SetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
15542 PyObject *resultobj;
15543 wxDC *arg1 = (wxDC *) 0 ;
15544 int arg2 ;
15545 PyObject * obj0 = 0 ;
15546 PyObject * obj1 = 0 ;
15547 char *kwnames[] = {
15548 (char *) "self",(char *) "mode", NULL
15549 };
15550
15551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackgroundMode",kwnames,&obj0,&obj1)) goto fail;
15552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15553 if (SWIG_arg_fail(1)) SWIG_fail;
15554 {
15555 arg2 = (int)(SWIG_As_int(obj1));
15556 if (SWIG_arg_fail(2)) SWIG_fail;
15557 }
15558 {
15559 PyThreadState* __tstate = wxPyBeginAllowThreads();
15560 (arg1)->SetBackgroundMode(arg2);
15561
15562 wxPyEndAllowThreads(__tstate);
15563 if (PyErr_Occurred()) SWIG_fail;
15564 }
15565 Py_INCREF(Py_None); resultobj = Py_None;
15566 return resultobj;
15567 fail:
15568 return NULL;
15569 }
15570
15571
15572 static PyObject *_wrap_DC_SetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
15573 PyObject *resultobj;
15574 wxDC *arg1 = (wxDC *) 0 ;
15575 wxPalette *arg2 = 0 ;
15576 PyObject * obj0 = 0 ;
15577 PyObject * obj1 = 0 ;
15578 char *kwnames[] = {
15579 (char *) "self",(char *) "palette", NULL
15580 };
15581
15582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPalette",kwnames,&obj0,&obj1)) goto fail;
15583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15584 if (SWIG_arg_fail(1)) SWIG_fail;
15585 {
15586 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
15587 if (SWIG_arg_fail(2)) SWIG_fail;
15588 if (arg2 == NULL) {
15589 SWIG_null_ref("wxPalette");
15590 }
15591 if (SWIG_arg_fail(2)) SWIG_fail;
15592 }
15593 {
15594 PyThreadState* __tstate = wxPyBeginAllowThreads();
15595 (arg1)->SetPalette((wxPalette const &)*arg2);
15596
15597 wxPyEndAllowThreads(__tstate);
15598 if (PyErr_Occurred()) SWIG_fail;
15599 }
15600 Py_INCREF(Py_None); resultobj = Py_None;
15601 return resultobj;
15602 fail:
15603 return NULL;
15604 }
15605
15606
15607 static PyObject *_wrap_DC_DestroyClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
15608 PyObject *resultobj;
15609 wxDC *arg1 = (wxDC *) 0 ;
15610 PyObject * obj0 = 0 ;
15611 char *kwnames[] = {
15612 (char *) "self", NULL
15613 };
15614
15615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_DestroyClippingRegion",kwnames,&obj0)) goto fail;
15616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15617 if (SWIG_arg_fail(1)) SWIG_fail;
15618 {
15619 PyThreadState* __tstate = wxPyBeginAllowThreads();
15620 (arg1)->DestroyClippingRegion();
15621
15622 wxPyEndAllowThreads(__tstate);
15623 if (PyErr_Occurred()) SWIG_fail;
15624 }
15625 Py_INCREF(Py_None); resultobj = Py_None;
15626 return resultobj;
15627 fail:
15628 return NULL;
15629 }
15630
15631
15632 static PyObject *_wrap_DC_GetClippingBox(PyObject *, PyObject *args, PyObject *kwargs) {
15633 PyObject *resultobj;
15634 wxDC *arg1 = (wxDC *) 0 ;
15635 int *arg2 = (int *) 0 ;
15636 int *arg3 = (int *) 0 ;
15637 int *arg4 = (int *) 0 ;
15638 int *arg5 = (int *) 0 ;
15639 int temp2 ;
15640 int res2 = 0 ;
15641 int temp3 ;
15642 int res3 = 0 ;
15643 int temp4 ;
15644 int res4 = 0 ;
15645 int temp5 ;
15646 int res5 = 0 ;
15647 PyObject * obj0 = 0 ;
15648 char *kwnames[] = {
15649 (char *) "self", NULL
15650 };
15651
15652 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15653 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15654 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15655 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingBox",kwnames,&obj0)) goto fail;
15657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15658 if (SWIG_arg_fail(1)) SWIG_fail;
15659 {
15660 PyThreadState* __tstate = wxPyBeginAllowThreads();
15661 ((wxDC const *)arg1)->GetClippingBox(arg2,arg3,arg4,arg5);
15662
15663 wxPyEndAllowThreads(__tstate);
15664 if (PyErr_Occurred()) SWIG_fail;
15665 }
15666 Py_INCREF(Py_None); resultobj = Py_None;
15667 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15668 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15669 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15670 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15671 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15672 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15673 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15674 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15675 return resultobj;
15676 fail:
15677 return NULL;
15678 }
15679
15680
15681 static PyObject *_wrap_DC_GetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
15682 PyObject *resultobj;
15683 wxDC *arg1 = (wxDC *) 0 ;
15684 wxRect result;
15685 PyObject * obj0 = 0 ;
15686 char *kwnames[] = {
15687 (char *) "self", NULL
15688 };
15689
15690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingRect",kwnames,&obj0)) goto fail;
15691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15692 if (SWIG_arg_fail(1)) SWIG_fail;
15693 {
15694 PyThreadState* __tstate = wxPyBeginAllowThreads();
15695 result = wxDC_GetClippingRect(arg1);
15696
15697 wxPyEndAllowThreads(__tstate);
15698 if (PyErr_Occurred()) SWIG_fail;
15699 }
15700 {
15701 wxRect * resultptr;
15702 resultptr = new wxRect((wxRect &)(result));
15703 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
15704 }
15705 return resultobj;
15706 fail:
15707 return NULL;
15708 }
15709
15710
15711 static PyObject *_wrap_DC_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
15712 PyObject *resultobj;
15713 wxDC *arg1 = (wxDC *) 0 ;
15714 int result;
15715 PyObject * obj0 = 0 ;
15716 char *kwnames[] = {
15717 (char *) "self", NULL
15718 };
15719
15720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharHeight",kwnames,&obj0)) goto fail;
15721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15722 if (SWIG_arg_fail(1)) SWIG_fail;
15723 {
15724 PyThreadState* __tstate = wxPyBeginAllowThreads();
15725 result = (int)((wxDC const *)arg1)->GetCharHeight();
15726
15727 wxPyEndAllowThreads(__tstate);
15728 if (PyErr_Occurred()) SWIG_fail;
15729 }
15730 {
15731 resultobj = SWIG_From_int((int)(result));
15732 }
15733 return resultobj;
15734 fail:
15735 return NULL;
15736 }
15737
15738
15739 static PyObject *_wrap_DC_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
15740 PyObject *resultobj;
15741 wxDC *arg1 = (wxDC *) 0 ;
15742 int result;
15743 PyObject * obj0 = 0 ;
15744 char *kwnames[] = {
15745 (char *) "self", NULL
15746 };
15747
15748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharWidth",kwnames,&obj0)) goto fail;
15749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15750 if (SWIG_arg_fail(1)) SWIG_fail;
15751 {
15752 PyThreadState* __tstate = wxPyBeginAllowThreads();
15753 result = (int)((wxDC const *)arg1)->GetCharWidth();
15754
15755 wxPyEndAllowThreads(__tstate);
15756 if (PyErr_Occurred()) SWIG_fail;
15757 }
15758 {
15759 resultobj = SWIG_From_int((int)(result));
15760 }
15761 return resultobj;
15762 fail:
15763 return NULL;
15764 }
15765
15766
15767 static PyObject *_wrap_DC_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15768 PyObject *resultobj;
15769 wxDC *arg1 = (wxDC *) 0 ;
15770 wxString *arg2 = 0 ;
15771 int *arg3 = (int *) 0 ;
15772 int *arg4 = (int *) 0 ;
15773 bool temp2 = false ;
15774 int temp3 ;
15775 int res3 = 0 ;
15776 int temp4 ;
15777 int res4 = 0 ;
15778 PyObject * obj0 = 0 ;
15779 PyObject * obj1 = 0 ;
15780 char *kwnames[] = {
15781 (char *) "self",(char *) "string", NULL
15782 };
15783
15784 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15785 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
15787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15788 if (SWIG_arg_fail(1)) SWIG_fail;
15789 {
15790 arg2 = wxString_in_helper(obj1);
15791 if (arg2 == NULL) SWIG_fail;
15792 temp2 = true;
15793 }
15794 {
15795 PyThreadState* __tstate = wxPyBeginAllowThreads();
15796 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
15797
15798 wxPyEndAllowThreads(__tstate);
15799 if (PyErr_Occurred()) SWIG_fail;
15800 }
15801 Py_INCREF(Py_None); resultobj = Py_None;
15802 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15803 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15804 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15805 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15806 {
15807 if (temp2)
15808 delete arg2;
15809 }
15810 return resultobj;
15811 fail:
15812 {
15813 if (temp2)
15814 delete arg2;
15815 }
15816 return NULL;
15817 }
15818
15819
15820 static PyObject *_wrap_DC_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15821 PyObject *resultobj;
15822 wxDC *arg1 = (wxDC *) 0 ;
15823 wxString *arg2 = 0 ;
15824 int *arg3 = (int *) 0 ;
15825 int *arg4 = (int *) 0 ;
15826 int *arg5 = (int *) 0 ;
15827 int *arg6 = (int *) 0 ;
15828 wxFont *arg7 = (wxFont *) NULL ;
15829 bool temp2 = false ;
15830 int temp3 ;
15831 int res3 = 0 ;
15832 int temp4 ;
15833 int res4 = 0 ;
15834 int temp5 ;
15835 int res5 = 0 ;
15836 int temp6 ;
15837 int res6 = 0 ;
15838 PyObject * obj0 = 0 ;
15839 PyObject * obj1 = 0 ;
15840 PyObject * obj2 = 0 ;
15841 char *kwnames[] = {
15842 (char *) "self",(char *) "string",(char *) "font", NULL
15843 };
15844
15845 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15846 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15847 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15848 arg6 = &temp6; res6 = SWIG_NEWOBJ;
15849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15851 if (SWIG_arg_fail(1)) SWIG_fail;
15852 {
15853 arg2 = wxString_in_helper(obj1);
15854 if (arg2 == NULL) SWIG_fail;
15855 temp2 = true;
15856 }
15857 if (obj2) {
15858 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15859 if (SWIG_arg_fail(7)) SWIG_fail;
15860 }
15861 {
15862 PyThreadState* __tstate = wxPyBeginAllowThreads();
15863 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7);
15864
15865 wxPyEndAllowThreads(__tstate);
15866 if (PyErr_Occurred()) SWIG_fail;
15867 }
15868 Py_INCREF(Py_None); resultobj = Py_None;
15869 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15870 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15871 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15872 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15873 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15874 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15875 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
15876 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
15877 {
15878 if (temp2)
15879 delete arg2;
15880 }
15881 return resultobj;
15882 fail:
15883 {
15884 if (temp2)
15885 delete arg2;
15886 }
15887 return NULL;
15888 }
15889
15890
15891 static PyObject *_wrap_DC_GetMultiLineTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15892 PyObject *resultobj;
15893 wxDC *arg1 = (wxDC *) 0 ;
15894 wxString *arg2 = 0 ;
15895 int *arg3 = (int *) 0 ;
15896 int *arg4 = (int *) 0 ;
15897 int *arg5 = (int *) 0 ;
15898 wxFont *arg6 = (wxFont *) NULL ;
15899 bool temp2 = false ;
15900 int temp3 ;
15901 int res3 = 0 ;
15902 int temp4 ;
15903 int res4 = 0 ;
15904 int temp5 ;
15905 int res5 = 0 ;
15906 PyObject * obj0 = 0 ;
15907 PyObject * obj1 = 0 ;
15908 PyObject * obj2 = 0 ;
15909 char *kwnames[] = {
15910 (char *) "self",(char *) "text",(char *) "font", NULL
15911 };
15912
15913 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15914 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15915 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetMultiLineTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15918 if (SWIG_arg_fail(1)) SWIG_fail;
15919 {
15920 arg2 = wxString_in_helper(obj1);
15921 if (arg2 == NULL) SWIG_fail;
15922 temp2 = true;
15923 }
15924 if (obj2) {
15925 SWIG_Python_ConvertPtr(obj2, (void **)&arg6, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15926 if (SWIG_arg_fail(6)) SWIG_fail;
15927 }
15928 {
15929 PyThreadState* __tstate = wxPyBeginAllowThreads();
15930 (arg1)->GetMultiLineTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6);
15931
15932 wxPyEndAllowThreads(__tstate);
15933 if (PyErr_Occurred()) SWIG_fail;
15934 }
15935 Py_INCREF(Py_None); resultobj = Py_None;
15936 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15937 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15938 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15939 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15940 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15941 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15942 {
15943 if (temp2)
15944 delete arg2;
15945 }
15946 return resultobj;
15947 fail:
15948 {
15949 if (temp2)
15950 delete arg2;
15951 }
15952 return NULL;
15953 }
15954
15955
15956 static PyObject *_wrap_DC_GetPartialTextExtents(PyObject *, PyObject *args, PyObject *kwargs) {
15957 PyObject *resultobj;
15958 wxDC *arg1 = (wxDC *) 0 ;
15959 wxString *arg2 = 0 ;
15960 wxArrayInt result;
15961 bool temp2 = false ;
15962 PyObject * obj0 = 0 ;
15963 PyObject * obj1 = 0 ;
15964 char *kwnames[] = {
15965 (char *) "self",(char *) "text", NULL
15966 };
15967
15968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPartialTextExtents",kwnames,&obj0,&obj1)) goto fail;
15969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15970 if (SWIG_arg_fail(1)) SWIG_fail;
15971 {
15972 arg2 = wxString_in_helper(obj1);
15973 if (arg2 == NULL) SWIG_fail;
15974 temp2 = true;
15975 }
15976 {
15977 PyThreadState* __tstate = wxPyBeginAllowThreads();
15978 result = wxDC_GetPartialTextExtents(arg1,(wxString const &)*arg2);
15979
15980 wxPyEndAllowThreads(__tstate);
15981 if (PyErr_Occurred()) SWIG_fail;
15982 }
15983 {
15984 resultobj = PyList_New(0);
15985 size_t idx;
15986 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
15987 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
15988 PyList_Append(resultobj, val);
15989 Py_DECREF(val);
15990 }
15991 }
15992 {
15993 if (temp2)
15994 delete arg2;
15995 }
15996 return resultobj;
15997 fail:
15998 {
15999 if (temp2)
16000 delete arg2;
16001 }
16002 return NULL;
16003 }
16004
16005
16006 static PyObject *_wrap_DC_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
16007 PyObject *resultobj;
16008 wxDC *arg1 = (wxDC *) 0 ;
16009 wxSize result;
16010 PyObject * obj0 = 0 ;
16011 char *kwnames[] = {
16012 (char *) "self", NULL
16013 };
16014
16015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSize",kwnames,&obj0)) goto fail;
16016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16017 if (SWIG_arg_fail(1)) SWIG_fail;
16018 {
16019 PyThreadState* __tstate = wxPyBeginAllowThreads();
16020 result = (arg1)->GetSize();
16021
16022 wxPyEndAllowThreads(__tstate);
16023 if (PyErr_Occurred()) SWIG_fail;
16024 }
16025 {
16026 wxSize * resultptr;
16027 resultptr = new wxSize((wxSize &)(result));
16028 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
16029 }
16030 return resultobj;
16031 fail:
16032 return NULL;
16033 }
16034
16035
16036 static PyObject *_wrap_DC_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16037 PyObject *resultobj;
16038 wxDC *arg1 = (wxDC *) 0 ;
16039 int *arg2 = (int *) 0 ;
16040 int *arg3 = (int *) 0 ;
16041 int temp2 ;
16042 int res2 = 0 ;
16043 int temp3 ;
16044 int res3 = 0 ;
16045 PyObject * obj0 = 0 ;
16046 char *kwnames[] = {
16047 (char *) "self", NULL
16048 };
16049
16050 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16051 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeTuple",kwnames,&obj0)) goto fail;
16053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16054 if (SWIG_arg_fail(1)) SWIG_fail;
16055 {
16056 PyThreadState* __tstate = wxPyBeginAllowThreads();
16057 (arg1)->GetSize(arg2,arg3);
16058
16059 wxPyEndAllowThreads(__tstate);
16060 if (PyErr_Occurred()) SWIG_fail;
16061 }
16062 Py_INCREF(Py_None); resultobj = Py_None;
16063 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16064 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16065 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16066 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16067 return resultobj;
16068 fail:
16069 return NULL;
16070 }
16071
16072
16073 static PyObject *_wrap_DC_GetSizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
16074 PyObject *resultobj;
16075 wxDC *arg1 = (wxDC *) 0 ;
16076 wxSize result;
16077 PyObject * obj0 = 0 ;
16078 char *kwnames[] = {
16079 (char *) "self", NULL
16080 };
16081
16082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMM",kwnames,&obj0)) goto fail;
16083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16084 if (SWIG_arg_fail(1)) SWIG_fail;
16085 {
16086 PyThreadState* __tstate = wxPyBeginAllowThreads();
16087 result = ((wxDC const *)arg1)->GetSizeMM();
16088
16089 wxPyEndAllowThreads(__tstate);
16090 if (PyErr_Occurred()) SWIG_fail;
16091 }
16092 {
16093 wxSize * resultptr;
16094 resultptr = new wxSize((wxSize &)(result));
16095 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
16096 }
16097 return resultobj;
16098 fail:
16099 return NULL;
16100 }
16101
16102
16103 static PyObject *_wrap_DC_GetSizeMMTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16104 PyObject *resultobj;
16105 wxDC *arg1 = (wxDC *) 0 ;
16106 int *arg2 = (int *) 0 ;
16107 int *arg3 = (int *) 0 ;
16108 int temp2 ;
16109 int res2 = 0 ;
16110 int temp3 ;
16111 int res3 = 0 ;
16112 PyObject * obj0 = 0 ;
16113 char *kwnames[] = {
16114 (char *) "self", NULL
16115 };
16116
16117 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16118 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMMTuple",kwnames,&obj0)) goto fail;
16120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16121 if (SWIG_arg_fail(1)) SWIG_fail;
16122 {
16123 PyThreadState* __tstate = wxPyBeginAllowThreads();
16124 ((wxDC const *)arg1)->GetSizeMM(arg2,arg3);
16125
16126 wxPyEndAllowThreads(__tstate);
16127 if (PyErr_Occurred()) SWIG_fail;
16128 }
16129 Py_INCREF(Py_None); resultobj = Py_None;
16130 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16131 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16132 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16133 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16134 return resultobj;
16135 fail:
16136 return NULL;
16137 }
16138
16139
16140 static PyObject *_wrap_DC_DeviceToLogicalX(PyObject *, PyObject *args, PyObject *kwargs) {
16141 PyObject *resultobj;
16142 wxDC *arg1 = (wxDC *) 0 ;
16143 int arg2 ;
16144 int result;
16145 PyObject * obj0 = 0 ;
16146 PyObject * obj1 = 0 ;
16147 char *kwnames[] = {
16148 (char *) "self",(char *) "x", NULL
16149 };
16150
16151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalX",kwnames,&obj0,&obj1)) goto fail;
16152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16153 if (SWIG_arg_fail(1)) SWIG_fail;
16154 {
16155 arg2 = (int)(SWIG_As_int(obj1));
16156 if (SWIG_arg_fail(2)) SWIG_fail;
16157 }
16158 {
16159 PyThreadState* __tstate = wxPyBeginAllowThreads();
16160 result = (int)((wxDC const *)arg1)->DeviceToLogicalX(arg2);
16161
16162 wxPyEndAllowThreads(__tstate);
16163 if (PyErr_Occurred()) SWIG_fail;
16164 }
16165 {
16166 resultobj = SWIG_From_int((int)(result));
16167 }
16168 return resultobj;
16169 fail:
16170 return NULL;
16171 }
16172
16173
16174 static PyObject *_wrap_DC_DeviceToLogicalY(PyObject *, PyObject *args, PyObject *kwargs) {
16175 PyObject *resultobj;
16176 wxDC *arg1 = (wxDC *) 0 ;
16177 int arg2 ;
16178 int result;
16179 PyObject * obj0 = 0 ;
16180 PyObject * obj1 = 0 ;
16181 char *kwnames[] = {
16182 (char *) "self",(char *) "y", NULL
16183 };
16184
16185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalY",kwnames,&obj0,&obj1)) goto fail;
16186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16187 if (SWIG_arg_fail(1)) SWIG_fail;
16188 {
16189 arg2 = (int)(SWIG_As_int(obj1));
16190 if (SWIG_arg_fail(2)) SWIG_fail;
16191 }
16192 {
16193 PyThreadState* __tstate = wxPyBeginAllowThreads();
16194 result = (int)((wxDC const *)arg1)->DeviceToLogicalY(arg2);
16195
16196 wxPyEndAllowThreads(__tstate);
16197 if (PyErr_Occurred()) SWIG_fail;
16198 }
16199 {
16200 resultobj = SWIG_From_int((int)(result));
16201 }
16202 return resultobj;
16203 fail:
16204 return NULL;
16205 }
16206
16207
16208 static PyObject *_wrap_DC_DeviceToLogicalXRel(PyObject *, PyObject *args, PyObject *kwargs) {
16209 PyObject *resultobj;
16210 wxDC *arg1 = (wxDC *) 0 ;
16211 int arg2 ;
16212 int result;
16213 PyObject * obj0 = 0 ;
16214 PyObject * obj1 = 0 ;
16215 char *kwnames[] = {
16216 (char *) "self",(char *) "x", NULL
16217 };
16218
16219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalXRel",kwnames,&obj0,&obj1)) goto fail;
16220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16221 if (SWIG_arg_fail(1)) SWIG_fail;
16222 {
16223 arg2 = (int)(SWIG_As_int(obj1));
16224 if (SWIG_arg_fail(2)) SWIG_fail;
16225 }
16226 {
16227 PyThreadState* __tstate = wxPyBeginAllowThreads();
16228 result = (int)((wxDC const *)arg1)->DeviceToLogicalXRel(arg2);
16229
16230 wxPyEndAllowThreads(__tstate);
16231 if (PyErr_Occurred()) SWIG_fail;
16232 }
16233 {
16234 resultobj = SWIG_From_int((int)(result));
16235 }
16236 return resultobj;
16237 fail:
16238 return NULL;
16239 }
16240
16241
16242 static PyObject *_wrap_DC_DeviceToLogicalYRel(PyObject *, PyObject *args, PyObject *kwargs) {
16243 PyObject *resultobj;
16244 wxDC *arg1 = (wxDC *) 0 ;
16245 int arg2 ;
16246 int result;
16247 PyObject * obj0 = 0 ;
16248 PyObject * obj1 = 0 ;
16249 char *kwnames[] = {
16250 (char *) "self",(char *) "y", NULL
16251 };
16252
16253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalYRel",kwnames,&obj0,&obj1)) goto fail;
16254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16255 if (SWIG_arg_fail(1)) SWIG_fail;
16256 {
16257 arg2 = (int)(SWIG_As_int(obj1));
16258 if (SWIG_arg_fail(2)) SWIG_fail;
16259 }
16260 {
16261 PyThreadState* __tstate = wxPyBeginAllowThreads();
16262 result = (int)((wxDC const *)arg1)->DeviceToLogicalYRel(arg2);
16263
16264 wxPyEndAllowThreads(__tstate);
16265 if (PyErr_Occurred()) SWIG_fail;
16266 }
16267 {
16268 resultobj = SWIG_From_int((int)(result));
16269 }
16270 return resultobj;
16271 fail:
16272 return NULL;
16273 }
16274
16275
16276 static PyObject *_wrap_DC_LogicalToDeviceX(PyObject *, PyObject *args, PyObject *kwargs) {
16277 PyObject *resultobj;
16278 wxDC *arg1 = (wxDC *) 0 ;
16279 int arg2 ;
16280 int result;
16281 PyObject * obj0 = 0 ;
16282 PyObject * obj1 = 0 ;
16283 char *kwnames[] = {
16284 (char *) "self",(char *) "x", NULL
16285 };
16286
16287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceX",kwnames,&obj0,&obj1)) goto fail;
16288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16289 if (SWIG_arg_fail(1)) SWIG_fail;
16290 {
16291 arg2 = (int)(SWIG_As_int(obj1));
16292 if (SWIG_arg_fail(2)) SWIG_fail;
16293 }
16294 {
16295 PyThreadState* __tstate = wxPyBeginAllowThreads();
16296 result = (int)((wxDC const *)arg1)->LogicalToDeviceX(arg2);
16297
16298 wxPyEndAllowThreads(__tstate);
16299 if (PyErr_Occurred()) SWIG_fail;
16300 }
16301 {
16302 resultobj = SWIG_From_int((int)(result));
16303 }
16304 return resultobj;
16305 fail:
16306 return NULL;
16307 }
16308
16309
16310 static PyObject *_wrap_DC_LogicalToDeviceY(PyObject *, PyObject *args, PyObject *kwargs) {
16311 PyObject *resultobj;
16312 wxDC *arg1 = (wxDC *) 0 ;
16313 int arg2 ;
16314 int result;
16315 PyObject * obj0 = 0 ;
16316 PyObject * obj1 = 0 ;
16317 char *kwnames[] = {
16318 (char *) "self",(char *) "y", NULL
16319 };
16320
16321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceY",kwnames,&obj0,&obj1)) goto fail;
16322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16323 if (SWIG_arg_fail(1)) SWIG_fail;
16324 {
16325 arg2 = (int)(SWIG_As_int(obj1));
16326 if (SWIG_arg_fail(2)) SWIG_fail;
16327 }
16328 {
16329 PyThreadState* __tstate = wxPyBeginAllowThreads();
16330 result = (int)((wxDC const *)arg1)->LogicalToDeviceY(arg2);
16331
16332 wxPyEndAllowThreads(__tstate);
16333 if (PyErr_Occurred()) SWIG_fail;
16334 }
16335 {
16336 resultobj = SWIG_From_int((int)(result));
16337 }
16338 return resultobj;
16339 fail:
16340 return NULL;
16341 }
16342
16343
16344 static PyObject *_wrap_DC_LogicalToDeviceXRel(PyObject *, PyObject *args, PyObject *kwargs) {
16345 PyObject *resultobj;
16346 wxDC *arg1 = (wxDC *) 0 ;
16347 int arg2 ;
16348 int result;
16349 PyObject * obj0 = 0 ;
16350 PyObject * obj1 = 0 ;
16351 char *kwnames[] = {
16352 (char *) "self",(char *) "x", NULL
16353 };
16354
16355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceXRel",kwnames,&obj0,&obj1)) goto fail;
16356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16357 if (SWIG_arg_fail(1)) SWIG_fail;
16358 {
16359 arg2 = (int)(SWIG_As_int(obj1));
16360 if (SWIG_arg_fail(2)) SWIG_fail;
16361 }
16362 {
16363 PyThreadState* __tstate = wxPyBeginAllowThreads();
16364 result = (int)((wxDC const *)arg1)->LogicalToDeviceXRel(arg2);
16365
16366 wxPyEndAllowThreads(__tstate);
16367 if (PyErr_Occurred()) SWIG_fail;
16368 }
16369 {
16370 resultobj = SWIG_From_int((int)(result));
16371 }
16372 return resultobj;
16373 fail:
16374 return NULL;
16375 }
16376
16377
16378 static PyObject *_wrap_DC_LogicalToDeviceYRel(PyObject *, PyObject *args, PyObject *kwargs) {
16379 PyObject *resultobj;
16380 wxDC *arg1 = (wxDC *) 0 ;
16381 int arg2 ;
16382 int result;
16383 PyObject * obj0 = 0 ;
16384 PyObject * obj1 = 0 ;
16385 char *kwnames[] = {
16386 (char *) "self",(char *) "y", NULL
16387 };
16388
16389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceYRel",kwnames,&obj0,&obj1)) goto fail;
16390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16391 if (SWIG_arg_fail(1)) SWIG_fail;
16392 {
16393 arg2 = (int)(SWIG_As_int(obj1));
16394 if (SWIG_arg_fail(2)) SWIG_fail;
16395 }
16396 {
16397 PyThreadState* __tstate = wxPyBeginAllowThreads();
16398 result = (int)((wxDC const *)arg1)->LogicalToDeviceYRel(arg2);
16399
16400 wxPyEndAllowThreads(__tstate);
16401 if (PyErr_Occurred()) SWIG_fail;
16402 }
16403 {
16404 resultobj = SWIG_From_int((int)(result));
16405 }
16406 return resultobj;
16407 fail:
16408 return NULL;
16409 }
16410
16411
16412 static PyObject *_wrap_DC_CanDrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16413 PyObject *resultobj;
16414 wxDC *arg1 = (wxDC *) 0 ;
16415 bool result;
16416 PyObject * obj0 = 0 ;
16417 char *kwnames[] = {
16418 (char *) "self", NULL
16419 };
16420
16421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanDrawBitmap",kwnames,&obj0)) goto fail;
16422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16423 if (SWIG_arg_fail(1)) SWIG_fail;
16424 {
16425 PyThreadState* __tstate = wxPyBeginAllowThreads();
16426 result = (bool)((wxDC const *)arg1)->CanDrawBitmap();
16427
16428 wxPyEndAllowThreads(__tstate);
16429 if (PyErr_Occurred()) SWIG_fail;
16430 }
16431 {
16432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16433 }
16434 return resultobj;
16435 fail:
16436 return NULL;
16437 }
16438
16439
16440 static PyObject *_wrap_DC_CanGetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
16441 PyObject *resultobj;
16442 wxDC *arg1 = (wxDC *) 0 ;
16443 bool result;
16444 PyObject * obj0 = 0 ;
16445 char *kwnames[] = {
16446 (char *) "self", NULL
16447 };
16448
16449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanGetTextExtent",kwnames,&obj0)) goto fail;
16450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16451 if (SWIG_arg_fail(1)) SWIG_fail;
16452 {
16453 PyThreadState* __tstate = wxPyBeginAllowThreads();
16454 result = (bool)((wxDC const *)arg1)->CanGetTextExtent();
16455
16456 wxPyEndAllowThreads(__tstate);
16457 if (PyErr_Occurred()) SWIG_fail;
16458 }
16459 {
16460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16461 }
16462 return resultobj;
16463 fail:
16464 return NULL;
16465 }
16466
16467
16468 static PyObject *_wrap_DC_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
16469 PyObject *resultobj;
16470 wxDC *arg1 = (wxDC *) 0 ;
16471 int result;
16472 PyObject * obj0 = 0 ;
16473 char *kwnames[] = {
16474 (char *) "self", NULL
16475 };
16476
16477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDepth",kwnames,&obj0)) goto fail;
16478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16479 if (SWIG_arg_fail(1)) SWIG_fail;
16480 {
16481 PyThreadState* __tstate = wxPyBeginAllowThreads();
16482 result = (int)((wxDC const *)arg1)->GetDepth();
16483
16484 wxPyEndAllowThreads(__tstate);
16485 if (PyErr_Occurred()) SWIG_fail;
16486 }
16487 {
16488 resultobj = SWIG_From_int((int)(result));
16489 }
16490 return resultobj;
16491 fail:
16492 return NULL;
16493 }
16494
16495
16496 static PyObject *_wrap_DC_GetPPI(PyObject *, PyObject *args, PyObject *kwargs) {
16497 PyObject *resultobj;
16498 wxDC *arg1 = (wxDC *) 0 ;
16499 wxSize result;
16500 PyObject * obj0 = 0 ;
16501 char *kwnames[] = {
16502 (char *) "self", NULL
16503 };
16504
16505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPPI",kwnames,&obj0)) goto fail;
16506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16507 if (SWIG_arg_fail(1)) SWIG_fail;
16508 {
16509 PyThreadState* __tstate = wxPyBeginAllowThreads();
16510 result = ((wxDC const *)arg1)->GetPPI();
16511
16512 wxPyEndAllowThreads(__tstate);
16513 if (PyErr_Occurred()) SWIG_fail;
16514 }
16515 {
16516 wxSize * resultptr;
16517 resultptr = new wxSize((wxSize &)(result));
16518 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
16519 }
16520 return resultobj;
16521 fail:
16522 return NULL;
16523 }
16524
16525
16526 static PyObject *_wrap_DC_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
16527 PyObject *resultobj;
16528 wxDC *arg1 = (wxDC *) 0 ;
16529 bool result;
16530 PyObject * obj0 = 0 ;
16531 char *kwnames[] = {
16532 (char *) "self", NULL
16533 };
16534
16535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Ok",kwnames,&obj0)) goto fail;
16536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16537 if (SWIG_arg_fail(1)) SWIG_fail;
16538 {
16539 PyThreadState* __tstate = wxPyBeginAllowThreads();
16540 result = (bool)((wxDC const *)arg1)->Ok();
16541
16542 wxPyEndAllowThreads(__tstate);
16543 if (PyErr_Occurred()) SWIG_fail;
16544 }
16545 {
16546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16547 }
16548 return resultobj;
16549 fail:
16550 return NULL;
16551 }
16552
16553
16554 static PyObject *_wrap_DC_GetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
16555 PyObject *resultobj;
16556 wxDC *arg1 = (wxDC *) 0 ;
16557 int result;
16558 PyObject * obj0 = 0 ;
16559 char *kwnames[] = {
16560 (char *) "self", NULL
16561 };
16562
16563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackgroundMode",kwnames,&obj0)) goto fail;
16564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16565 if (SWIG_arg_fail(1)) SWIG_fail;
16566 {
16567 PyThreadState* __tstate = wxPyBeginAllowThreads();
16568 result = (int)((wxDC const *)arg1)->GetBackgroundMode();
16569
16570 wxPyEndAllowThreads(__tstate);
16571 if (PyErr_Occurred()) SWIG_fail;
16572 }
16573 {
16574 resultobj = SWIG_From_int((int)(result));
16575 }
16576 return resultobj;
16577 fail:
16578 return NULL;
16579 }
16580
16581
16582 static PyObject *_wrap_DC_GetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16583 PyObject *resultobj;
16584 wxDC *arg1 = (wxDC *) 0 ;
16585 wxBrush *result;
16586 PyObject * obj0 = 0 ;
16587 char *kwnames[] = {
16588 (char *) "self", NULL
16589 };
16590
16591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackground",kwnames,&obj0)) goto fail;
16592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16593 if (SWIG_arg_fail(1)) SWIG_fail;
16594 {
16595 PyThreadState* __tstate = wxPyBeginAllowThreads();
16596 {
16597 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBackground();
16598 result = (wxBrush *) &_result_ref;
16599 }
16600
16601 wxPyEndAllowThreads(__tstate);
16602 if (PyErr_Occurred()) SWIG_fail;
16603 }
16604 {
16605 wxBrush* resultptr = new wxBrush(*result);
16606 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
16607 }
16608 return resultobj;
16609 fail:
16610 return NULL;
16611 }
16612
16613
16614 static PyObject *_wrap_DC_GetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
16615 PyObject *resultobj;
16616 wxDC *arg1 = (wxDC *) 0 ;
16617 wxBrush *result;
16618 PyObject * obj0 = 0 ;
16619 char *kwnames[] = {
16620 (char *) "self", NULL
16621 };
16622
16623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBrush",kwnames,&obj0)) goto fail;
16624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16625 if (SWIG_arg_fail(1)) SWIG_fail;
16626 {
16627 PyThreadState* __tstate = wxPyBeginAllowThreads();
16628 {
16629 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBrush();
16630 result = (wxBrush *) &_result_ref;
16631 }
16632
16633 wxPyEndAllowThreads(__tstate);
16634 if (PyErr_Occurred()) SWIG_fail;
16635 }
16636 {
16637 wxBrush* resultptr = new wxBrush(*result);
16638 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
16639 }
16640 return resultobj;
16641 fail:
16642 return NULL;
16643 }
16644
16645
16646 static PyObject *_wrap_DC_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
16647 PyObject *resultobj;
16648 wxDC *arg1 = (wxDC *) 0 ;
16649 wxFont *result;
16650 PyObject * obj0 = 0 ;
16651 char *kwnames[] = {
16652 (char *) "self", NULL
16653 };
16654
16655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetFont",kwnames,&obj0)) goto fail;
16656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16657 if (SWIG_arg_fail(1)) SWIG_fail;
16658 {
16659 PyThreadState* __tstate = wxPyBeginAllowThreads();
16660 {
16661 wxFont const &_result_ref = ((wxDC const *)arg1)->GetFont();
16662 result = (wxFont *) &_result_ref;
16663 }
16664
16665 wxPyEndAllowThreads(__tstate);
16666 if (PyErr_Occurred()) SWIG_fail;
16667 }
16668 {
16669 wxFont* resultptr = new wxFont(*result);
16670 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxFont, 1);
16671 }
16672 return resultobj;
16673 fail:
16674 return NULL;
16675 }
16676
16677
16678 static PyObject *_wrap_DC_GetPen(PyObject *, PyObject *args, PyObject *kwargs) {
16679 PyObject *resultobj;
16680 wxDC *arg1 = (wxDC *) 0 ;
16681 wxPen *result;
16682 PyObject * obj0 = 0 ;
16683 char *kwnames[] = {
16684 (char *) "self", NULL
16685 };
16686
16687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPen",kwnames,&obj0)) goto fail;
16688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16689 if (SWIG_arg_fail(1)) SWIG_fail;
16690 {
16691 PyThreadState* __tstate = wxPyBeginAllowThreads();
16692 {
16693 wxPen const &_result_ref = ((wxDC const *)arg1)->GetPen();
16694 result = (wxPen *) &_result_ref;
16695 }
16696
16697 wxPyEndAllowThreads(__tstate);
16698 if (PyErr_Occurred()) SWIG_fail;
16699 }
16700 {
16701 wxPen* resultptr = new wxPen(*result);
16702 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxPen, 1);
16703 }
16704 return resultobj;
16705 fail:
16706 return NULL;
16707 }
16708
16709
16710 static PyObject *_wrap_DC_GetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16711 PyObject *resultobj;
16712 wxDC *arg1 = (wxDC *) 0 ;
16713 wxColour *result;
16714 PyObject * obj0 = 0 ;
16715 char *kwnames[] = {
16716 (char *) "self", NULL
16717 };
16718
16719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextBackground",kwnames,&obj0)) goto fail;
16720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16721 if (SWIG_arg_fail(1)) SWIG_fail;
16722 {
16723 PyThreadState* __tstate = wxPyBeginAllowThreads();
16724 {
16725 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextBackground();
16726 result = (wxColour *) &_result_ref;
16727 }
16728
16729 wxPyEndAllowThreads(__tstate);
16730 if (PyErr_Occurred()) SWIG_fail;
16731 }
16732 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
16733 return resultobj;
16734 fail:
16735 return NULL;
16736 }
16737
16738
16739 static PyObject *_wrap_DC_GetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
16740 PyObject *resultobj;
16741 wxDC *arg1 = (wxDC *) 0 ;
16742 wxColour *result;
16743 PyObject * obj0 = 0 ;
16744 char *kwnames[] = {
16745 (char *) "self", NULL
16746 };
16747
16748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextForeground",kwnames,&obj0)) goto fail;
16749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16750 if (SWIG_arg_fail(1)) SWIG_fail;
16751 {
16752 PyThreadState* __tstate = wxPyBeginAllowThreads();
16753 {
16754 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextForeground();
16755 result = (wxColour *) &_result_ref;
16756 }
16757
16758 wxPyEndAllowThreads(__tstate);
16759 if (PyErr_Occurred()) SWIG_fail;
16760 }
16761 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
16762 return resultobj;
16763 fail:
16764 return NULL;
16765 }
16766
16767
16768 static PyObject *_wrap_DC_SetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
16769 PyObject *resultobj;
16770 wxDC *arg1 = (wxDC *) 0 ;
16771 wxColour *arg2 = 0 ;
16772 wxColour temp2 ;
16773 PyObject * obj0 = 0 ;
16774 PyObject * obj1 = 0 ;
16775 char *kwnames[] = {
16776 (char *) "self",(char *) "colour", NULL
16777 };
16778
16779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextForeground",kwnames,&obj0,&obj1)) goto fail;
16780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16781 if (SWIG_arg_fail(1)) SWIG_fail;
16782 {
16783 arg2 = &temp2;
16784 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16785 }
16786 {
16787 PyThreadState* __tstate = wxPyBeginAllowThreads();
16788 (arg1)->SetTextForeground((wxColour const &)*arg2);
16789
16790 wxPyEndAllowThreads(__tstate);
16791 if (PyErr_Occurred()) SWIG_fail;
16792 }
16793 Py_INCREF(Py_None); resultobj = Py_None;
16794 return resultobj;
16795 fail:
16796 return NULL;
16797 }
16798
16799
16800 static PyObject *_wrap_DC_SetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16801 PyObject *resultobj;
16802 wxDC *arg1 = (wxDC *) 0 ;
16803 wxColour *arg2 = 0 ;
16804 wxColour temp2 ;
16805 PyObject * obj0 = 0 ;
16806 PyObject * obj1 = 0 ;
16807 char *kwnames[] = {
16808 (char *) "self",(char *) "colour", NULL
16809 };
16810
16811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextBackground",kwnames,&obj0,&obj1)) goto fail;
16812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16813 if (SWIG_arg_fail(1)) SWIG_fail;
16814 {
16815 arg2 = &temp2;
16816 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16817 }
16818 {
16819 PyThreadState* __tstate = wxPyBeginAllowThreads();
16820 (arg1)->SetTextBackground((wxColour const &)*arg2);
16821
16822 wxPyEndAllowThreads(__tstate);
16823 if (PyErr_Occurred()) SWIG_fail;
16824 }
16825 Py_INCREF(Py_None); resultobj = Py_None;
16826 return resultobj;
16827 fail:
16828 return NULL;
16829 }
16830
16831
16832 static PyObject *_wrap_DC_GetMapMode(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_GetMapMode",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)->GetMapMode();
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_SetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16861 PyObject *resultobj;
16862 wxDC *arg1 = (wxDC *) 0 ;
16863 int arg2 ;
16864 PyObject * obj0 = 0 ;
16865 PyObject * obj1 = 0 ;
16866 char *kwnames[] = {
16867 (char *) "self",(char *) "mode", NULL
16868 };
16869
16870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetMapMode",kwnames,&obj0,&obj1)) goto fail;
16871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16872 if (SWIG_arg_fail(1)) SWIG_fail;
16873 {
16874 arg2 = (int)(SWIG_As_int(obj1));
16875 if (SWIG_arg_fail(2)) SWIG_fail;
16876 }
16877 {
16878 PyThreadState* __tstate = wxPyBeginAllowThreads();
16879 (arg1)->SetMapMode(arg2);
16880
16881 wxPyEndAllowThreads(__tstate);
16882 if (PyErr_Occurred()) SWIG_fail;
16883 }
16884 Py_INCREF(Py_None); resultobj = Py_None;
16885 return resultobj;
16886 fail:
16887 return NULL;
16888 }
16889
16890
16891 static PyObject *_wrap_DC_GetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16892 PyObject *resultobj;
16893 wxDC *arg1 = (wxDC *) 0 ;
16894 double *arg2 = (double *) 0 ;
16895 double *arg3 = (double *) 0 ;
16896 double temp2 ;
16897 int res2 = 0 ;
16898 double temp3 ;
16899 int res3 = 0 ;
16900 PyObject * obj0 = 0 ;
16901 char *kwnames[] = {
16902 (char *) "self", NULL
16903 };
16904
16905 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16906 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetUserScale",kwnames,&obj0)) goto fail;
16908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16909 if (SWIG_arg_fail(1)) SWIG_fail;
16910 {
16911 PyThreadState* __tstate = wxPyBeginAllowThreads();
16912 ((wxDC const *)arg1)->GetUserScale(arg2,arg3);
16913
16914 wxPyEndAllowThreads(__tstate);
16915 if (PyErr_Occurred()) SWIG_fail;
16916 }
16917 Py_INCREF(Py_None); resultobj = Py_None;
16918 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16919 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16920 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16921 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16922 return resultobj;
16923 fail:
16924 return NULL;
16925 }
16926
16927
16928 static PyObject *_wrap_DC_SetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16929 PyObject *resultobj;
16930 wxDC *arg1 = (wxDC *) 0 ;
16931 double arg2 ;
16932 double arg3 ;
16933 PyObject * obj0 = 0 ;
16934 PyObject * obj1 = 0 ;
16935 PyObject * obj2 = 0 ;
16936 char *kwnames[] = {
16937 (char *) "self",(char *) "x",(char *) "y", NULL
16938 };
16939
16940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetUserScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16942 if (SWIG_arg_fail(1)) SWIG_fail;
16943 {
16944 arg2 = (double)(SWIG_As_double(obj1));
16945 if (SWIG_arg_fail(2)) SWIG_fail;
16946 }
16947 {
16948 arg3 = (double)(SWIG_As_double(obj2));
16949 if (SWIG_arg_fail(3)) SWIG_fail;
16950 }
16951 {
16952 PyThreadState* __tstate = wxPyBeginAllowThreads();
16953 (arg1)->SetUserScale(arg2,arg3);
16954
16955 wxPyEndAllowThreads(__tstate);
16956 if (PyErr_Occurred()) SWIG_fail;
16957 }
16958 Py_INCREF(Py_None); resultobj = Py_None;
16959 return resultobj;
16960 fail:
16961 return NULL;
16962 }
16963
16964
16965 static PyObject *_wrap_DC_GetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16966 PyObject *resultobj;
16967 wxDC *arg1 = (wxDC *) 0 ;
16968 double *arg2 = (double *) 0 ;
16969 double *arg3 = (double *) 0 ;
16970 double temp2 ;
16971 int res2 = 0 ;
16972 double temp3 ;
16973 int res3 = 0 ;
16974 PyObject * obj0 = 0 ;
16975 char *kwnames[] = {
16976 (char *) "self", NULL
16977 };
16978
16979 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16980 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalScale",kwnames,&obj0)) goto fail;
16982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16983 if (SWIG_arg_fail(1)) SWIG_fail;
16984 {
16985 PyThreadState* __tstate = wxPyBeginAllowThreads();
16986 (arg1)->GetLogicalScale(arg2,arg3);
16987
16988 wxPyEndAllowThreads(__tstate);
16989 if (PyErr_Occurred()) SWIG_fail;
16990 }
16991 Py_INCREF(Py_None); resultobj = Py_None;
16992 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16993 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16994 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16995 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16996 return resultobj;
16997 fail:
16998 return NULL;
16999 }
17000
17001
17002 static PyObject *_wrap_DC_SetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
17003 PyObject *resultobj;
17004 wxDC *arg1 = (wxDC *) 0 ;
17005 double arg2 ;
17006 double arg3 ;
17007 PyObject * obj0 = 0 ;
17008 PyObject * obj1 = 0 ;
17009 PyObject * obj2 = 0 ;
17010 char *kwnames[] = {
17011 (char *) "self",(char *) "x",(char *) "y", NULL
17012 };
17013
17014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
17015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17016 if (SWIG_arg_fail(1)) SWIG_fail;
17017 {
17018 arg2 = (double)(SWIG_As_double(obj1));
17019 if (SWIG_arg_fail(2)) SWIG_fail;
17020 }
17021 {
17022 arg3 = (double)(SWIG_As_double(obj2));
17023 if (SWIG_arg_fail(3)) SWIG_fail;
17024 }
17025 {
17026 PyThreadState* __tstate = wxPyBeginAllowThreads();
17027 (arg1)->SetLogicalScale(arg2,arg3);
17028
17029 wxPyEndAllowThreads(__tstate);
17030 if (PyErr_Occurred()) SWIG_fail;
17031 }
17032 Py_INCREF(Py_None); resultobj = Py_None;
17033 return resultobj;
17034 fail:
17035 return NULL;
17036 }
17037
17038
17039 static PyObject *_wrap_DC_GetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
17040 PyObject *resultobj;
17041 wxDC *arg1 = (wxDC *) 0 ;
17042 wxPoint result;
17043 PyObject * obj0 = 0 ;
17044 char *kwnames[] = {
17045 (char *) "self", NULL
17046 };
17047
17048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOrigin",kwnames,&obj0)) goto fail;
17049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17050 if (SWIG_arg_fail(1)) SWIG_fail;
17051 {
17052 PyThreadState* __tstate = wxPyBeginAllowThreads();
17053 result = ((wxDC const *)arg1)->GetLogicalOrigin();
17054
17055 wxPyEndAllowThreads(__tstate);
17056 if (PyErr_Occurred()) SWIG_fail;
17057 }
17058 {
17059 wxPoint * resultptr;
17060 resultptr = new wxPoint((wxPoint &)(result));
17061 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17062 }
17063 return resultobj;
17064 fail:
17065 return NULL;
17066 }
17067
17068
17069 static PyObject *_wrap_DC_GetLogicalOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17070 PyObject *resultobj;
17071 wxDC *arg1 = (wxDC *) 0 ;
17072 int *arg2 = (int *) 0 ;
17073 int *arg3 = (int *) 0 ;
17074 int temp2 ;
17075 int res2 = 0 ;
17076 int temp3 ;
17077 int res3 = 0 ;
17078 PyObject * obj0 = 0 ;
17079 char *kwnames[] = {
17080 (char *) "self", NULL
17081 };
17082
17083 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17084 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOriginTuple",kwnames,&obj0)) goto fail;
17086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17087 if (SWIG_arg_fail(1)) SWIG_fail;
17088 {
17089 PyThreadState* __tstate = wxPyBeginAllowThreads();
17090 ((wxDC const *)arg1)->GetLogicalOrigin(arg2,arg3);
17091
17092 wxPyEndAllowThreads(__tstate);
17093 if (PyErr_Occurred()) SWIG_fail;
17094 }
17095 Py_INCREF(Py_None); resultobj = Py_None;
17096 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17097 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
17098 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17099 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
17100 return resultobj;
17101 fail:
17102 return NULL;
17103 }
17104
17105
17106 static PyObject *_wrap_DC_SetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
17107 PyObject *resultobj;
17108 wxDC *arg1 = (wxDC *) 0 ;
17109 int arg2 ;
17110 int arg3 ;
17111 PyObject * obj0 = 0 ;
17112 PyObject * obj1 = 0 ;
17113 PyObject * obj2 = 0 ;
17114 char *kwnames[] = {
17115 (char *) "self",(char *) "x",(char *) "y", NULL
17116 };
17117
17118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
17119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17120 if (SWIG_arg_fail(1)) SWIG_fail;
17121 {
17122 arg2 = (int)(SWIG_As_int(obj1));
17123 if (SWIG_arg_fail(2)) SWIG_fail;
17124 }
17125 {
17126 arg3 = (int)(SWIG_As_int(obj2));
17127 if (SWIG_arg_fail(3)) SWIG_fail;
17128 }
17129 {
17130 PyThreadState* __tstate = wxPyBeginAllowThreads();
17131 (arg1)->SetLogicalOrigin(arg2,arg3);
17132
17133 wxPyEndAllowThreads(__tstate);
17134 if (PyErr_Occurred()) SWIG_fail;
17135 }
17136 Py_INCREF(Py_None); resultobj = Py_None;
17137 return resultobj;
17138 fail:
17139 return NULL;
17140 }
17141
17142
17143 static PyObject *_wrap_DC_SetLogicalOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
17144 PyObject *resultobj;
17145 wxDC *arg1 = (wxDC *) 0 ;
17146 wxPoint *arg2 = 0 ;
17147 wxPoint temp2 ;
17148 PyObject * obj0 = 0 ;
17149 PyObject * obj1 = 0 ;
17150 char *kwnames[] = {
17151 (char *) "self",(char *) "point", NULL
17152 };
17153
17154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalOriginPoint",kwnames,&obj0,&obj1)) goto fail;
17155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17156 if (SWIG_arg_fail(1)) SWIG_fail;
17157 {
17158 arg2 = &temp2;
17159 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
17160 }
17161 {
17162 PyThreadState* __tstate = wxPyBeginAllowThreads();
17163 wxDC_SetLogicalOriginPoint(arg1,(wxPoint const &)*arg2);
17164
17165 wxPyEndAllowThreads(__tstate);
17166 if (PyErr_Occurred()) SWIG_fail;
17167 }
17168 Py_INCREF(Py_None); resultobj = Py_None;
17169 return resultobj;
17170 fail:
17171 return NULL;
17172 }
17173
17174
17175 static PyObject *_wrap_DC_GetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
17176 PyObject *resultobj;
17177 wxDC *arg1 = (wxDC *) 0 ;
17178 wxPoint result;
17179 PyObject * obj0 = 0 ;
17180 char *kwnames[] = {
17181 (char *) "self", NULL
17182 };
17183
17184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOrigin",kwnames,&obj0)) goto fail;
17185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17186 if (SWIG_arg_fail(1)) SWIG_fail;
17187 {
17188 PyThreadState* __tstate = wxPyBeginAllowThreads();
17189 result = ((wxDC const *)arg1)->GetDeviceOrigin();
17190
17191 wxPyEndAllowThreads(__tstate);
17192 if (PyErr_Occurred()) SWIG_fail;
17193 }
17194 {
17195 wxPoint * resultptr;
17196 resultptr = new wxPoint((wxPoint &)(result));
17197 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17198 }
17199 return resultobj;
17200 fail:
17201 return NULL;
17202 }
17203
17204
17205 static PyObject *_wrap_DC_GetDeviceOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17206 PyObject *resultobj;
17207 wxDC *arg1 = (wxDC *) 0 ;
17208 int *arg2 = (int *) 0 ;
17209 int *arg3 = (int *) 0 ;
17210 int temp2 ;
17211 int res2 = 0 ;
17212 int temp3 ;
17213 int res3 = 0 ;
17214 PyObject * obj0 = 0 ;
17215 char *kwnames[] = {
17216 (char *) "self", NULL
17217 };
17218
17219 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17220 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOriginTuple",kwnames,&obj0)) goto fail;
17222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17223 if (SWIG_arg_fail(1)) SWIG_fail;
17224 {
17225 PyThreadState* __tstate = wxPyBeginAllowThreads();
17226 ((wxDC const *)arg1)->GetDeviceOrigin(arg2,arg3);
17227
17228 wxPyEndAllowThreads(__tstate);
17229 if (PyErr_Occurred()) SWIG_fail;
17230 }
17231 Py_INCREF(Py_None); resultobj = Py_None;
17232 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17233 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
17234 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17235 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
17236 return resultobj;
17237 fail:
17238 return NULL;
17239 }
17240
17241
17242 static PyObject *_wrap_DC_SetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
17243 PyObject *resultobj;
17244 wxDC *arg1 = (wxDC *) 0 ;
17245 int arg2 ;
17246 int arg3 ;
17247 PyObject * obj0 = 0 ;
17248 PyObject * obj1 = 0 ;
17249 PyObject * obj2 = 0 ;
17250 char *kwnames[] = {
17251 (char *) "self",(char *) "x",(char *) "y", NULL
17252 };
17253
17254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetDeviceOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
17255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17256 if (SWIG_arg_fail(1)) SWIG_fail;
17257 {
17258 arg2 = (int)(SWIG_As_int(obj1));
17259 if (SWIG_arg_fail(2)) SWIG_fail;
17260 }
17261 {
17262 arg3 = (int)(SWIG_As_int(obj2));
17263 if (SWIG_arg_fail(3)) SWIG_fail;
17264 }
17265 {
17266 PyThreadState* __tstate = wxPyBeginAllowThreads();
17267 (arg1)->SetDeviceOrigin(arg2,arg3);
17268
17269 wxPyEndAllowThreads(__tstate);
17270 if (PyErr_Occurred()) SWIG_fail;
17271 }
17272 Py_INCREF(Py_None); resultobj = Py_None;
17273 return resultobj;
17274 fail:
17275 return NULL;
17276 }
17277
17278
17279 static PyObject *_wrap_DC_SetDeviceOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
17280 PyObject *resultobj;
17281 wxDC *arg1 = (wxDC *) 0 ;
17282 wxPoint *arg2 = 0 ;
17283 wxPoint temp2 ;
17284 PyObject * obj0 = 0 ;
17285 PyObject * obj1 = 0 ;
17286 char *kwnames[] = {
17287 (char *) "self",(char *) "point", NULL
17288 };
17289
17290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetDeviceOriginPoint",kwnames,&obj0,&obj1)) goto fail;
17291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17292 if (SWIG_arg_fail(1)) SWIG_fail;
17293 {
17294 arg2 = &temp2;
17295 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
17296 }
17297 {
17298 PyThreadState* __tstate = wxPyBeginAllowThreads();
17299 wxDC_SetDeviceOriginPoint(arg1,(wxPoint const &)*arg2);
17300
17301 wxPyEndAllowThreads(__tstate);
17302 if (PyErr_Occurred()) SWIG_fail;
17303 }
17304 Py_INCREF(Py_None); resultobj = Py_None;
17305 return resultobj;
17306 fail:
17307 return NULL;
17308 }
17309
17310
17311 static PyObject *_wrap_DC_SetAxisOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
17312 PyObject *resultobj;
17313 wxDC *arg1 = (wxDC *) 0 ;
17314 bool arg2 ;
17315 bool arg3 ;
17316 PyObject * obj0 = 0 ;
17317 PyObject * obj1 = 0 ;
17318 PyObject * obj2 = 0 ;
17319 char *kwnames[] = {
17320 (char *) "self",(char *) "xLeftRight",(char *) "yBottomUp", NULL
17321 };
17322
17323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetAxisOrientation",kwnames,&obj0,&obj1,&obj2)) goto fail;
17324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17325 if (SWIG_arg_fail(1)) SWIG_fail;
17326 {
17327 arg2 = (bool)(SWIG_As_bool(obj1));
17328 if (SWIG_arg_fail(2)) SWIG_fail;
17329 }
17330 {
17331 arg3 = (bool)(SWIG_As_bool(obj2));
17332 if (SWIG_arg_fail(3)) SWIG_fail;
17333 }
17334 {
17335 PyThreadState* __tstate = wxPyBeginAllowThreads();
17336 (arg1)->SetAxisOrientation(arg2,arg3);
17337
17338 wxPyEndAllowThreads(__tstate);
17339 if (PyErr_Occurred()) SWIG_fail;
17340 }
17341 Py_INCREF(Py_None); resultobj = Py_None;
17342 return resultobj;
17343 fail:
17344 return NULL;
17345 }
17346
17347
17348 static PyObject *_wrap_DC_GetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
17349 PyObject *resultobj;
17350 wxDC *arg1 = (wxDC *) 0 ;
17351 int result;
17352 PyObject * obj0 = 0 ;
17353 char *kwnames[] = {
17354 (char *) "self", NULL
17355 };
17356
17357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalFunction",kwnames,&obj0)) goto fail;
17358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17359 if (SWIG_arg_fail(1)) SWIG_fail;
17360 {
17361 PyThreadState* __tstate = wxPyBeginAllowThreads();
17362 result = (int)((wxDC const *)arg1)->GetLogicalFunction();
17363
17364 wxPyEndAllowThreads(__tstate);
17365 if (PyErr_Occurred()) SWIG_fail;
17366 }
17367 {
17368 resultobj = SWIG_From_int((int)(result));
17369 }
17370 return resultobj;
17371 fail:
17372 return NULL;
17373 }
17374
17375
17376 static PyObject *_wrap_DC_SetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
17377 PyObject *resultobj;
17378 wxDC *arg1 = (wxDC *) 0 ;
17379 int arg2 ;
17380 PyObject * obj0 = 0 ;
17381 PyObject * obj1 = 0 ;
17382 char *kwnames[] = {
17383 (char *) "self",(char *) "function", NULL
17384 };
17385
17386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalFunction",kwnames,&obj0,&obj1)) goto fail;
17387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17388 if (SWIG_arg_fail(1)) SWIG_fail;
17389 {
17390 arg2 = (int)(SWIG_As_int(obj1));
17391 if (SWIG_arg_fail(2)) SWIG_fail;
17392 }
17393 {
17394 PyThreadState* __tstate = wxPyBeginAllowThreads();
17395 (arg1)->SetLogicalFunction(arg2);
17396
17397 wxPyEndAllowThreads(__tstate);
17398 if (PyErr_Occurred()) SWIG_fail;
17399 }
17400 Py_INCREF(Py_None); resultobj = Py_None;
17401 return resultobj;
17402 fail:
17403 return NULL;
17404 }
17405
17406
17407 static PyObject *_wrap_DC_ComputeScaleAndOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
17408 PyObject *resultobj;
17409 wxDC *arg1 = (wxDC *) 0 ;
17410 PyObject * obj0 = 0 ;
17411 char *kwnames[] = {
17412 (char *) "self", NULL
17413 };
17414
17415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ComputeScaleAndOrigin",kwnames,&obj0)) goto fail;
17416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17417 if (SWIG_arg_fail(1)) SWIG_fail;
17418 {
17419 PyThreadState* __tstate = wxPyBeginAllowThreads();
17420 (arg1)->ComputeScaleAndOrigin();
17421
17422 wxPyEndAllowThreads(__tstate);
17423 if (PyErr_Occurred()) SWIG_fail;
17424 }
17425 Py_INCREF(Py_None); resultobj = Py_None;
17426 return resultobj;
17427 fail:
17428 return NULL;
17429 }
17430
17431
17432 static PyObject *_wrap_DC_CalcBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
17433 PyObject *resultobj;
17434 wxDC *arg1 = (wxDC *) 0 ;
17435 int arg2 ;
17436 int arg3 ;
17437 PyObject * obj0 = 0 ;
17438 PyObject * obj1 = 0 ;
17439 PyObject * obj2 = 0 ;
17440 char *kwnames[] = {
17441 (char *) "self",(char *) "x",(char *) "y", NULL
17442 };
17443
17444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CalcBoundingBox",kwnames,&obj0,&obj1,&obj2)) goto fail;
17445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17446 if (SWIG_arg_fail(1)) SWIG_fail;
17447 {
17448 arg2 = (int)(SWIG_As_int(obj1));
17449 if (SWIG_arg_fail(2)) SWIG_fail;
17450 }
17451 {
17452 arg3 = (int)(SWIG_As_int(obj2));
17453 if (SWIG_arg_fail(3)) SWIG_fail;
17454 }
17455 {
17456 PyThreadState* __tstate = wxPyBeginAllowThreads();
17457 (arg1)->CalcBoundingBox(arg2,arg3);
17458
17459 wxPyEndAllowThreads(__tstate);
17460 if (PyErr_Occurred()) SWIG_fail;
17461 }
17462 Py_INCREF(Py_None); resultobj = Py_None;
17463 return resultobj;
17464 fail:
17465 return NULL;
17466 }
17467
17468
17469 static PyObject *_wrap_DC_CalcBoundingBoxPoint(PyObject *, PyObject *args, PyObject *kwargs) {
17470 PyObject *resultobj;
17471 wxDC *arg1 = (wxDC *) 0 ;
17472 wxPoint *arg2 = 0 ;
17473 wxPoint temp2 ;
17474 PyObject * obj0 = 0 ;
17475 PyObject * obj1 = 0 ;
17476 char *kwnames[] = {
17477 (char *) "self",(char *) "point", NULL
17478 };
17479
17480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CalcBoundingBoxPoint",kwnames,&obj0,&obj1)) goto fail;
17481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17482 if (SWIG_arg_fail(1)) SWIG_fail;
17483 {
17484 arg2 = &temp2;
17485 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
17486 }
17487 {
17488 PyThreadState* __tstate = wxPyBeginAllowThreads();
17489 wxDC_CalcBoundingBoxPoint(arg1,(wxPoint const &)*arg2);
17490
17491 wxPyEndAllowThreads(__tstate);
17492 if (PyErr_Occurred()) SWIG_fail;
17493 }
17494 Py_INCREF(Py_None); resultobj = Py_None;
17495 return resultobj;
17496 fail:
17497 return NULL;
17498 }
17499
17500
17501 static PyObject *_wrap_DC_ResetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
17502 PyObject *resultobj;
17503 wxDC *arg1 = (wxDC *) 0 ;
17504 PyObject * obj0 = 0 ;
17505 char *kwnames[] = {
17506 (char *) "self", NULL
17507 };
17508
17509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ResetBoundingBox",kwnames,&obj0)) goto fail;
17510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17511 if (SWIG_arg_fail(1)) SWIG_fail;
17512 {
17513 PyThreadState* __tstate = wxPyBeginAllowThreads();
17514 (arg1)->ResetBoundingBox();
17515
17516 wxPyEndAllowThreads(__tstate);
17517 if (PyErr_Occurred()) SWIG_fail;
17518 }
17519 Py_INCREF(Py_None); resultobj = Py_None;
17520 return resultobj;
17521 fail:
17522 return NULL;
17523 }
17524
17525
17526 static PyObject *_wrap_DC_MinX(PyObject *, PyObject *args, PyObject *kwargs) {
17527 PyObject *resultobj;
17528 wxDC *arg1 = (wxDC *) 0 ;
17529 int result;
17530 PyObject * obj0 = 0 ;
17531 char *kwnames[] = {
17532 (char *) "self", NULL
17533 };
17534
17535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinX",kwnames,&obj0)) goto fail;
17536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17537 if (SWIG_arg_fail(1)) SWIG_fail;
17538 {
17539 PyThreadState* __tstate = wxPyBeginAllowThreads();
17540 result = (int)((wxDC const *)arg1)->MinX();
17541
17542 wxPyEndAllowThreads(__tstate);
17543 if (PyErr_Occurred()) SWIG_fail;
17544 }
17545 {
17546 resultobj = SWIG_From_int((int)(result));
17547 }
17548 return resultobj;
17549 fail:
17550 return NULL;
17551 }
17552
17553
17554 static PyObject *_wrap_DC_MaxX(PyObject *, PyObject *args, PyObject *kwargs) {
17555 PyObject *resultobj;
17556 wxDC *arg1 = (wxDC *) 0 ;
17557 int result;
17558 PyObject * obj0 = 0 ;
17559 char *kwnames[] = {
17560 (char *) "self", NULL
17561 };
17562
17563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxX",kwnames,&obj0)) goto fail;
17564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17565 if (SWIG_arg_fail(1)) SWIG_fail;
17566 {
17567 PyThreadState* __tstate = wxPyBeginAllowThreads();
17568 result = (int)((wxDC const *)arg1)->MaxX();
17569
17570 wxPyEndAllowThreads(__tstate);
17571 if (PyErr_Occurred()) SWIG_fail;
17572 }
17573 {
17574 resultobj = SWIG_From_int((int)(result));
17575 }
17576 return resultobj;
17577 fail:
17578 return NULL;
17579 }
17580
17581
17582 static PyObject *_wrap_DC_MinY(PyObject *, PyObject *args, PyObject *kwargs) {
17583 PyObject *resultobj;
17584 wxDC *arg1 = (wxDC *) 0 ;
17585 int result;
17586 PyObject * obj0 = 0 ;
17587 char *kwnames[] = {
17588 (char *) "self", NULL
17589 };
17590
17591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinY",kwnames,&obj0)) goto fail;
17592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17593 if (SWIG_arg_fail(1)) SWIG_fail;
17594 {
17595 PyThreadState* __tstate = wxPyBeginAllowThreads();
17596 result = (int)((wxDC const *)arg1)->MinY();
17597
17598 wxPyEndAllowThreads(__tstate);
17599 if (PyErr_Occurred()) SWIG_fail;
17600 }
17601 {
17602 resultobj = SWIG_From_int((int)(result));
17603 }
17604 return resultobj;
17605 fail:
17606 return NULL;
17607 }
17608
17609
17610 static PyObject *_wrap_DC_MaxY(PyObject *, PyObject *args, PyObject *kwargs) {
17611 PyObject *resultobj;
17612 wxDC *arg1 = (wxDC *) 0 ;
17613 int result;
17614 PyObject * obj0 = 0 ;
17615 char *kwnames[] = {
17616 (char *) "self", NULL
17617 };
17618
17619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxY",kwnames,&obj0)) goto fail;
17620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17621 if (SWIG_arg_fail(1)) SWIG_fail;
17622 {
17623 PyThreadState* __tstate = wxPyBeginAllowThreads();
17624 result = (int)((wxDC const *)arg1)->MaxY();
17625
17626 wxPyEndAllowThreads(__tstate);
17627 if (PyErr_Occurred()) SWIG_fail;
17628 }
17629 {
17630 resultobj = SWIG_From_int((int)(result));
17631 }
17632 return resultobj;
17633 fail:
17634 return NULL;
17635 }
17636
17637
17638 static PyObject *_wrap_DC_GetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
17639 PyObject *resultobj;
17640 wxDC *arg1 = (wxDC *) 0 ;
17641 int *arg2 = (int *) 0 ;
17642 int *arg3 = (int *) 0 ;
17643 int *arg4 = (int *) 0 ;
17644 int *arg5 = (int *) 0 ;
17645 int temp2 ;
17646 int res2 = 0 ;
17647 int temp3 ;
17648 int res3 = 0 ;
17649 int temp4 ;
17650 int res4 = 0 ;
17651 int temp5 ;
17652 int res5 = 0 ;
17653 PyObject * obj0 = 0 ;
17654 char *kwnames[] = {
17655 (char *) "self", NULL
17656 };
17657
17658 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17659 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17660 arg4 = &temp4; res4 = SWIG_NEWOBJ;
17661 arg5 = &temp5; res5 = SWIG_NEWOBJ;
17662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBoundingBox",kwnames,&obj0)) goto fail;
17663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17664 if (SWIG_arg_fail(1)) SWIG_fail;
17665 {
17666 PyThreadState* __tstate = wxPyBeginAllowThreads();
17667 wxDC_GetBoundingBox(arg1,arg2,arg3,arg4,arg5);
17668
17669 wxPyEndAllowThreads(__tstate);
17670 if (PyErr_Occurred()) SWIG_fail;
17671 }
17672 Py_INCREF(Py_None); resultobj = Py_None;
17673 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17674 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
17675 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17676 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
17677 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
17678 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
17679 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
17680 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
17681 return resultobj;
17682 fail:
17683 return NULL;
17684 }
17685
17686
17687 static PyObject *_wrap_DC_GetHDC(PyObject *, PyObject *args, PyObject *kwargs) {
17688 PyObject *resultobj;
17689 wxDC *arg1 = (wxDC *) 0 ;
17690 long result;
17691 PyObject * obj0 = 0 ;
17692 char *kwnames[] = {
17693 (char *) "self", NULL
17694 };
17695
17696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetHDC",kwnames,&obj0)) goto fail;
17697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17698 if (SWIG_arg_fail(1)) SWIG_fail;
17699 {
17700 PyThreadState* __tstate = wxPyBeginAllowThreads();
17701 result = (long)(arg1)->GetHDC();
17702
17703 wxPyEndAllowThreads(__tstate);
17704 if (PyErr_Occurred()) SWIG_fail;
17705 }
17706 {
17707 resultobj = SWIG_From_long((long)(result));
17708 }
17709 return resultobj;
17710 fail:
17711 return NULL;
17712 }
17713
17714
17715 static PyObject *_wrap_DC__DrawPointList(PyObject *, PyObject *args, PyObject *kwargs) {
17716 PyObject *resultobj;
17717 wxDC *arg1 = (wxDC *) 0 ;
17718 PyObject *arg2 = (PyObject *) 0 ;
17719 PyObject *arg3 = (PyObject *) 0 ;
17720 PyObject *arg4 = (PyObject *) 0 ;
17721 PyObject *result;
17722 PyObject * obj0 = 0 ;
17723 PyObject * obj1 = 0 ;
17724 PyObject * obj2 = 0 ;
17725 PyObject * obj3 = 0 ;
17726 char *kwnames[] = {
17727 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17728 };
17729
17730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPointList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17732 if (SWIG_arg_fail(1)) SWIG_fail;
17733 arg2 = obj1;
17734 arg3 = obj2;
17735 arg4 = obj3;
17736 {
17737 PyThreadState* __tstate = wxPyBeginAllowThreads();
17738 result = (PyObject *)wxDC__DrawPointList(arg1,arg2,arg3,arg4);
17739
17740 wxPyEndAllowThreads(__tstate);
17741 if (PyErr_Occurred()) SWIG_fail;
17742 }
17743 resultobj = result;
17744 return resultobj;
17745 fail:
17746 return NULL;
17747 }
17748
17749
17750 static PyObject *_wrap_DC__DrawLineList(PyObject *, PyObject *args, PyObject *kwargs) {
17751 PyObject *resultobj;
17752 wxDC *arg1 = (wxDC *) 0 ;
17753 PyObject *arg2 = (PyObject *) 0 ;
17754 PyObject *arg3 = (PyObject *) 0 ;
17755 PyObject *arg4 = (PyObject *) 0 ;
17756 PyObject *result;
17757 PyObject * obj0 = 0 ;
17758 PyObject * obj1 = 0 ;
17759 PyObject * obj2 = 0 ;
17760 PyObject * obj3 = 0 ;
17761 char *kwnames[] = {
17762 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17763 };
17764
17765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawLineList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17767 if (SWIG_arg_fail(1)) SWIG_fail;
17768 arg2 = obj1;
17769 arg3 = obj2;
17770 arg4 = obj3;
17771 {
17772 PyThreadState* __tstate = wxPyBeginAllowThreads();
17773 result = (PyObject *)wxDC__DrawLineList(arg1,arg2,arg3,arg4);
17774
17775 wxPyEndAllowThreads(__tstate);
17776 if (PyErr_Occurred()) SWIG_fail;
17777 }
17778 resultobj = result;
17779 return resultobj;
17780 fail:
17781 return NULL;
17782 }
17783
17784
17785 static PyObject *_wrap_DC__DrawRectangleList(PyObject *, PyObject *args, PyObject *kwargs) {
17786 PyObject *resultobj;
17787 wxDC *arg1 = (wxDC *) 0 ;
17788 PyObject *arg2 = (PyObject *) 0 ;
17789 PyObject *arg3 = (PyObject *) 0 ;
17790 PyObject *arg4 = (PyObject *) 0 ;
17791 PyObject *result;
17792 PyObject * obj0 = 0 ;
17793 PyObject * obj1 = 0 ;
17794 PyObject * obj2 = 0 ;
17795 PyObject * obj3 = 0 ;
17796 char *kwnames[] = {
17797 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17798 };
17799
17800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawRectangleList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17802 if (SWIG_arg_fail(1)) SWIG_fail;
17803 arg2 = obj1;
17804 arg3 = obj2;
17805 arg4 = obj3;
17806 {
17807 PyThreadState* __tstate = wxPyBeginAllowThreads();
17808 result = (PyObject *)wxDC__DrawRectangleList(arg1,arg2,arg3,arg4);
17809
17810 wxPyEndAllowThreads(__tstate);
17811 if (PyErr_Occurred()) SWIG_fail;
17812 }
17813 resultobj = result;
17814 return resultobj;
17815 fail:
17816 return NULL;
17817 }
17818
17819
17820 static PyObject *_wrap_DC__DrawEllipseList(PyObject *, PyObject *args, PyObject *kwargs) {
17821 PyObject *resultobj;
17822 wxDC *arg1 = (wxDC *) 0 ;
17823 PyObject *arg2 = (PyObject *) 0 ;
17824 PyObject *arg3 = (PyObject *) 0 ;
17825 PyObject *arg4 = (PyObject *) 0 ;
17826 PyObject *result;
17827 PyObject * obj0 = 0 ;
17828 PyObject * obj1 = 0 ;
17829 PyObject * obj2 = 0 ;
17830 PyObject * obj3 = 0 ;
17831 char *kwnames[] = {
17832 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17833 };
17834
17835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawEllipseList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17837 if (SWIG_arg_fail(1)) SWIG_fail;
17838 arg2 = obj1;
17839 arg3 = obj2;
17840 arg4 = obj3;
17841 {
17842 PyThreadState* __tstate = wxPyBeginAllowThreads();
17843 result = (PyObject *)wxDC__DrawEllipseList(arg1,arg2,arg3,arg4);
17844
17845 wxPyEndAllowThreads(__tstate);
17846 if (PyErr_Occurred()) SWIG_fail;
17847 }
17848 resultobj = result;
17849 return resultobj;
17850 fail:
17851 return NULL;
17852 }
17853
17854
17855 static PyObject *_wrap_DC__DrawPolygonList(PyObject *, PyObject *args, PyObject *kwargs) {
17856 PyObject *resultobj;
17857 wxDC *arg1 = (wxDC *) 0 ;
17858 PyObject *arg2 = (PyObject *) 0 ;
17859 PyObject *arg3 = (PyObject *) 0 ;
17860 PyObject *arg4 = (PyObject *) 0 ;
17861 PyObject *result;
17862 PyObject * obj0 = 0 ;
17863 PyObject * obj1 = 0 ;
17864 PyObject * obj2 = 0 ;
17865 PyObject * obj3 = 0 ;
17866 char *kwnames[] = {
17867 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17868 };
17869
17870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPolygonList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17872 if (SWIG_arg_fail(1)) SWIG_fail;
17873 arg2 = obj1;
17874 arg3 = obj2;
17875 arg4 = obj3;
17876 {
17877 PyThreadState* __tstate = wxPyBeginAllowThreads();
17878 result = (PyObject *)wxDC__DrawPolygonList(arg1,arg2,arg3,arg4);
17879
17880 wxPyEndAllowThreads(__tstate);
17881 if (PyErr_Occurred()) SWIG_fail;
17882 }
17883 resultobj = result;
17884 return resultobj;
17885 fail:
17886 return NULL;
17887 }
17888
17889
17890 static PyObject *_wrap_DC__DrawTextList(PyObject *, PyObject *args, PyObject *kwargs) {
17891 PyObject *resultobj;
17892 wxDC *arg1 = (wxDC *) 0 ;
17893 PyObject *arg2 = (PyObject *) 0 ;
17894 PyObject *arg3 = (PyObject *) 0 ;
17895 PyObject *arg4 = (PyObject *) 0 ;
17896 PyObject *arg5 = (PyObject *) 0 ;
17897 PyObject *result;
17898 PyObject * obj0 = 0 ;
17899 PyObject * obj1 = 0 ;
17900 PyObject * obj2 = 0 ;
17901 PyObject * obj3 = 0 ;
17902 PyObject * obj4 = 0 ;
17903 char *kwnames[] = {
17904 (char *) "self",(char *) "textList",(char *) "pyPoints",(char *) "foregroundList",(char *) "backgroundList", NULL
17905 };
17906
17907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC__DrawTextList",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
17908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17909 if (SWIG_arg_fail(1)) SWIG_fail;
17910 arg2 = obj1;
17911 arg3 = obj2;
17912 arg4 = obj3;
17913 arg5 = obj4;
17914 {
17915 PyThreadState* __tstate = wxPyBeginAllowThreads();
17916 result = (PyObject *)wxDC__DrawTextList(arg1,arg2,arg3,arg4,arg5);
17917
17918 wxPyEndAllowThreads(__tstate);
17919 if (PyErr_Occurred()) SWIG_fail;
17920 }
17921 resultobj = result;
17922 return resultobj;
17923 fail:
17924 return NULL;
17925 }
17926
17927
17928 static PyObject * DC_swigregister(PyObject *, PyObject *args) {
17929 PyObject *obj;
17930 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17931 SWIG_TypeClientData(SWIGTYPE_p_wxDC, obj);
17932 Py_INCREF(obj);
17933 return Py_BuildValue((char *)"");
17934 }
17935 static PyObject *_wrap_new_MemoryDC(PyObject *, PyObject *args, PyObject *kwargs) {
17936 PyObject *resultobj;
17937 wxMemoryDC *result;
17938 char *kwnames[] = {
17939 NULL
17940 };
17941
17942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryDC",kwnames)) goto fail;
17943 {
17944 if (!wxPyCheckForApp()) SWIG_fail;
17945 PyThreadState* __tstate = wxPyBeginAllowThreads();
17946 result = (wxMemoryDC *)new wxMemoryDC();
17947
17948 wxPyEndAllowThreads(__tstate);
17949 if (PyErr_Occurred()) SWIG_fail;
17950 }
17951 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17952 return resultobj;
17953 fail:
17954 return NULL;
17955 }
17956
17957
17958 static PyObject *_wrap_new_MemoryDCFromDC(PyObject *, PyObject *args, PyObject *kwargs) {
17959 PyObject *resultobj;
17960 wxDC *arg1 = (wxDC *) 0 ;
17961 wxMemoryDC *result;
17962 PyObject * obj0 = 0 ;
17963 char *kwnames[] = {
17964 (char *) "oldDC", NULL
17965 };
17966
17967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_MemoryDCFromDC",kwnames,&obj0)) goto fail;
17968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17969 if (SWIG_arg_fail(1)) SWIG_fail;
17970 {
17971 if (!wxPyCheckForApp()) SWIG_fail;
17972 PyThreadState* __tstate = wxPyBeginAllowThreads();
17973 result = (wxMemoryDC *)new wxMemoryDC(arg1);
17974
17975 wxPyEndAllowThreads(__tstate);
17976 if (PyErr_Occurred()) SWIG_fail;
17977 }
17978 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17979 return resultobj;
17980 fail:
17981 return NULL;
17982 }
17983
17984
17985 static PyObject *_wrap_MemoryDC_SelectObject(PyObject *, PyObject *args, PyObject *kwargs) {
17986 PyObject *resultobj;
17987 wxMemoryDC *arg1 = (wxMemoryDC *) 0 ;
17988 wxBitmap *arg2 = 0 ;
17989 PyObject * obj0 = 0 ;
17990 PyObject * obj1 = 0 ;
17991 char *kwnames[] = {
17992 (char *) "self",(char *) "bitmap", NULL
17993 };
17994
17995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryDC_SelectObject",kwnames,&obj0,&obj1)) goto fail;
17996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryDC, SWIG_POINTER_EXCEPTION | 0);
17997 if (SWIG_arg_fail(1)) SWIG_fail;
17998 {
17999 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18000 if (SWIG_arg_fail(2)) SWIG_fail;
18001 if (arg2 == NULL) {
18002 SWIG_null_ref("wxBitmap");
18003 }
18004 if (SWIG_arg_fail(2)) SWIG_fail;
18005 }
18006 {
18007 PyThreadState* __tstate = wxPyBeginAllowThreads();
18008 (arg1)->SelectObject((wxBitmap const &)*arg2);
18009
18010 wxPyEndAllowThreads(__tstate);
18011 if (PyErr_Occurred()) SWIG_fail;
18012 }
18013 Py_INCREF(Py_None); resultobj = Py_None;
18014 return resultobj;
18015 fail:
18016 return NULL;
18017 }
18018
18019
18020 static PyObject * MemoryDC_swigregister(PyObject *, PyObject *args) {
18021 PyObject *obj;
18022 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18023 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryDC, obj);
18024 Py_INCREF(obj);
18025 return Py_BuildValue((char *)"");
18026 }
18027 static PyObject *_wrap_new_BufferedDC__SWIG_0(PyObject *, PyObject *args) {
18028 PyObject *resultobj;
18029 wxDC *arg1 = (wxDC *) 0 ;
18030 wxBitmap const &arg2_defvalue = wxNullBitmap ;
18031 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
18032 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
18033 wxBufferedDC *result;
18034 PyObject * obj0 = 0 ;
18035 PyObject * obj1 = 0 ;
18036 PyObject * obj2 = 0 ;
18037
18038 if(!PyArg_ParseTuple(args,(char *)"O|OO:new_BufferedDC",&obj0,&obj1,&obj2)) goto fail;
18039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
18040 if (SWIG_arg_fail(1)) SWIG_fail;
18041 if (obj1) {
18042 {
18043 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18044 if (SWIG_arg_fail(2)) SWIG_fail;
18045 if (arg2 == NULL) {
18046 SWIG_null_ref("wxBitmap");
18047 }
18048 if (SWIG_arg_fail(2)) SWIG_fail;
18049 }
18050 }
18051 if (obj2) {
18052 {
18053 arg3 = (int)(SWIG_As_int(obj2));
18054 if (SWIG_arg_fail(3)) SWIG_fail;
18055 }
18056 }
18057 {
18058 if (!wxPyCheckForApp()) SWIG_fail;
18059 PyThreadState* __tstate = wxPyBeginAllowThreads();
18060 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxBitmap const &)*arg2,arg3);
18061
18062 wxPyEndAllowThreads(__tstate);
18063 if (PyErr_Occurred()) SWIG_fail;
18064 }
18065 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
18066 return resultobj;
18067 fail:
18068 return NULL;
18069 }
18070
18071
18072 static PyObject *_wrap_new_BufferedDC__SWIG_1(PyObject *, PyObject *args) {
18073 PyObject *resultobj;
18074 wxDC *arg1 = (wxDC *) 0 ;
18075 wxSize *arg2 = 0 ;
18076 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
18077 wxBufferedDC *result;
18078 wxSize temp2 ;
18079 PyObject * obj0 = 0 ;
18080 PyObject * obj1 = 0 ;
18081 PyObject * obj2 = 0 ;
18082
18083 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_BufferedDC",&obj0,&obj1,&obj2)) goto fail;
18084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
18085 if (SWIG_arg_fail(1)) SWIG_fail;
18086 {
18087 arg2 = &temp2;
18088 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
18089 }
18090 if (obj2) {
18091 {
18092 arg3 = (int)(SWIG_As_int(obj2));
18093 if (SWIG_arg_fail(3)) SWIG_fail;
18094 }
18095 }
18096 {
18097 if (!wxPyCheckForApp()) SWIG_fail;
18098 PyThreadState* __tstate = wxPyBeginAllowThreads();
18099 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxSize const &)*arg2,arg3);
18100
18101 wxPyEndAllowThreads(__tstate);
18102 if (PyErr_Occurred()) SWIG_fail;
18103 }
18104 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
18105 return resultobj;
18106 fail:
18107 return NULL;
18108 }
18109
18110
18111 static PyObject *_wrap_new_BufferedDC(PyObject *self, PyObject *args) {
18112 int argc;
18113 PyObject *argv[4];
18114 int ii;
18115
18116 argc = PyObject_Length(args);
18117 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
18118 argv[ii] = PyTuple_GetItem(args,ii);
18119 }
18120 if ((argc >= 1) && (argc <= 3)) {
18121 int _v;
18122 {
18123 void *ptr;
18124 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
18125 _v = 0;
18126 PyErr_Clear();
18127 } else {
18128 _v = 1;
18129 }
18130 }
18131 if (_v) {
18132 if (argc <= 1) {
18133 return _wrap_new_BufferedDC__SWIG_0(self,args);
18134 }
18135 {
18136 void *ptr = 0;
18137 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxBitmap, 0) == -1) {
18138 _v = 0;
18139 PyErr_Clear();
18140 } else {
18141 _v = (ptr != 0);
18142 }
18143 }
18144 if (_v) {
18145 if (argc <= 2) {
18146 return _wrap_new_BufferedDC__SWIG_0(self,args);
18147 }
18148 _v = SWIG_Check_int(argv[2]);
18149 if (_v) {
18150 return _wrap_new_BufferedDC__SWIG_0(self,args);
18151 }
18152 }
18153 }
18154 }
18155 if ((argc >= 2) && (argc <= 3)) {
18156 int _v;
18157 {
18158 void *ptr;
18159 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
18160 _v = 0;
18161 PyErr_Clear();
18162 } else {
18163 _v = 1;
18164 }
18165 }
18166 if (_v) {
18167 {
18168 _v = wxPySimple_typecheck(argv[1], wxT("wxSize"), 2);
18169 }
18170 if (_v) {
18171 if (argc <= 2) {
18172 return _wrap_new_BufferedDC__SWIG_1(self,args);
18173 }
18174 _v = SWIG_Check_int(argv[2]);
18175 if (_v) {
18176 return _wrap_new_BufferedDC__SWIG_1(self,args);
18177 }
18178 }
18179 }
18180 }
18181
18182 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_BufferedDC'");
18183 return NULL;
18184 }
18185
18186
18187 static PyObject *_wrap_delete_BufferedDC(PyObject *, PyObject *args, PyObject *kwargs) {
18188 PyObject *resultobj;
18189 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
18190 PyObject * obj0 = 0 ;
18191 char *kwnames[] = {
18192 (char *) "self", NULL
18193 };
18194
18195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BufferedDC",kwnames,&obj0)) goto fail;
18196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
18197 if (SWIG_arg_fail(1)) SWIG_fail;
18198 {
18199 PyThreadState* __tstate = wxPyBeginAllowThreads();
18200 delete arg1;
18201
18202 wxPyEndAllowThreads(__tstate);
18203 if (PyErr_Occurred()) SWIG_fail;
18204 }
18205 Py_INCREF(Py_None); resultobj = Py_None;
18206 return resultobj;
18207 fail:
18208 return NULL;
18209 }
18210
18211
18212 static PyObject *_wrap_BufferedDC_UnMask(PyObject *, PyObject *args, PyObject *kwargs) {
18213 PyObject *resultobj;
18214 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
18215 PyObject * obj0 = 0 ;
18216 char *kwnames[] = {
18217 (char *) "self", NULL
18218 };
18219
18220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BufferedDC_UnMask",kwnames,&obj0)) goto fail;
18221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
18222 if (SWIG_arg_fail(1)) SWIG_fail;
18223 {
18224 PyThreadState* __tstate = wxPyBeginAllowThreads();
18225 (arg1)->UnMask();
18226
18227 wxPyEndAllowThreads(__tstate);
18228 if (PyErr_Occurred()) SWIG_fail;
18229 }
18230 Py_INCREF(Py_None); resultobj = Py_None;
18231 return resultobj;
18232 fail:
18233 return NULL;
18234 }
18235
18236
18237 static PyObject * BufferedDC_swigregister(PyObject *, PyObject *args) {
18238 PyObject *obj;
18239 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18240 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedDC, obj);
18241 Py_INCREF(obj);
18242 return Py_BuildValue((char *)"");
18243 }
18244 static PyObject *_wrap_new_BufferedPaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
18245 PyObject *resultobj;
18246 wxWindow *arg1 = (wxWindow *) 0 ;
18247 wxBitmap const &arg2_defvalue = wxNullBitmap ;
18248 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
18249 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
18250 wxBufferedPaintDC *result;
18251 PyObject * obj0 = 0 ;
18252 PyObject * obj1 = 0 ;
18253 PyObject * obj2 = 0 ;
18254 char *kwnames[] = {
18255 (char *) "window",(char *) "buffer",(char *) "style", NULL
18256 };
18257
18258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_BufferedPaintDC",kwnames,&obj0,&obj1,&obj2)) goto fail;
18259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18260 if (SWIG_arg_fail(1)) SWIG_fail;
18261 if (obj1) {
18262 {
18263 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18264 if (SWIG_arg_fail(2)) SWIG_fail;
18265 if (arg2 == NULL) {
18266 SWIG_null_ref("wxBitmap");
18267 }
18268 if (SWIG_arg_fail(2)) SWIG_fail;
18269 }
18270 }
18271 if (obj2) {
18272 {
18273 arg3 = (int)(SWIG_As_int(obj2));
18274 if (SWIG_arg_fail(3)) SWIG_fail;
18275 }
18276 }
18277 {
18278 if (!wxPyCheckForApp()) SWIG_fail;
18279 PyThreadState* __tstate = wxPyBeginAllowThreads();
18280 result = (wxBufferedPaintDC *)new wxBufferedPaintDC(arg1,(wxBitmap const &)*arg2,arg3);
18281
18282 wxPyEndAllowThreads(__tstate);
18283 if (PyErr_Occurred()) SWIG_fail;
18284 }
18285 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedPaintDC, 1);
18286 return resultobj;
18287 fail:
18288 return NULL;
18289 }
18290
18291
18292 static PyObject * BufferedPaintDC_swigregister(PyObject *, PyObject *args) {
18293 PyObject *obj;
18294 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18295 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedPaintDC, obj);
18296 Py_INCREF(obj);
18297 return Py_BuildValue((char *)"");
18298 }
18299 static PyObject *_wrap_new_ScreenDC(PyObject *, PyObject *args, PyObject *kwargs) {
18300 PyObject *resultobj;
18301 wxScreenDC *result;
18302 char *kwnames[] = {
18303 NULL
18304 };
18305
18306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ScreenDC",kwnames)) goto fail;
18307 {
18308 if (!wxPyCheckForApp()) SWIG_fail;
18309 PyThreadState* __tstate = wxPyBeginAllowThreads();
18310 result = (wxScreenDC *)new wxScreenDC();
18311
18312 wxPyEndAllowThreads(__tstate);
18313 if (PyErr_Occurred()) SWIG_fail;
18314 }
18315 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScreenDC, 1);
18316 return resultobj;
18317 fail:
18318 return NULL;
18319 }
18320
18321
18322 static PyObject *_wrap_ScreenDC_StartDrawingOnTopWin(PyObject *, PyObject *args, PyObject *kwargs) {
18323 PyObject *resultobj;
18324 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
18325 wxWindow *arg2 = (wxWindow *) 0 ;
18326 bool result;
18327 PyObject * obj0 = 0 ;
18328 PyObject * obj1 = 0 ;
18329 char *kwnames[] = {
18330 (char *) "self",(char *) "window", NULL
18331 };
18332
18333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScreenDC_StartDrawingOnTopWin",kwnames,&obj0,&obj1)) goto fail;
18334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
18335 if (SWIG_arg_fail(1)) SWIG_fail;
18336 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18337 if (SWIG_arg_fail(2)) SWIG_fail;
18338 {
18339 PyThreadState* __tstate = wxPyBeginAllowThreads();
18340 result = (bool)(arg1)->StartDrawingOnTop(arg2);
18341
18342 wxPyEndAllowThreads(__tstate);
18343 if (PyErr_Occurred()) SWIG_fail;
18344 }
18345 {
18346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18347 }
18348 return resultobj;
18349 fail:
18350 return NULL;
18351 }
18352
18353
18354 static PyObject *_wrap_ScreenDC_StartDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
18355 PyObject *resultobj;
18356 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
18357 wxRect *arg2 = (wxRect *) NULL ;
18358 bool result;
18359 PyObject * obj0 = 0 ;
18360 PyObject * obj1 = 0 ;
18361 char *kwnames[] = {
18362 (char *) "self",(char *) "rect", NULL
18363 };
18364
18365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ScreenDC_StartDrawingOnTop",kwnames,&obj0,&obj1)) goto fail;
18366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
18367 if (SWIG_arg_fail(1)) SWIG_fail;
18368 if (obj1) {
18369 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
18370 if (SWIG_arg_fail(2)) SWIG_fail;
18371 }
18372 {
18373 PyThreadState* __tstate = wxPyBeginAllowThreads();
18374 result = (bool)(arg1)->StartDrawingOnTop(arg2);
18375
18376 wxPyEndAllowThreads(__tstate);
18377 if (PyErr_Occurred()) SWIG_fail;
18378 }
18379 {
18380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18381 }
18382 return resultobj;
18383 fail:
18384 return NULL;
18385 }
18386
18387
18388 static PyObject *_wrap_ScreenDC_EndDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
18389 PyObject *resultobj;
18390 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
18391 bool result;
18392 PyObject * obj0 = 0 ;
18393 char *kwnames[] = {
18394 (char *) "self", NULL
18395 };
18396
18397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScreenDC_EndDrawingOnTop",kwnames,&obj0)) goto fail;
18398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
18399 if (SWIG_arg_fail(1)) SWIG_fail;
18400 {
18401 PyThreadState* __tstate = wxPyBeginAllowThreads();
18402 result = (bool)(arg1)->EndDrawingOnTop();
18403
18404 wxPyEndAllowThreads(__tstate);
18405 if (PyErr_Occurred()) SWIG_fail;
18406 }
18407 {
18408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18409 }
18410 return resultobj;
18411 fail:
18412 return NULL;
18413 }
18414
18415
18416 static PyObject * ScreenDC_swigregister(PyObject *, PyObject *args) {
18417 PyObject *obj;
18418 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18419 SWIG_TypeClientData(SWIGTYPE_p_wxScreenDC, obj);
18420 Py_INCREF(obj);
18421 return Py_BuildValue((char *)"");
18422 }
18423 static PyObject *_wrap_new_ClientDC(PyObject *, PyObject *args, PyObject *kwargs) {
18424 PyObject *resultobj;
18425 wxWindow *arg1 = (wxWindow *) 0 ;
18426 wxClientDC *result;
18427 PyObject * obj0 = 0 ;
18428 char *kwnames[] = {
18429 (char *) "win", NULL
18430 };
18431
18432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ClientDC",kwnames,&obj0)) goto fail;
18433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18434 if (SWIG_arg_fail(1)) SWIG_fail;
18435 {
18436 if (!wxPyCheckForApp()) SWIG_fail;
18437 PyThreadState* __tstate = wxPyBeginAllowThreads();
18438 result = (wxClientDC *)new wxClientDC(arg1);
18439
18440 wxPyEndAllowThreads(__tstate);
18441 if (PyErr_Occurred()) SWIG_fail;
18442 }
18443 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClientDC, 1);
18444 return resultobj;
18445 fail:
18446 return NULL;
18447 }
18448
18449
18450 static PyObject * ClientDC_swigregister(PyObject *, PyObject *args) {
18451 PyObject *obj;
18452 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18453 SWIG_TypeClientData(SWIGTYPE_p_wxClientDC, obj);
18454 Py_INCREF(obj);
18455 return Py_BuildValue((char *)"");
18456 }
18457 static PyObject *_wrap_new_PaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
18458 PyObject *resultobj;
18459 wxWindow *arg1 = (wxWindow *) 0 ;
18460 wxPaintDC *result;
18461 PyObject * obj0 = 0 ;
18462 char *kwnames[] = {
18463 (char *) "win", NULL
18464 };
18465
18466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PaintDC",kwnames,&obj0)) goto fail;
18467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18468 if (SWIG_arg_fail(1)) SWIG_fail;
18469 {
18470 if (!wxPyCheckForApp()) SWIG_fail;
18471 PyThreadState* __tstate = wxPyBeginAllowThreads();
18472 result = (wxPaintDC *)new wxPaintDC(arg1);
18473
18474 wxPyEndAllowThreads(__tstate);
18475 if (PyErr_Occurred()) SWIG_fail;
18476 }
18477 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintDC, 1);
18478 return resultobj;
18479 fail:
18480 return NULL;
18481 }
18482
18483
18484 static PyObject * PaintDC_swigregister(PyObject *, PyObject *args) {
18485 PyObject *obj;
18486 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18487 SWIG_TypeClientData(SWIGTYPE_p_wxPaintDC, obj);
18488 Py_INCREF(obj);
18489 return Py_BuildValue((char *)"");
18490 }
18491 static PyObject *_wrap_new_WindowDC(PyObject *, PyObject *args, PyObject *kwargs) {
18492 PyObject *resultobj;
18493 wxWindow *arg1 = (wxWindow *) 0 ;
18494 wxWindowDC *result;
18495 PyObject * obj0 = 0 ;
18496 char *kwnames[] = {
18497 (char *) "win", NULL
18498 };
18499
18500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_WindowDC",kwnames,&obj0)) goto fail;
18501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18502 if (SWIG_arg_fail(1)) SWIG_fail;
18503 {
18504 if (!wxPyCheckForApp()) SWIG_fail;
18505 PyThreadState* __tstate = wxPyBeginAllowThreads();
18506 result = (wxWindowDC *)new wxWindowDC(arg1);
18507
18508 wxPyEndAllowThreads(__tstate);
18509 if (PyErr_Occurred()) SWIG_fail;
18510 }
18511 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDC, 1);
18512 return resultobj;
18513 fail:
18514 return NULL;
18515 }
18516
18517
18518 static PyObject * WindowDC_swigregister(PyObject *, PyObject *args) {
18519 PyObject *obj;
18520 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18521 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDC, obj);
18522 Py_INCREF(obj);
18523 return Py_BuildValue((char *)"");
18524 }
18525 static PyObject *_wrap_new_MirrorDC(PyObject *, PyObject *args, PyObject *kwargs) {
18526 PyObject *resultobj;
18527 wxDC *arg1 = 0 ;
18528 bool arg2 ;
18529 wxMirrorDC *result;
18530 PyObject * obj0 = 0 ;
18531 PyObject * obj1 = 0 ;
18532 char *kwnames[] = {
18533 (char *) "dc",(char *) "mirror", NULL
18534 };
18535
18536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_MirrorDC",kwnames,&obj0,&obj1)) goto fail;
18537 {
18538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
18539 if (SWIG_arg_fail(1)) SWIG_fail;
18540 if (arg1 == NULL) {
18541 SWIG_null_ref("wxDC");
18542 }
18543 if (SWIG_arg_fail(1)) SWIG_fail;
18544 }
18545 {
18546 arg2 = (bool)(SWIG_As_bool(obj1));
18547 if (SWIG_arg_fail(2)) SWIG_fail;
18548 }
18549 {
18550 if (!wxPyCheckForApp()) SWIG_fail;
18551 PyThreadState* __tstate = wxPyBeginAllowThreads();
18552 result = (wxMirrorDC *)new wxMirrorDC(*arg1,arg2);
18553
18554 wxPyEndAllowThreads(__tstate);
18555 if (PyErr_Occurred()) SWIG_fail;
18556 }
18557 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMirrorDC, 1);
18558 return resultobj;
18559 fail:
18560 return NULL;
18561 }
18562
18563
18564 static PyObject * MirrorDC_swigregister(PyObject *, PyObject *args) {
18565 PyObject *obj;
18566 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18567 SWIG_TypeClientData(SWIGTYPE_p_wxMirrorDC, obj);
18568 Py_INCREF(obj);
18569 return Py_BuildValue((char *)"");
18570 }
18571 static PyObject *_wrap_new_PostScriptDC(PyObject *, PyObject *args, PyObject *kwargs) {
18572 PyObject *resultobj;
18573 wxPrintData *arg1 = 0 ;
18574 wxPostScriptDC *result;
18575 PyObject * obj0 = 0 ;
18576 char *kwnames[] = {
18577 (char *) "printData", NULL
18578 };
18579
18580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PostScriptDC",kwnames,&obj0)) goto fail;
18581 {
18582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
18583 if (SWIG_arg_fail(1)) SWIG_fail;
18584 if (arg1 == NULL) {
18585 SWIG_null_ref("wxPrintData");
18586 }
18587 if (SWIG_arg_fail(1)) SWIG_fail;
18588 }
18589 {
18590 if (!wxPyCheckForApp()) SWIG_fail;
18591 PyThreadState* __tstate = wxPyBeginAllowThreads();
18592 result = (wxPostScriptDC *)new wxPostScriptDC((wxPrintData const &)*arg1);
18593
18594 wxPyEndAllowThreads(__tstate);
18595 if (PyErr_Occurred()) SWIG_fail;
18596 }
18597 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPostScriptDC, 1);
18598 return resultobj;
18599 fail:
18600 return NULL;
18601 }
18602
18603
18604 static PyObject *_wrap_PostScriptDC_GetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
18605 PyObject *resultobj;
18606 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
18607 wxPrintData *result;
18608 PyObject * obj0 = 0 ;
18609 char *kwnames[] = {
18610 (char *) "self", NULL
18611 };
18612
18613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_GetPrintData",kwnames,&obj0)) goto fail;
18614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
18615 if (SWIG_arg_fail(1)) SWIG_fail;
18616 {
18617 PyThreadState* __tstate = wxPyBeginAllowThreads();
18618 {
18619 wxPrintData &_result_ref = (arg1)->GetPrintData();
18620 result = (wxPrintData *) &_result_ref;
18621 }
18622
18623 wxPyEndAllowThreads(__tstate);
18624 if (PyErr_Occurred()) SWIG_fail;
18625 }
18626 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 0);
18627 return resultobj;
18628 fail:
18629 return NULL;
18630 }
18631
18632
18633 static PyObject *_wrap_PostScriptDC_SetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
18634 PyObject *resultobj;
18635 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
18636 wxPrintData *arg2 = 0 ;
18637 PyObject * obj0 = 0 ;
18638 PyObject * obj1 = 0 ;
18639 char *kwnames[] = {
18640 (char *) "self",(char *) "data", NULL
18641 };
18642
18643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostScriptDC_SetPrintData",kwnames,&obj0,&obj1)) goto fail;
18644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
18645 if (SWIG_arg_fail(1)) SWIG_fail;
18646 {
18647 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
18648 if (SWIG_arg_fail(2)) SWIG_fail;
18649 if (arg2 == NULL) {
18650 SWIG_null_ref("wxPrintData");
18651 }
18652 if (SWIG_arg_fail(2)) SWIG_fail;
18653 }
18654 {
18655 PyThreadState* __tstate = wxPyBeginAllowThreads();
18656 (arg1)->SetPrintData((wxPrintData const &)*arg2);
18657
18658 wxPyEndAllowThreads(__tstate);
18659 if (PyErr_Occurred()) SWIG_fail;
18660 }
18661 Py_INCREF(Py_None); resultobj = Py_None;
18662 return resultobj;
18663 fail:
18664 return NULL;
18665 }
18666
18667
18668 static PyObject *_wrap_PostScriptDC_SetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
18669 PyObject *resultobj;
18670 int arg1 ;
18671 PyObject * obj0 = 0 ;
18672 char *kwnames[] = {
18673 (char *) "ppi", NULL
18674 };
18675
18676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_SetResolution",kwnames,&obj0)) goto fail;
18677 {
18678 arg1 = (int)(SWIG_As_int(obj0));
18679 if (SWIG_arg_fail(1)) SWIG_fail;
18680 }
18681 {
18682 PyThreadState* __tstate = wxPyBeginAllowThreads();
18683 wxPostScriptDC::SetResolution(arg1);
18684
18685 wxPyEndAllowThreads(__tstate);
18686 if (PyErr_Occurred()) SWIG_fail;
18687 }
18688 Py_INCREF(Py_None); resultobj = Py_None;
18689 return resultobj;
18690 fail:
18691 return NULL;
18692 }
18693
18694
18695 static PyObject *_wrap_PostScriptDC_GetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
18696 PyObject *resultobj;
18697 int result;
18698 char *kwnames[] = {
18699 NULL
18700 };
18701
18702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PostScriptDC_GetResolution",kwnames)) goto fail;
18703 {
18704 PyThreadState* __tstate = wxPyBeginAllowThreads();
18705 result = (int)wxPostScriptDC::GetResolution();
18706
18707 wxPyEndAllowThreads(__tstate);
18708 if (PyErr_Occurred()) SWIG_fail;
18709 }
18710 {
18711 resultobj = SWIG_From_int((int)(result));
18712 }
18713 return resultobj;
18714 fail:
18715 return NULL;
18716 }
18717
18718
18719 static PyObject * PostScriptDC_swigregister(PyObject *, PyObject *args) {
18720 PyObject *obj;
18721 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18722 SWIG_TypeClientData(SWIGTYPE_p_wxPostScriptDC, obj);
18723 Py_INCREF(obj);
18724 return Py_BuildValue((char *)"");
18725 }
18726 static PyObject *_wrap_new_MetaFile(PyObject *, PyObject *args, PyObject *kwargs) {
18727 PyObject *resultobj;
18728 wxString const &arg1_defvalue = wxPyEmptyString ;
18729 wxString *arg1 = (wxString *) &arg1_defvalue ;
18730 wxMetaFile *result;
18731 bool temp1 = false ;
18732 PyObject * obj0 = 0 ;
18733 char *kwnames[] = {
18734 (char *) "filename", NULL
18735 };
18736
18737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MetaFile",kwnames,&obj0)) goto fail;
18738 if (obj0) {
18739 {
18740 arg1 = wxString_in_helper(obj0);
18741 if (arg1 == NULL) SWIG_fail;
18742 temp1 = true;
18743 }
18744 }
18745 {
18746 if (!wxPyCheckForApp()) SWIG_fail;
18747 PyThreadState* __tstate = wxPyBeginAllowThreads();
18748 result = (wxMetaFile *)new wxMetaFile((wxString const &)*arg1);
18749
18750 wxPyEndAllowThreads(__tstate);
18751 if (PyErr_Occurred()) SWIG_fail;
18752 }
18753 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFile, 1);
18754 {
18755 if (temp1)
18756 delete arg1;
18757 }
18758 return resultobj;
18759 fail:
18760 {
18761 if (temp1)
18762 delete arg1;
18763 }
18764 return NULL;
18765 }
18766
18767
18768 static PyObject *_wrap_delete_MetaFile(PyObject *, PyObject *args, PyObject *kwargs) {
18769 PyObject *resultobj;
18770 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18771 PyObject * obj0 = 0 ;
18772 char *kwnames[] = {
18773 (char *) "self", NULL
18774 };
18775
18776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MetaFile",kwnames,&obj0)) goto fail;
18777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18778 if (SWIG_arg_fail(1)) SWIG_fail;
18779 {
18780 PyThreadState* __tstate = wxPyBeginAllowThreads();
18781 delete arg1;
18782
18783 wxPyEndAllowThreads(__tstate);
18784 if (PyErr_Occurred()) SWIG_fail;
18785 }
18786 Py_INCREF(Py_None); resultobj = Py_None;
18787 return resultobj;
18788 fail:
18789 return NULL;
18790 }
18791
18792
18793 static PyObject *_wrap_MetaFile_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
18794 PyObject *resultobj;
18795 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18796 bool result;
18797 PyObject * obj0 = 0 ;
18798 char *kwnames[] = {
18799 (char *) "self", NULL
18800 };
18801
18802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_Ok",kwnames,&obj0)) goto fail;
18803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18804 if (SWIG_arg_fail(1)) SWIG_fail;
18805 {
18806 PyThreadState* __tstate = wxPyBeginAllowThreads();
18807 result = (bool)(arg1)->Ok();
18808
18809 wxPyEndAllowThreads(__tstate);
18810 if (PyErr_Occurred()) SWIG_fail;
18811 }
18812 {
18813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18814 }
18815 return resultobj;
18816 fail:
18817 return NULL;
18818 }
18819
18820
18821 static PyObject *_wrap_MetaFile_SetClipboard(PyObject *, PyObject *args, PyObject *kwargs) {
18822 PyObject *resultobj;
18823 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18824 int arg2 = (int) 0 ;
18825 int arg3 = (int) 0 ;
18826 bool result;
18827 PyObject * obj0 = 0 ;
18828 PyObject * obj1 = 0 ;
18829 PyObject * obj2 = 0 ;
18830 char *kwnames[] = {
18831 (char *) "self",(char *) "width",(char *) "height", NULL
18832 };
18833
18834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MetaFile_SetClipboard",kwnames,&obj0,&obj1,&obj2)) goto fail;
18835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18836 if (SWIG_arg_fail(1)) SWIG_fail;
18837 if (obj1) {
18838 {
18839 arg2 = (int)(SWIG_As_int(obj1));
18840 if (SWIG_arg_fail(2)) SWIG_fail;
18841 }
18842 }
18843 if (obj2) {
18844 {
18845 arg3 = (int)(SWIG_As_int(obj2));
18846 if (SWIG_arg_fail(3)) SWIG_fail;
18847 }
18848 }
18849 {
18850 PyThreadState* __tstate = wxPyBeginAllowThreads();
18851 result = (bool)(arg1)->SetClipboard(arg2,arg3);
18852
18853 wxPyEndAllowThreads(__tstate);
18854 if (PyErr_Occurred()) SWIG_fail;
18855 }
18856 {
18857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18858 }
18859 return resultobj;
18860 fail:
18861 return NULL;
18862 }
18863
18864
18865 static PyObject *_wrap_MetaFile_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18866 PyObject *resultobj;
18867 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18868 wxSize result;
18869 PyObject * obj0 = 0 ;
18870 char *kwnames[] = {
18871 (char *) "self", NULL
18872 };
18873
18874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetSize",kwnames,&obj0)) goto fail;
18875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18876 if (SWIG_arg_fail(1)) SWIG_fail;
18877 {
18878 PyThreadState* __tstate = wxPyBeginAllowThreads();
18879 result = (arg1)->GetSize();
18880
18881 wxPyEndAllowThreads(__tstate);
18882 if (PyErr_Occurred()) SWIG_fail;
18883 }
18884 {
18885 wxSize * resultptr;
18886 resultptr = new wxSize((wxSize &)(result));
18887 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18888 }
18889 return resultobj;
18890 fail:
18891 return NULL;
18892 }
18893
18894
18895 static PyObject *_wrap_MetaFile_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
18896 PyObject *resultobj;
18897 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18898 int result;
18899 PyObject * obj0 = 0 ;
18900 char *kwnames[] = {
18901 (char *) "self", NULL
18902 };
18903
18904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetWidth",kwnames,&obj0)) goto fail;
18905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18906 if (SWIG_arg_fail(1)) SWIG_fail;
18907 {
18908 PyThreadState* __tstate = wxPyBeginAllowThreads();
18909 result = (int)(arg1)->GetWidth();
18910
18911 wxPyEndAllowThreads(__tstate);
18912 if (PyErr_Occurred()) SWIG_fail;
18913 }
18914 {
18915 resultobj = SWIG_From_int((int)(result));
18916 }
18917 return resultobj;
18918 fail:
18919 return NULL;
18920 }
18921
18922
18923 static PyObject *_wrap_MetaFile_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
18924 PyObject *resultobj;
18925 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18926 int result;
18927 PyObject * obj0 = 0 ;
18928 char *kwnames[] = {
18929 (char *) "self", NULL
18930 };
18931
18932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetHeight",kwnames,&obj0)) goto fail;
18933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18934 if (SWIG_arg_fail(1)) SWIG_fail;
18935 {
18936 PyThreadState* __tstate = wxPyBeginAllowThreads();
18937 result = (int)(arg1)->GetHeight();
18938
18939 wxPyEndAllowThreads(__tstate);
18940 if (PyErr_Occurred()) SWIG_fail;
18941 }
18942 {
18943 resultobj = SWIG_From_int((int)(result));
18944 }
18945 return resultobj;
18946 fail:
18947 return NULL;
18948 }
18949
18950
18951 static PyObject *_wrap_MetaFile_GetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
18952 PyObject *resultobj;
18953 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18954 wxString *result;
18955 PyObject * obj0 = 0 ;
18956 char *kwnames[] = {
18957 (char *) "self", NULL
18958 };
18959
18960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetFileName",kwnames,&obj0)) goto fail;
18961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18962 if (SWIG_arg_fail(1)) SWIG_fail;
18963 {
18964 PyThreadState* __tstate = wxPyBeginAllowThreads();
18965 {
18966 wxString const &_result_ref = ((wxMetaFile const *)arg1)->GetFileName();
18967 result = (wxString *) &_result_ref;
18968 }
18969
18970 wxPyEndAllowThreads(__tstate);
18971 if (PyErr_Occurred()) SWIG_fail;
18972 }
18973 {
18974 #if wxUSE_UNICODE
18975 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18976 #else
18977 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18978 #endif
18979 }
18980 return resultobj;
18981 fail:
18982 return NULL;
18983 }
18984
18985
18986 static PyObject * MetaFile_swigregister(PyObject *, PyObject *args) {
18987 PyObject *obj;
18988 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18989 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFile, obj);
18990 Py_INCREF(obj);
18991 return Py_BuildValue((char *)"");
18992 }
18993 static PyObject *_wrap_new_MetaFileDC(PyObject *, PyObject *args, PyObject *kwargs) {
18994 PyObject *resultobj;
18995 wxString const &arg1_defvalue = wxPyEmptyString ;
18996 wxString *arg1 = (wxString *) &arg1_defvalue ;
18997 int arg2 = (int) 0 ;
18998 int arg3 = (int) 0 ;
18999 wxString const &arg4_defvalue = wxPyEmptyString ;
19000 wxString *arg4 = (wxString *) &arg4_defvalue ;
19001 wxMetaFileDC *result;
19002 bool temp1 = false ;
19003 bool temp4 = false ;
19004 PyObject * obj0 = 0 ;
19005 PyObject * obj1 = 0 ;
19006 PyObject * obj2 = 0 ;
19007 PyObject * obj3 = 0 ;
19008 char *kwnames[] = {
19009 (char *) "filename",(char *) "width",(char *) "height",(char *) "description", NULL
19010 };
19011
19012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_MetaFileDC",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19013 if (obj0) {
19014 {
19015 arg1 = wxString_in_helper(obj0);
19016 if (arg1 == NULL) SWIG_fail;
19017 temp1 = true;
19018 }
19019 }
19020 if (obj1) {
19021 {
19022 arg2 = (int)(SWIG_As_int(obj1));
19023 if (SWIG_arg_fail(2)) SWIG_fail;
19024 }
19025 }
19026 if (obj2) {
19027 {
19028 arg3 = (int)(SWIG_As_int(obj2));
19029 if (SWIG_arg_fail(3)) SWIG_fail;
19030 }
19031 }
19032 if (obj3) {
19033 {
19034 arg4 = wxString_in_helper(obj3);
19035 if (arg4 == NULL) SWIG_fail;
19036 temp4 = true;
19037 }
19038 }
19039 {
19040 if (!wxPyCheckForApp()) SWIG_fail;
19041 PyThreadState* __tstate = wxPyBeginAllowThreads();
19042 result = (wxMetaFileDC *)new wxMetaFileDC((wxString const &)*arg1,arg2,arg3,(wxString const &)*arg4);
19043
19044 wxPyEndAllowThreads(__tstate);
19045 if (PyErr_Occurred()) SWIG_fail;
19046 }
19047 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFileDC, 1);
19048 {
19049 if (temp1)
19050 delete arg1;
19051 }
19052 {
19053 if (temp4)
19054 delete arg4;
19055 }
19056 return resultobj;
19057 fail:
19058 {
19059 if (temp1)
19060 delete arg1;
19061 }
19062 {
19063 if (temp4)
19064 delete arg4;
19065 }
19066 return NULL;
19067 }
19068
19069
19070 static PyObject *_wrap_MetaFileDC_Close(PyObject *, PyObject *args, PyObject *kwargs) {
19071 PyObject *resultobj;
19072 wxMetaFileDC *arg1 = (wxMetaFileDC *) 0 ;
19073 wxMetaFile *result;
19074 PyObject * obj0 = 0 ;
19075 char *kwnames[] = {
19076 (char *) "self", NULL
19077 };
19078
19079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFileDC_Close",kwnames,&obj0)) goto fail;
19080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFileDC, SWIG_POINTER_EXCEPTION | 0);
19081 if (SWIG_arg_fail(1)) SWIG_fail;
19082 {
19083 PyThreadState* __tstate = wxPyBeginAllowThreads();
19084 result = (wxMetaFile *)(arg1)->Close();
19085
19086 wxPyEndAllowThreads(__tstate);
19087 if (PyErr_Occurred()) SWIG_fail;
19088 }
19089 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFile, 0);
19090 return resultobj;
19091 fail:
19092 return NULL;
19093 }
19094
19095
19096 static PyObject * MetaFileDC_swigregister(PyObject *, PyObject *args) {
19097 PyObject *obj;
19098 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19099 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFileDC, obj);
19100 Py_INCREF(obj);
19101 return Py_BuildValue((char *)"");
19102 }
19103 static PyObject *_wrap_new_PrinterDC(PyObject *, PyObject *args, PyObject *kwargs) {
19104 PyObject *resultobj;
19105 wxPrintData *arg1 = 0 ;
19106 wxPrinterDC *result;
19107 PyObject * obj0 = 0 ;
19108 char *kwnames[] = {
19109 (char *) "printData", NULL
19110 };
19111
19112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PrinterDC",kwnames,&obj0)) goto fail;
19113 {
19114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
19115 if (SWIG_arg_fail(1)) SWIG_fail;
19116 if (arg1 == NULL) {
19117 SWIG_null_ref("wxPrintData");
19118 }
19119 if (SWIG_arg_fail(1)) SWIG_fail;
19120 }
19121 {
19122 if (!wxPyCheckForApp()) SWIG_fail;
19123 PyThreadState* __tstate = wxPyBeginAllowThreads();
19124 result = (wxPrinterDC *)new wxPrinterDC((wxPrintData const &)*arg1);
19125
19126 wxPyEndAllowThreads(__tstate);
19127 if (PyErr_Occurred()) SWIG_fail;
19128 }
19129 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrinterDC, 1);
19130 return resultobj;
19131 fail:
19132 return NULL;
19133 }
19134
19135
19136 static PyObject * PrinterDC_swigregister(PyObject *, PyObject *args) {
19137 PyObject *obj;
19138 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19139 SWIG_TypeClientData(SWIGTYPE_p_wxPrinterDC, obj);
19140 Py_INCREF(obj);
19141 return Py_BuildValue((char *)"");
19142 }
19143 static PyObject *_wrap_new_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
19144 PyObject *resultobj;
19145 int arg1 ;
19146 int arg2 ;
19147 int arg3 = (int) true ;
19148 int arg4 = (int) 1 ;
19149 wxImageList *result;
19150 PyObject * obj0 = 0 ;
19151 PyObject * obj1 = 0 ;
19152 PyObject * obj2 = 0 ;
19153 PyObject * obj3 = 0 ;
19154 char *kwnames[] = {
19155 (char *) "width",(char *) "height",(char *) "mask",(char *) "initialCount", NULL
19156 };
19157
19158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_ImageList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19159 {
19160 arg1 = (int)(SWIG_As_int(obj0));
19161 if (SWIG_arg_fail(1)) SWIG_fail;
19162 }
19163 {
19164 arg2 = (int)(SWIG_As_int(obj1));
19165 if (SWIG_arg_fail(2)) SWIG_fail;
19166 }
19167 if (obj2) {
19168 {
19169 arg3 = (int)(SWIG_As_int(obj2));
19170 if (SWIG_arg_fail(3)) SWIG_fail;
19171 }
19172 }
19173 if (obj3) {
19174 {
19175 arg4 = (int)(SWIG_As_int(obj3));
19176 if (SWIG_arg_fail(4)) SWIG_fail;
19177 }
19178 }
19179 {
19180 if (!wxPyCheckForApp()) SWIG_fail;
19181 PyThreadState* __tstate = wxPyBeginAllowThreads();
19182 result = (wxImageList *)new wxImageList(arg1,arg2,arg3,arg4);
19183
19184 wxPyEndAllowThreads(__tstate);
19185 if (PyErr_Occurred()) SWIG_fail;
19186 }
19187 {
19188 resultobj = wxPyMake_wxObject(result, 1);
19189 }
19190 return resultobj;
19191 fail:
19192 return NULL;
19193 }
19194
19195
19196 static PyObject *_wrap_delete_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
19197 PyObject *resultobj;
19198 wxImageList *arg1 = (wxImageList *) 0 ;
19199 PyObject * obj0 = 0 ;
19200 char *kwnames[] = {
19201 (char *) "self", NULL
19202 };
19203
19204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ImageList",kwnames,&obj0)) goto fail;
19205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19206 if (SWIG_arg_fail(1)) SWIG_fail;
19207 {
19208 PyThreadState* __tstate = wxPyBeginAllowThreads();
19209 delete arg1;
19210
19211 wxPyEndAllowThreads(__tstate);
19212 if (PyErr_Occurred()) SWIG_fail;
19213 }
19214 Py_INCREF(Py_None); resultobj = Py_None;
19215 return resultobj;
19216 fail:
19217 return NULL;
19218 }
19219
19220
19221 static PyObject *_wrap_ImageList_Add(PyObject *, PyObject *args, PyObject *kwargs) {
19222 PyObject *resultobj;
19223 wxImageList *arg1 = (wxImageList *) 0 ;
19224 wxBitmap *arg2 = 0 ;
19225 wxBitmap const &arg3_defvalue = wxNullBitmap ;
19226 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
19227 int result;
19228 PyObject * obj0 = 0 ;
19229 PyObject * obj1 = 0 ;
19230 PyObject * obj2 = 0 ;
19231 char *kwnames[] = {
19232 (char *) "self",(char *) "bitmap",(char *) "mask", NULL
19233 };
19234
19235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ImageList_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
19236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19237 if (SWIG_arg_fail(1)) SWIG_fail;
19238 {
19239 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19240 if (SWIG_arg_fail(2)) SWIG_fail;
19241 if (arg2 == NULL) {
19242 SWIG_null_ref("wxBitmap");
19243 }
19244 if (SWIG_arg_fail(2)) SWIG_fail;
19245 }
19246 if (obj2) {
19247 {
19248 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19249 if (SWIG_arg_fail(3)) SWIG_fail;
19250 if (arg3 == NULL) {
19251 SWIG_null_ref("wxBitmap");
19252 }
19253 if (SWIG_arg_fail(3)) SWIG_fail;
19254 }
19255 }
19256 {
19257 PyThreadState* __tstate = wxPyBeginAllowThreads();
19258 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
19259
19260 wxPyEndAllowThreads(__tstate);
19261 if (PyErr_Occurred()) SWIG_fail;
19262 }
19263 {
19264 resultobj = SWIG_From_int((int)(result));
19265 }
19266 return resultobj;
19267 fail:
19268 return NULL;
19269 }
19270
19271
19272 static PyObject *_wrap_ImageList_AddWithColourMask(PyObject *, PyObject *args, PyObject *kwargs) {
19273 PyObject *resultobj;
19274 wxImageList *arg1 = (wxImageList *) 0 ;
19275 wxBitmap *arg2 = 0 ;
19276 wxColour *arg3 = 0 ;
19277 int result;
19278 wxColour temp3 ;
19279 PyObject * obj0 = 0 ;
19280 PyObject * obj1 = 0 ;
19281 PyObject * obj2 = 0 ;
19282 char *kwnames[] = {
19283 (char *) "self",(char *) "bitmap",(char *) "maskColour", NULL
19284 };
19285
19286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_AddWithColourMask",kwnames,&obj0,&obj1,&obj2)) goto fail;
19287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19288 if (SWIG_arg_fail(1)) SWIG_fail;
19289 {
19290 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19291 if (SWIG_arg_fail(2)) SWIG_fail;
19292 if (arg2 == NULL) {
19293 SWIG_null_ref("wxBitmap");
19294 }
19295 if (SWIG_arg_fail(2)) SWIG_fail;
19296 }
19297 {
19298 arg3 = &temp3;
19299 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
19300 }
19301 {
19302 PyThreadState* __tstate = wxPyBeginAllowThreads();
19303 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxColour const &)*arg3);
19304
19305 wxPyEndAllowThreads(__tstate);
19306 if (PyErr_Occurred()) SWIG_fail;
19307 }
19308 {
19309 resultobj = SWIG_From_int((int)(result));
19310 }
19311 return resultobj;
19312 fail:
19313 return NULL;
19314 }
19315
19316
19317 static PyObject *_wrap_ImageList_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
19318 PyObject *resultobj;
19319 wxImageList *arg1 = (wxImageList *) 0 ;
19320 wxIcon *arg2 = 0 ;
19321 int result;
19322 PyObject * obj0 = 0 ;
19323 PyObject * obj1 = 0 ;
19324 char *kwnames[] = {
19325 (char *) "self",(char *) "icon", NULL
19326 };
19327
19328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_AddIcon",kwnames,&obj0,&obj1)) goto fail;
19329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19330 if (SWIG_arg_fail(1)) SWIG_fail;
19331 {
19332 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
19333 if (SWIG_arg_fail(2)) SWIG_fail;
19334 if (arg2 == NULL) {
19335 SWIG_null_ref("wxIcon");
19336 }
19337 if (SWIG_arg_fail(2)) SWIG_fail;
19338 }
19339 {
19340 PyThreadState* __tstate = wxPyBeginAllowThreads();
19341 result = (int)(arg1)->Add((wxIcon const &)*arg2);
19342
19343 wxPyEndAllowThreads(__tstate);
19344 if (PyErr_Occurred()) SWIG_fail;
19345 }
19346 {
19347 resultobj = SWIG_From_int((int)(result));
19348 }
19349 return resultobj;
19350 fail:
19351 return NULL;
19352 }
19353
19354
19355 static PyObject *_wrap_ImageList_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
19356 PyObject *resultobj;
19357 wxImageList *arg1 = (wxImageList *) 0 ;
19358 int arg2 ;
19359 SwigValueWrapper<wxBitmap > result;
19360 PyObject * obj0 = 0 ;
19361 PyObject * obj1 = 0 ;
19362 char *kwnames[] = {
19363 (char *) "self",(char *) "index", NULL
19364 };
19365
19366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetBitmap",kwnames,&obj0,&obj1)) goto fail;
19367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19368 if (SWIG_arg_fail(1)) SWIG_fail;
19369 {
19370 arg2 = (int)(SWIG_As_int(obj1));
19371 if (SWIG_arg_fail(2)) SWIG_fail;
19372 }
19373 {
19374 PyThreadState* __tstate = wxPyBeginAllowThreads();
19375 result = ((wxImageList const *)arg1)->GetBitmap(arg2);
19376
19377 wxPyEndAllowThreads(__tstate);
19378 if (PyErr_Occurred()) SWIG_fail;
19379 }
19380 {
19381 wxBitmap * resultptr;
19382 resultptr = new wxBitmap((wxBitmap &)(result));
19383 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
19384 }
19385 return resultobj;
19386 fail:
19387 return NULL;
19388 }
19389
19390
19391 static PyObject *_wrap_ImageList_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
19392 PyObject *resultobj;
19393 wxImageList *arg1 = (wxImageList *) 0 ;
19394 int arg2 ;
19395 wxIcon result;
19396 PyObject * obj0 = 0 ;
19397 PyObject * obj1 = 0 ;
19398 char *kwnames[] = {
19399 (char *) "self",(char *) "index", NULL
19400 };
19401
19402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetIcon",kwnames,&obj0,&obj1)) goto fail;
19403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19404 if (SWIG_arg_fail(1)) SWIG_fail;
19405 {
19406 arg2 = (int)(SWIG_As_int(obj1));
19407 if (SWIG_arg_fail(2)) SWIG_fail;
19408 }
19409 {
19410 PyThreadState* __tstate = wxPyBeginAllowThreads();
19411 result = ((wxImageList const *)arg1)->GetIcon(arg2);
19412
19413 wxPyEndAllowThreads(__tstate);
19414 if (PyErr_Occurred()) SWIG_fail;
19415 }
19416 {
19417 wxIcon * resultptr;
19418 resultptr = new wxIcon((wxIcon &)(result));
19419 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
19420 }
19421 return resultobj;
19422 fail:
19423 return NULL;
19424 }
19425
19426
19427 static PyObject *_wrap_ImageList_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
19428 PyObject *resultobj;
19429 wxImageList *arg1 = (wxImageList *) 0 ;
19430 int arg2 ;
19431 wxBitmap *arg3 = 0 ;
19432 wxBitmap const &arg4_defvalue = wxNullBitmap ;
19433 wxBitmap *arg4 = (wxBitmap *) &arg4_defvalue ;
19434 bool result;
19435 PyObject * obj0 = 0 ;
19436 PyObject * obj1 = 0 ;
19437 PyObject * obj2 = 0 ;
19438 PyObject * obj3 = 0 ;
19439 char *kwnames[] = {
19440 (char *) "self",(char *) "index",(char *) "bitmap",(char *) "mask", NULL
19441 };
19442
19443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ImageList_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19445 if (SWIG_arg_fail(1)) SWIG_fail;
19446 {
19447 arg2 = (int)(SWIG_As_int(obj1));
19448 if (SWIG_arg_fail(2)) SWIG_fail;
19449 }
19450 {
19451 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19452 if (SWIG_arg_fail(3)) SWIG_fail;
19453 if (arg3 == NULL) {
19454 SWIG_null_ref("wxBitmap");
19455 }
19456 if (SWIG_arg_fail(3)) SWIG_fail;
19457 }
19458 if (obj3) {
19459 {
19460 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19461 if (SWIG_arg_fail(4)) SWIG_fail;
19462 if (arg4 == NULL) {
19463 SWIG_null_ref("wxBitmap");
19464 }
19465 if (SWIG_arg_fail(4)) SWIG_fail;
19466 }
19467 }
19468 {
19469 PyThreadState* __tstate = wxPyBeginAllowThreads();
19470 result = (bool)(arg1)->Replace(arg2,(wxBitmap const &)*arg3,(wxBitmap const &)*arg4);
19471
19472 wxPyEndAllowThreads(__tstate);
19473 if (PyErr_Occurred()) SWIG_fail;
19474 }
19475 {
19476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19477 }
19478 return resultobj;
19479 fail:
19480 return NULL;
19481 }
19482
19483
19484 static PyObject *_wrap_ImageList_Draw(PyObject *, PyObject *args, PyObject *kwargs) {
19485 PyObject *resultobj;
19486 wxImageList *arg1 = (wxImageList *) 0 ;
19487 int arg2 ;
19488 wxDC *arg3 = 0 ;
19489 int arg4 ;
19490 int arg5 ;
19491 int arg6 = (int) wxIMAGELIST_DRAW_NORMAL ;
19492 bool arg7 = (bool) (bool)false ;
19493 bool result;
19494 PyObject * obj0 = 0 ;
19495 PyObject * obj1 = 0 ;
19496 PyObject * obj2 = 0 ;
19497 PyObject * obj3 = 0 ;
19498 PyObject * obj4 = 0 ;
19499 PyObject * obj5 = 0 ;
19500 PyObject * obj6 = 0 ;
19501 char *kwnames[] = {
19502 (char *) "self",(char *) "index",(char *) "dc",(char *) "x",(char *) "x",(char *) "flags",(char *) "solidBackground", NULL
19503 };
19504
19505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OO:ImageList_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19507 if (SWIG_arg_fail(1)) SWIG_fail;
19508 {
19509 arg2 = (int)(SWIG_As_int(obj1));
19510 if (SWIG_arg_fail(2)) SWIG_fail;
19511 }
19512 {
19513 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19514 if (SWIG_arg_fail(3)) SWIG_fail;
19515 if (arg3 == NULL) {
19516 SWIG_null_ref("wxDC");
19517 }
19518 if (SWIG_arg_fail(3)) SWIG_fail;
19519 }
19520 {
19521 arg4 = (int)(SWIG_As_int(obj3));
19522 if (SWIG_arg_fail(4)) SWIG_fail;
19523 }
19524 {
19525 arg5 = (int)(SWIG_As_int(obj4));
19526 if (SWIG_arg_fail(5)) SWIG_fail;
19527 }
19528 if (obj5) {
19529 {
19530 arg6 = (int)(SWIG_As_int(obj5));
19531 if (SWIG_arg_fail(6)) SWIG_fail;
19532 }
19533 }
19534 if (obj6) {
19535 {
19536 arg7 = (bool const)(SWIG_As_bool(obj6));
19537 if (SWIG_arg_fail(7)) SWIG_fail;
19538 }
19539 }
19540 {
19541 PyThreadState* __tstate = wxPyBeginAllowThreads();
19542 result = (bool)(arg1)->Draw(arg2,*arg3,arg4,arg5,arg6,arg7);
19543
19544 wxPyEndAllowThreads(__tstate);
19545 if (PyErr_Occurred()) SWIG_fail;
19546 }
19547 {
19548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19549 }
19550 return resultobj;
19551 fail:
19552 return NULL;
19553 }
19554
19555
19556 static PyObject *_wrap_ImageList_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
19557 PyObject *resultobj;
19558 wxImageList *arg1 = (wxImageList *) 0 ;
19559 int result;
19560 PyObject * obj0 = 0 ;
19561 char *kwnames[] = {
19562 (char *) "self", NULL
19563 };
19564
19565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_GetImageCount",kwnames,&obj0)) goto fail;
19566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19567 if (SWIG_arg_fail(1)) SWIG_fail;
19568 {
19569 PyThreadState* __tstate = wxPyBeginAllowThreads();
19570 result = (int)(arg1)->GetImageCount();
19571
19572 wxPyEndAllowThreads(__tstate);
19573 if (PyErr_Occurred()) SWIG_fail;
19574 }
19575 {
19576 resultobj = SWIG_From_int((int)(result));
19577 }
19578 return resultobj;
19579 fail:
19580 return NULL;
19581 }
19582
19583
19584 static PyObject *_wrap_ImageList_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
19585 PyObject *resultobj;
19586 wxImageList *arg1 = (wxImageList *) 0 ;
19587 int arg2 ;
19588 bool result;
19589 PyObject * obj0 = 0 ;
19590 PyObject * obj1 = 0 ;
19591 char *kwnames[] = {
19592 (char *) "self",(char *) "index", NULL
19593 };
19594
19595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_Remove",kwnames,&obj0,&obj1)) goto fail;
19596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19597 if (SWIG_arg_fail(1)) SWIG_fail;
19598 {
19599 arg2 = (int)(SWIG_As_int(obj1));
19600 if (SWIG_arg_fail(2)) SWIG_fail;
19601 }
19602 {
19603 PyThreadState* __tstate = wxPyBeginAllowThreads();
19604 result = (bool)(arg1)->Remove(arg2);
19605
19606 wxPyEndAllowThreads(__tstate);
19607 if (PyErr_Occurred()) SWIG_fail;
19608 }
19609 {
19610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19611 }
19612 return resultobj;
19613 fail:
19614 return NULL;
19615 }
19616
19617
19618 static PyObject *_wrap_ImageList_RemoveAll(PyObject *, PyObject *args, PyObject *kwargs) {
19619 PyObject *resultobj;
19620 wxImageList *arg1 = (wxImageList *) 0 ;
19621 bool result;
19622 PyObject * obj0 = 0 ;
19623 char *kwnames[] = {
19624 (char *) "self", NULL
19625 };
19626
19627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_RemoveAll",kwnames,&obj0)) goto fail;
19628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19629 if (SWIG_arg_fail(1)) SWIG_fail;
19630 {
19631 PyThreadState* __tstate = wxPyBeginAllowThreads();
19632 result = (bool)(arg1)->RemoveAll();
19633
19634 wxPyEndAllowThreads(__tstate);
19635 if (PyErr_Occurred()) SWIG_fail;
19636 }
19637 {
19638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19639 }
19640 return resultobj;
19641 fail:
19642 return NULL;
19643 }
19644
19645
19646 static PyObject *_wrap_ImageList_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19647 PyObject *resultobj;
19648 wxImageList *arg1 = (wxImageList *) 0 ;
19649 int arg2 ;
19650 int *arg3 = 0 ;
19651 int *arg4 = 0 ;
19652 int temp3 ;
19653 int res3 = 0 ;
19654 int temp4 ;
19655 int res4 = 0 ;
19656 PyObject * obj0 = 0 ;
19657 PyObject * obj1 = 0 ;
19658 char *kwnames[] = {
19659 (char *) "self",(char *) "index", NULL
19660 };
19661
19662 arg3 = &temp3; res3 = SWIG_NEWOBJ;
19663 arg4 = &temp4; res4 = SWIG_NEWOBJ;
19664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetSize",kwnames,&obj0,&obj1)) goto fail;
19665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19666 if (SWIG_arg_fail(1)) SWIG_fail;
19667 {
19668 arg2 = (int)(SWIG_As_int(obj1));
19669 if (SWIG_arg_fail(2)) SWIG_fail;
19670 }
19671 {
19672 PyThreadState* __tstate = wxPyBeginAllowThreads();
19673 (arg1)->GetSize(arg2,*arg3,*arg4);
19674
19675 wxPyEndAllowThreads(__tstate);
19676 if (PyErr_Occurred()) SWIG_fail;
19677 }
19678 Py_INCREF(Py_None); resultobj = Py_None;
19679 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
19680 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
19681 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
19682 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
19683 return resultobj;
19684 fail:
19685 return NULL;
19686 }
19687
19688
19689 static PyObject * ImageList_swigregister(PyObject *, PyObject *args) {
19690 PyObject *obj;
19691 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19692 SWIG_TypeClientData(SWIGTYPE_p_wxImageList, obj);
19693 Py_INCREF(obj);
19694 return Py_BuildValue((char *)"");
19695 }
19696 static int _wrap_NORMAL_FONT_set(PyObject *) {
19697 PyErr_SetString(PyExc_TypeError,"Variable NORMAL_FONT is read-only.");
19698 return 1;
19699 }
19700
19701
19702 static PyObject *_wrap_NORMAL_FONT_get(void) {
19703 PyObject *pyobj;
19704
19705 pyobj = SWIG_NewPointerObj((void *)(wxNORMAL_FONT), SWIGTYPE_p_wxFont, 0);
19706 return pyobj;
19707 }
19708
19709
19710 static int _wrap_SMALL_FONT_set(PyObject *) {
19711 PyErr_SetString(PyExc_TypeError,"Variable SMALL_FONT is read-only.");
19712 return 1;
19713 }
19714
19715
19716 static PyObject *_wrap_SMALL_FONT_get(void) {
19717 PyObject *pyobj;
19718
19719 pyobj = SWIG_NewPointerObj((void *)(wxSMALL_FONT), SWIGTYPE_p_wxFont, 0);
19720 return pyobj;
19721 }
19722
19723
19724 static int _wrap_ITALIC_FONT_set(PyObject *) {
19725 PyErr_SetString(PyExc_TypeError,"Variable ITALIC_FONT is read-only.");
19726 return 1;
19727 }
19728
19729
19730 static PyObject *_wrap_ITALIC_FONT_get(void) {
19731 PyObject *pyobj;
19732
19733 pyobj = SWIG_NewPointerObj((void *)(wxITALIC_FONT), SWIGTYPE_p_wxFont, 0);
19734 return pyobj;
19735 }
19736
19737
19738 static int _wrap_SWISS_FONT_set(PyObject *) {
19739 PyErr_SetString(PyExc_TypeError,"Variable SWISS_FONT is read-only.");
19740 return 1;
19741 }
19742
19743
19744 static PyObject *_wrap_SWISS_FONT_get(void) {
19745 PyObject *pyobj;
19746
19747 pyobj = SWIG_NewPointerObj((void *)(wxSWISS_FONT), SWIGTYPE_p_wxFont, 0);
19748 return pyobj;
19749 }
19750
19751
19752 static int _wrap_RED_PEN_set(PyObject *) {
19753 PyErr_SetString(PyExc_TypeError,"Variable RED_PEN is read-only.");
19754 return 1;
19755 }
19756
19757
19758 static PyObject *_wrap_RED_PEN_get(void) {
19759 PyObject *pyobj;
19760
19761 pyobj = SWIG_NewPointerObj((void *)(wxRED_PEN), SWIGTYPE_p_wxPen, 0);
19762 return pyobj;
19763 }
19764
19765
19766 static int _wrap_CYAN_PEN_set(PyObject *) {
19767 PyErr_SetString(PyExc_TypeError,"Variable CYAN_PEN is read-only.");
19768 return 1;
19769 }
19770
19771
19772 static PyObject *_wrap_CYAN_PEN_get(void) {
19773 PyObject *pyobj;
19774
19775 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_PEN), SWIGTYPE_p_wxPen, 0);
19776 return pyobj;
19777 }
19778
19779
19780 static int _wrap_GREEN_PEN_set(PyObject *) {
19781 PyErr_SetString(PyExc_TypeError,"Variable GREEN_PEN is read-only.");
19782 return 1;
19783 }
19784
19785
19786 static PyObject *_wrap_GREEN_PEN_get(void) {
19787 PyObject *pyobj;
19788
19789 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_PEN), SWIGTYPE_p_wxPen, 0);
19790 return pyobj;
19791 }
19792
19793
19794 static int _wrap_BLACK_PEN_set(PyObject *) {
19795 PyErr_SetString(PyExc_TypeError,"Variable BLACK_PEN is read-only.");
19796 return 1;
19797 }
19798
19799
19800 static PyObject *_wrap_BLACK_PEN_get(void) {
19801 PyObject *pyobj;
19802
19803 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_PEN), SWIGTYPE_p_wxPen, 0);
19804 return pyobj;
19805 }
19806
19807
19808 static int _wrap_WHITE_PEN_set(PyObject *) {
19809 PyErr_SetString(PyExc_TypeError,"Variable WHITE_PEN is read-only.");
19810 return 1;
19811 }
19812
19813
19814 static PyObject *_wrap_WHITE_PEN_get(void) {
19815 PyObject *pyobj;
19816
19817 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_PEN), SWIGTYPE_p_wxPen, 0);
19818 return pyobj;
19819 }
19820
19821
19822 static int _wrap_TRANSPARENT_PEN_set(PyObject *) {
19823 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_PEN is read-only.");
19824 return 1;
19825 }
19826
19827
19828 static PyObject *_wrap_TRANSPARENT_PEN_get(void) {
19829 PyObject *pyobj;
19830
19831 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_PEN), SWIGTYPE_p_wxPen, 0);
19832 return pyobj;
19833 }
19834
19835
19836 static int _wrap_BLACK_DASHED_PEN_set(PyObject *) {
19837 PyErr_SetString(PyExc_TypeError,"Variable BLACK_DASHED_PEN is read-only.");
19838 return 1;
19839 }
19840
19841
19842 static PyObject *_wrap_BLACK_DASHED_PEN_get(void) {
19843 PyObject *pyobj;
19844
19845 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_DASHED_PEN), SWIGTYPE_p_wxPen, 0);
19846 return pyobj;
19847 }
19848
19849
19850 static int _wrap_GREY_PEN_set(PyObject *) {
19851 PyErr_SetString(PyExc_TypeError,"Variable GREY_PEN is read-only.");
19852 return 1;
19853 }
19854
19855
19856 static PyObject *_wrap_GREY_PEN_get(void) {
19857 PyObject *pyobj;
19858
19859 pyobj = SWIG_NewPointerObj((void *)(wxGREY_PEN), SWIGTYPE_p_wxPen, 0);
19860 return pyobj;
19861 }
19862
19863
19864 static int _wrap_MEDIUM_GREY_PEN_set(PyObject *) {
19865 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_PEN is read-only.");
19866 return 1;
19867 }
19868
19869
19870 static PyObject *_wrap_MEDIUM_GREY_PEN_get(void) {
19871 PyObject *pyobj;
19872
19873 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_PEN), SWIGTYPE_p_wxPen, 0);
19874 return pyobj;
19875 }
19876
19877
19878 static int _wrap_LIGHT_GREY_PEN_set(PyObject *) {
19879 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_PEN is read-only.");
19880 return 1;
19881 }
19882
19883
19884 static PyObject *_wrap_LIGHT_GREY_PEN_get(void) {
19885 PyObject *pyobj;
19886
19887 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_PEN), SWIGTYPE_p_wxPen, 0);
19888 return pyobj;
19889 }
19890
19891
19892 static int _wrap_BLUE_BRUSH_set(PyObject *) {
19893 PyErr_SetString(PyExc_TypeError,"Variable BLUE_BRUSH is read-only.");
19894 return 1;
19895 }
19896
19897
19898 static PyObject *_wrap_BLUE_BRUSH_get(void) {
19899 PyObject *pyobj;
19900
19901 pyobj = SWIG_NewPointerObj((void *)(wxBLUE_BRUSH), SWIGTYPE_p_wxBrush, 0);
19902 return pyobj;
19903 }
19904
19905
19906 static int _wrap_GREEN_BRUSH_set(PyObject *) {
19907 PyErr_SetString(PyExc_TypeError,"Variable GREEN_BRUSH is read-only.");
19908 return 1;
19909 }
19910
19911
19912 static PyObject *_wrap_GREEN_BRUSH_get(void) {
19913 PyObject *pyobj;
19914
19915 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_BRUSH), SWIGTYPE_p_wxBrush, 0);
19916 return pyobj;
19917 }
19918
19919
19920 static int _wrap_WHITE_BRUSH_set(PyObject *) {
19921 PyErr_SetString(PyExc_TypeError,"Variable WHITE_BRUSH is read-only.");
19922 return 1;
19923 }
19924
19925
19926 static PyObject *_wrap_WHITE_BRUSH_get(void) {
19927 PyObject *pyobj;
19928
19929 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_BRUSH), SWIGTYPE_p_wxBrush, 0);
19930 return pyobj;
19931 }
19932
19933
19934 static int _wrap_BLACK_BRUSH_set(PyObject *) {
19935 PyErr_SetString(PyExc_TypeError,"Variable BLACK_BRUSH is read-only.");
19936 return 1;
19937 }
19938
19939
19940 static PyObject *_wrap_BLACK_BRUSH_get(void) {
19941 PyObject *pyobj;
19942
19943 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_BRUSH), SWIGTYPE_p_wxBrush, 0);
19944 return pyobj;
19945 }
19946
19947
19948 static int _wrap_TRANSPARENT_BRUSH_set(PyObject *) {
19949 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_BRUSH is read-only.");
19950 return 1;
19951 }
19952
19953
19954 static PyObject *_wrap_TRANSPARENT_BRUSH_get(void) {
19955 PyObject *pyobj;
19956
19957 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_BRUSH), SWIGTYPE_p_wxBrush, 0);
19958 return pyobj;
19959 }
19960
19961
19962 static int _wrap_CYAN_BRUSH_set(PyObject *) {
19963 PyErr_SetString(PyExc_TypeError,"Variable CYAN_BRUSH is read-only.");
19964 return 1;
19965 }
19966
19967
19968 static PyObject *_wrap_CYAN_BRUSH_get(void) {
19969 PyObject *pyobj;
19970
19971 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_BRUSH), SWIGTYPE_p_wxBrush, 0);
19972 return pyobj;
19973 }
19974
19975
19976 static int _wrap_RED_BRUSH_set(PyObject *) {
19977 PyErr_SetString(PyExc_TypeError,"Variable RED_BRUSH is read-only.");
19978 return 1;
19979 }
19980
19981
19982 static PyObject *_wrap_RED_BRUSH_get(void) {
19983 PyObject *pyobj;
19984
19985 pyobj = SWIG_NewPointerObj((void *)(wxRED_BRUSH), SWIGTYPE_p_wxBrush, 0);
19986 return pyobj;
19987 }
19988
19989
19990 static int _wrap_GREY_BRUSH_set(PyObject *) {
19991 PyErr_SetString(PyExc_TypeError,"Variable GREY_BRUSH is read-only.");
19992 return 1;
19993 }
19994
19995
19996 static PyObject *_wrap_GREY_BRUSH_get(void) {
19997 PyObject *pyobj;
19998
19999 pyobj = SWIG_NewPointerObj((void *)(wxGREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
20000 return pyobj;
20001 }
20002
20003
20004 static int _wrap_MEDIUM_GREY_BRUSH_set(PyObject *) {
20005 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_BRUSH is read-only.");
20006 return 1;
20007 }
20008
20009
20010 static PyObject *_wrap_MEDIUM_GREY_BRUSH_get(void) {
20011 PyObject *pyobj;
20012
20013 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
20014 return pyobj;
20015 }
20016
20017
20018 static int _wrap_LIGHT_GREY_BRUSH_set(PyObject *) {
20019 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_BRUSH is read-only.");
20020 return 1;
20021 }
20022
20023
20024 static PyObject *_wrap_LIGHT_GREY_BRUSH_get(void) {
20025 PyObject *pyobj;
20026
20027 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
20028 return pyobj;
20029 }
20030
20031
20032 static int _wrap_BLACK_set(PyObject *) {
20033 PyErr_SetString(PyExc_TypeError,"Variable BLACK is read-only.");
20034 return 1;
20035 }
20036
20037
20038 static PyObject *_wrap_BLACK_get(void) {
20039 PyObject *pyobj;
20040
20041 pyobj = SWIG_NewPointerObj((void *)(wxBLACK), SWIGTYPE_p_wxColour, 0);
20042 return pyobj;
20043 }
20044
20045
20046 static int _wrap_WHITE_set(PyObject *) {
20047 PyErr_SetString(PyExc_TypeError,"Variable WHITE is read-only.");
20048 return 1;
20049 }
20050
20051
20052 static PyObject *_wrap_WHITE_get(void) {
20053 PyObject *pyobj;
20054
20055 pyobj = SWIG_NewPointerObj((void *)(wxWHITE), SWIGTYPE_p_wxColour, 0);
20056 return pyobj;
20057 }
20058
20059
20060 static int _wrap_RED_set(PyObject *) {
20061 PyErr_SetString(PyExc_TypeError,"Variable RED is read-only.");
20062 return 1;
20063 }
20064
20065
20066 static PyObject *_wrap_RED_get(void) {
20067 PyObject *pyobj;
20068
20069 pyobj = SWIG_NewPointerObj((void *)(wxRED), SWIGTYPE_p_wxColour, 0);
20070 return pyobj;
20071 }
20072
20073
20074 static int _wrap_BLUE_set(PyObject *) {
20075 PyErr_SetString(PyExc_TypeError,"Variable BLUE is read-only.");
20076 return 1;
20077 }
20078
20079
20080 static PyObject *_wrap_BLUE_get(void) {
20081 PyObject *pyobj;
20082
20083 pyobj = SWIG_NewPointerObj((void *)(wxBLUE), SWIGTYPE_p_wxColour, 0);
20084 return pyobj;
20085 }
20086
20087
20088 static int _wrap_GREEN_set(PyObject *) {
20089 PyErr_SetString(PyExc_TypeError,"Variable GREEN is read-only.");
20090 return 1;
20091 }
20092
20093
20094 static PyObject *_wrap_GREEN_get(void) {
20095 PyObject *pyobj;
20096
20097 pyobj = SWIG_NewPointerObj((void *)(wxGREEN), SWIGTYPE_p_wxColour, 0);
20098 return pyobj;
20099 }
20100
20101
20102 static int _wrap_CYAN_set(PyObject *) {
20103 PyErr_SetString(PyExc_TypeError,"Variable CYAN is read-only.");
20104 return 1;
20105 }
20106
20107
20108 static PyObject *_wrap_CYAN_get(void) {
20109 PyObject *pyobj;
20110
20111 pyobj = SWIG_NewPointerObj((void *)(wxCYAN), SWIGTYPE_p_wxColour, 0);
20112 return pyobj;
20113 }
20114
20115
20116 static int _wrap_LIGHT_GREY_set(PyObject *) {
20117 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY is read-only.");
20118 return 1;
20119 }
20120
20121
20122 static PyObject *_wrap_LIGHT_GREY_get(void) {
20123 PyObject *pyobj;
20124
20125 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY), SWIGTYPE_p_wxColour, 0);
20126 return pyobj;
20127 }
20128
20129
20130 static int _wrap_STANDARD_CURSOR_set(PyObject *) {
20131 PyErr_SetString(PyExc_TypeError,"Variable STANDARD_CURSOR is read-only.");
20132 return 1;
20133 }
20134
20135
20136 static PyObject *_wrap_STANDARD_CURSOR_get(void) {
20137 PyObject *pyobj;
20138
20139 pyobj = SWIG_NewPointerObj((void *)(wxSTANDARD_CURSOR), SWIGTYPE_p_wxCursor, 0);
20140 return pyobj;
20141 }
20142
20143
20144 static int _wrap_HOURGLASS_CURSOR_set(PyObject *) {
20145 PyErr_SetString(PyExc_TypeError,"Variable HOURGLASS_CURSOR is read-only.");
20146 return 1;
20147 }
20148
20149
20150 static PyObject *_wrap_HOURGLASS_CURSOR_get(void) {
20151 PyObject *pyobj;
20152
20153 pyobj = SWIG_NewPointerObj((void *)(wxHOURGLASS_CURSOR), SWIGTYPE_p_wxCursor, 0);
20154 return pyobj;
20155 }
20156
20157
20158 static int _wrap_CROSS_CURSOR_set(PyObject *) {
20159 PyErr_SetString(PyExc_TypeError,"Variable CROSS_CURSOR is read-only.");
20160 return 1;
20161 }
20162
20163
20164 static PyObject *_wrap_CROSS_CURSOR_get(void) {
20165 PyObject *pyobj;
20166
20167 pyobj = SWIG_NewPointerObj((void *)(wxCROSS_CURSOR), SWIGTYPE_p_wxCursor, 0);
20168 return pyobj;
20169 }
20170
20171
20172 static int _wrap_NullBitmap_set(PyObject *) {
20173 PyErr_SetString(PyExc_TypeError,"Variable NullBitmap is read-only.");
20174 return 1;
20175 }
20176
20177
20178 static PyObject *_wrap_NullBitmap_get(void) {
20179 PyObject *pyobj;
20180
20181 pyobj = SWIG_NewPointerObj((void *)(&wxNullBitmap), SWIGTYPE_p_wxBitmap, 0);
20182 return pyobj;
20183 }
20184
20185
20186 static int _wrap_NullIcon_set(PyObject *) {
20187 PyErr_SetString(PyExc_TypeError,"Variable NullIcon is read-only.");
20188 return 1;
20189 }
20190
20191
20192 static PyObject *_wrap_NullIcon_get(void) {
20193 PyObject *pyobj;
20194
20195 pyobj = SWIG_NewPointerObj((void *)(&wxNullIcon), SWIGTYPE_p_wxIcon, 0);
20196 return pyobj;
20197 }
20198
20199
20200 static int _wrap_NullCursor_set(PyObject *) {
20201 PyErr_SetString(PyExc_TypeError,"Variable NullCursor is read-only.");
20202 return 1;
20203 }
20204
20205
20206 static PyObject *_wrap_NullCursor_get(void) {
20207 PyObject *pyobj;
20208
20209 pyobj = SWIG_NewPointerObj((void *)(&wxNullCursor), SWIGTYPE_p_wxCursor, 0);
20210 return pyobj;
20211 }
20212
20213
20214 static int _wrap_NullPen_set(PyObject *) {
20215 PyErr_SetString(PyExc_TypeError,"Variable NullPen is read-only.");
20216 return 1;
20217 }
20218
20219
20220 static PyObject *_wrap_NullPen_get(void) {
20221 PyObject *pyobj;
20222
20223 pyobj = SWIG_NewPointerObj((void *)(&wxNullPen), SWIGTYPE_p_wxPen, 0);
20224 return pyobj;
20225 }
20226
20227
20228 static int _wrap_NullBrush_set(PyObject *) {
20229 PyErr_SetString(PyExc_TypeError,"Variable NullBrush is read-only.");
20230 return 1;
20231 }
20232
20233
20234 static PyObject *_wrap_NullBrush_get(void) {
20235 PyObject *pyobj;
20236
20237 pyobj = SWIG_NewPointerObj((void *)(&wxNullBrush), SWIGTYPE_p_wxBrush, 0);
20238 return pyobj;
20239 }
20240
20241
20242 static int _wrap_NullPalette_set(PyObject *) {
20243 PyErr_SetString(PyExc_TypeError,"Variable NullPalette is read-only.");
20244 return 1;
20245 }
20246
20247
20248 static PyObject *_wrap_NullPalette_get(void) {
20249 PyObject *pyobj;
20250
20251 pyobj = SWIG_NewPointerObj((void *)(&wxNullPalette), SWIGTYPE_p_wxPalette, 0);
20252 return pyobj;
20253 }
20254
20255
20256 static int _wrap_NullFont_set(PyObject *) {
20257 PyErr_SetString(PyExc_TypeError,"Variable NullFont is read-only.");
20258 return 1;
20259 }
20260
20261
20262 static PyObject *_wrap_NullFont_get(void) {
20263 PyObject *pyobj;
20264
20265 pyobj = SWIG_NewPointerObj((void *)(&wxNullFont), SWIGTYPE_p_wxFont, 0);
20266 return pyobj;
20267 }
20268
20269
20270 static int _wrap_NullColour_set(PyObject *) {
20271 PyErr_SetString(PyExc_TypeError,"Variable NullColour is read-only.");
20272 return 1;
20273 }
20274
20275
20276 static PyObject *_wrap_NullColour_get(void) {
20277 PyObject *pyobj;
20278
20279 pyobj = SWIG_NewPointerObj((void *)(&wxNullColour), SWIGTYPE_p_wxColour, 0);
20280 return pyobj;
20281 }
20282
20283
20284 static PyObject *_wrap_PenList_AddPen(PyObject *, PyObject *args, PyObject *kwargs) {
20285 PyObject *resultobj;
20286 wxPenList *arg1 = (wxPenList *) 0 ;
20287 wxPen *arg2 = (wxPen *) 0 ;
20288 PyObject * obj0 = 0 ;
20289 PyObject * obj1 = 0 ;
20290 char *kwnames[] = {
20291 (char *) "self",(char *) "pen", NULL
20292 };
20293
20294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_AddPen",kwnames,&obj0,&obj1)) goto fail;
20295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
20296 if (SWIG_arg_fail(1)) SWIG_fail;
20297 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
20298 if (SWIG_arg_fail(2)) SWIG_fail;
20299 {
20300 PyThreadState* __tstate = wxPyBeginAllowThreads();
20301 (arg1)->AddPen(arg2);
20302
20303 wxPyEndAllowThreads(__tstate);
20304 if (PyErr_Occurred()) SWIG_fail;
20305 }
20306 Py_INCREF(Py_None); resultobj = Py_None;
20307 return resultobj;
20308 fail:
20309 return NULL;
20310 }
20311
20312
20313 static PyObject *_wrap_PenList_FindOrCreatePen(PyObject *, PyObject *args, PyObject *kwargs) {
20314 PyObject *resultobj;
20315 wxPenList *arg1 = (wxPenList *) 0 ;
20316 wxColour *arg2 = 0 ;
20317 int arg3 ;
20318 int arg4 ;
20319 wxPen *result;
20320 wxColour temp2 ;
20321 PyObject * obj0 = 0 ;
20322 PyObject * obj1 = 0 ;
20323 PyObject * obj2 = 0 ;
20324 PyObject * obj3 = 0 ;
20325 char *kwnames[] = {
20326 (char *) "self",(char *) "colour",(char *) "width",(char *) "style", NULL
20327 };
20328
20329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PenList_FindOrCreatePen",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
20331 if (SWIG_arg_fail(1)) SWIG_fail;
20332 {
20333 arg2 = &temp2;
20334 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20335 }
20336 {
20337 arg3 = (int)(SWIG_As_int(obj2));
20338 if (SWIG_arg_fail(3)) SWIG_fail;
20339 }
20340 {
20341 arg4 = (int)(SWIG_As_int(obj3));
20342 if (SWIG_arg_fail(4)) SWIG_fail;
20343 }
20344 {
20345 PyThreadState* __tstate = wxPyBeginAllowThreads();
20346 result = (wxPen *)(arg1)->FindOrCreatePen((wxColour const &)*arg2,arg3,arg4);
20347
20348 wxPyEndAllowThreads(__tstate);
20349 if (PyErr_Occurred()) SWIG_fail;
20350 }
20351 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 0);
20352 return resultobj;
20353 fail:
20354 return NULL;
20355 }
20356
20357
20358 static PyObject *_wrap_PenList_RemovePen(PyObject *, PyObject *args, PyObject *kwargs) {
20359 PyObject *resultobj;
20360 wxPenList *arg1 = (wxPenList *) 0 ;
20361 wxPen *arg2 = (wxPen *) 0 ;
20362 PyObject * obj0 = 0 ;
20363 PyObject * obj1 = 0 ;
20364 char *kwnames[] = {
20365 (char *) "self",(char *) "pen", NULL
20366 };
20367
20368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_RemovePen",kwnames,&obj0,&obj1)) goto fail;
20369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
20370 if (SWIG_arg_fail(1)) SWIG_fail;
20371 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
20372 if (SWIG_arg_fail(2)) SWIG_fail;
20373 {
20374 PyThreadState* __tstate = wxPyBeginAllowThreads();
20375 (arg1)->RemovePen(arg2);
20376
20377 wxPyEndAllowThreads(__tstate);
20378 if (PyErr_Occurred()) SWIG_fail;
20379 }
20380 Py_INCREF(Py_None); resultobj = Py_None;
20381 return resultobj;
20382 fail:
20383 return NULL;
20384 }
20385
20386
20387 static PyObject *_wrap_PenList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
20388 PyObject *resultobj;
20389 wxPenList *arg1 = (wxPenList *) 0 ;
20390 int result;
20391 PyObject * obj0 = 0 ;
20392 char *kwnames[] = {
20393 (char *) "self", NULL
20394 };
20395
20396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PenList_GetCount",kwnames,&obj0)) goto fail;
20397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
20398 if (SWIG_arg_fail(1)) SWIG_fail;
20399 {
20400 PyThreadState* __tstate = wxPyBeginAllowThreads();
20401 result = (int)(arg1)->GetCount();
20402
20403 wxPyEndAllowThreads(__tstate);
20404 if (PyErr_Occurred()) SWIG_fail;
20405 }
20406 {
20407 resultobj = SWIG_From_int((int)(result));
20408 }
20409 return resultobj;
20410 fail:
20411 return NULL;
20412 }
20413
20414
20415 static PyObject * PenList_swigregister(PyObject *, PyObject *args) {
20416 PyObject *obj;
20417 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20418 SWIG_TypeClientData(SWIGTYPE_p_wxPenList, obj);
20419 Py_INCREF(obj);
20420 return Py_BuildValue((char *)"");
20421 }
20422 static PyObject *_wrap_BrushList_AddBrush(PyObject *, PyObject *args, PyObject *kwargs) {
20423 PyObject *resultobj;
20424 wxBrushList *arg1 = (wxBrushList *) 0 ;
20425 wxBrush *arg2 = (wxBrush *) 0 ;
20426 PyObject * obj0 = 0 ;
20427 PyObject * obj1 = 0 ;
20428 char *kwnames[] = {
20429 (char *) "self",(char *) "brush", NULL
20430 };
20431
20432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_AddBrush",kwnames,&obj0,&obj1)) goto fail;
20433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
20434 if (SWIG_arg_fail(1)) SWIG_fail;
20435 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
20436 if (SWIG_arg_fail(2)) SWIG_fail;
20437 {
20438 PyThreadState* __tstate = wxPyBeginAllowThreads();
20439 (arg1)->AddBrush(arg2);
20440
20441 wxPyEndAllowThreads(__tstate);
20442 if (PyErr_Occurred()) SWIG_fail;
20443 }
20444 Py_INCREF(Py_None); resultobj = Py_None;
20445 return resultobj;
20446 fail:
20447 return NULL;
20448 }
20449
20450
20451 static PyObject *_wrap_BrushList_FindOrCreateBrush(PyObject *, PyObject *args, PyObject *kwargs) {
20452 PyObject *resultobj;
20453 wxBrushList *arg1 = (wxBrushList *) 0 ;
20454 wxColour *arg2 = 0 ;
20455 int arg3 = (int) wxSOLID ;
20456 wxBrush *result;
20457 wxColour temp2 ;
20458 PyObject * obj0 = 0 ;
20459 PyObject * obj1 = 0 ;
20460 PyObject * obj2 = 0 ;
20461 char *kwnames[] = {
20462 (char *) "self",(char *) "colour",(char *) "style", NULL
20463 };
20464
20465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:BrushList_FindOrCreateBrush",kwnames,&obj0,&obj1,&obj2)) goto fail;
20466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
20467 if (SWIG_arg_fail(1)) SWIG_fail;
20468 {
20469 arg2 = &temp2;
20470 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20471 }
20472 if (obj2) {
20473 {
20474 arg3 = (int)(SWIG_As_int(obj2));
20475 if (SWIG_arg_fail(3)) SWIG_fail;
20476 }
20477 }
20478 {
20479 PyThreadState* __tstate = wxPyBeginAllowThreads();
20480 result = (wxBrush *)(arg1)->FindOrCreateBrush((wxColour const &)*arg2,arg3);
20481
20482 wxPyEndAllowThreads(__tstate);
20483 if (PyErr_Occurred()) SWIG_fail;
20484 }
20485 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 0);
20486 return resultobj;
20487 fail:
20488 return NULL;
20489 }
20490
20491
20492 static PyObject *_wrap_BrushList_RemoveBrush(PyObject *, PyObject *args, PyObject *kwargs) {
20493 PyObject *resultobj;
20494 wxBrushList *arg1 = (wxBrushList *) 0 ;
20495 wxBrush *arg2 = (wxBrush *) 0 ;
20496 PyObject * obj0 = 0 ;
20497 PyObject * obj1 = 0 ;
20498 char *kwnames[] = {
20499 (char *) "self",(char *) "brush", NULL
20500 };
20501
20502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_RemoveBrush",kwnames,&obj0,&obj1)) goto fail;
20503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
20504 if (SWIG_arg_fail(1)) SWIG_fail;
20505 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
20506 if (SWIG_arg_fail(2)) SWIG_fail;
20507 {
20508 PyThreadState* __tstate = wxPyBeginAllowThreads();
20509 (arg1)->RemoveBrush(arg2);
20510
20511 wxPyEndAllowThreads(__tstate);
20512 if (PyErr_Occurred()) SWIG_fail;
20513 }
20514 Py_INCREF(Py_None); resultobj = Py_None;
20515 return resultobj;
20516 fail:
20517 return NULL;
20518 }
20519
20520
20521 static PyObject *_wrap_BrushList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
20522 PyObject *resultobj;
20523 wxBrushList *arg1 = (wxBrushList *) 0 ;
20524 int result;
20525 PyObject * obj0 = 0 ;
20526 char *kwnames[] = {
20527 (char *) "self", NULL
20528 };
20529
20530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BrushList_GetCount",kwnames,&obj0)) goto fail;
20531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
20532 if (SWIG_arg_fail(1)) SWIG_fail;
20533 {
20534 PyThreadState* __tstate = wxPyBeginAllowThreads();
20535 result = (int)(arg1)->GetCount();
20536
20537 wxPyEndAllowThreads(__tstate);
20538 if (PyErr_Occurred()) SWIG_fail;
20539 }
20540 {
20541 resultobj = SWIG_From_int((int)(result));
20542 }
20543 return resultobj;
20544 fail:
20545 return NULL;
20546 }
20547
20548
20549 static PyObject * BrushList_swigregister(PyObject *, PyObject *args) {
20550 PyObject *obj;
20551 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20552 SWIG_TypeClientData(SWIGTYPE_p_wxBrushList, obj);
20553 Py_INCREF(obj);
20554 return Py_BuildValue((char *)"");
20555 }
20556 static PyObject *_wrap_new_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
20557 PyObject *resultobj;
20558 wxColourDatabase *result;
20559 char *kwnames[] = {
20560 NULL
20561 };
20562
20563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ColourDatabase",kwnames)) goto fail;
20564 {
20565 if (!wxPyCheckForApp()) SWIG_fail;
20566 PyThreadState* __tstate = wxPyBeginAllowThreads();
20567 result = (wxColourDatabase *)new wxColourDatabase();
20568
20569 wxPyEndAllowThreads(__tstate);
20570 if (PyErr_Occurred()) SWIG_fail;
20571 }
20572 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColourDatabase, 1);
20573 return resultobj;
20574 fail:
20575 return NULL;
20576 }
20577
20578
20579 static PyObject *_wrap_delete_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
20580 PyObject *resultobj;
20581 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20582 PyObject * obj0 = 0 ;
20583 char *kwnames[] = {
20584 (char *) "self", NULL
20585 };
20586
20587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ColourDatabase",kwnames,&obj0)) goto fail;
20588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20589 if (SWIG_arg_fail(1)) SWIG_fail;
20590 {
20591 PyThreadState* __tstate = wxPyBeginAllowThreads();
20592 delete arg1;
20593
20594 wxPyEndAllowThreads(__tstate);
20595 if (PyErr_Occurred()) SWIG_fail;
20596 }
20597 Py_INCREF(Py_None); resultobj = Py_None;
20598 return resultobj;
20599 fail:
20600 return NULL;
20601 }
20602
20603
20604 static PyObject *_wrap_ColourDatabase_Find(PyObject *, PyObject *args, PyObject *kwargs) {
20605 PyObject *resultobj;
20606 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20607 wxString *arg2 = 0 ;
20608 wxColour result;
20609 bool temp2 = false ;
20610 PyObject * obj0 = 0 ;
20611 PyObject * obj1 = 0 ;
20612 char *kwnames[] = {
20613 (char *) "self",(char *) "name", NULL
20614 };
20615
20616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_Find",kwnames,&obj0,&obj1)) goto fail;
20617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20618 if (SWIG_arg_fail(1)) SWIG_fail;
20619 {
20620 arg2 = wxString_in_helper(obj1);
20621 if (arg2 == NULL) SWIG_fail;
20622 temp2 = true;
20623 }
20624 {
20625 PyThreadState* __tstate = wxPyBeginAllowThreads();
20626 result = ((wxColourDatabase const *)arg1)->Find((wxString const &)*arg2);
20627
20628 wxPyEndAllowThreads(__tstate);
20629 if (PyErr_Occurred()) SWIG_fail;
20630 }
20631 {
20632 wxColour * resultptr;
20633 resultptr = new wxColour((wxColour &)(result));
20634 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20635 }
20636 {
20637 if (temp2)
20638 delete arg2;
20639 }
20640 return resultobj;
20641 fail:
20642 {
20643 if (temp2)
20644 delete arg2;
20645 }
20646 return NULL;
20647 }
20648
20649
20650 static PyObject *_wrap_ColourDatabase_FindName(PyObject *, PyObject *args, PyObject *kwargs) {
20651 PyObject *resultobj;
20652 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20653 wxColour *arg2 = 0 ;
20654 wxString result;
20655 wxColour temp2 ;
20656 PyObject * obj0 = 0 ;
20657 PyObject * obj1 = 0 ;
20658 char *kwnames[] = {
20659 (char *) "self",(char *) "colour", NULL
20660 };
20661
20662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_FindName",kwnames,&obj0,&obj1)) goto fail;
20663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20664 if (SWIG_arg_fail(1)) SWIG_fail;
20665 {
20666 arg2 = &temp2;
20667 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20668 }
20669 {
20670 PyThreadState* __tstate = wxPyBeginAllowThreads();
20671 result = ((wxColourDatabase const *)arg1)->FindName((wxColour const &)*arg2);
20672
20673 wxPyEndAllowThreads(__tstate);
20674 if (PyErr_Occurred()) SWIG_fail;
20675 }
20676 {
20677 #if wxUSE_UNICODE
20678 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20679 #else
20680 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20681 #endif
20682 }
20683 return resultobj;
20684 fail:
20685 return NULL;
20686 }
20687
20688
20689 static PyObject *_wrap_ColourDatabase_AddColour(PyObject *, PyObject *args, PyObject *kwargs) {
20690 PyObject *resultobj;
20691 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20692 wxString *arg2 = 0 ;
20693 wxColour *arg3 = 0 ;
20694 bool temp2 = false ;
20695 wxColour temp3 ;
20696 PyObject * obj0 = 0 ;
20697 PyObject * obj1 = 0 ;
20698 PyObject * obj2 = 0 ;
20699 char *kwnames[] = {
20700 (char *) "self",(char *) "name",(char *) "colour", NULL
20701 };
20702
20703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ColourDatabase_AddColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
20704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20705 if (SWIG_arg_fail(1)) SWIG_fail;
20706 {
20707 arg2 = wxString_in_helper(obj1);
20708 if (arg2 == NULL) SWIG_fail;
20709 temp2 = true;
20710 }
20711 {
20712 arg3 = &temp3;
20713 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
20714 }
20715 {
20716 PyThreadState* __tstate = wxPyBeginAllowThreads();
20717 (arg1)->AddColour((wxString const &)*arg2,(wxColour const &)*arg3);
20718
20719 wxPyEndAllowThreads(__tstate);
20720 if (PyErr_Occurred()) SWIG_fail;
20721 }
20722 Py_INCREF(Py_None); resultobj = Py_None;
20723 {
20724 if (temp2)
20725 delete arg2;
20726 }
20727 return resultobj;
20728 fail:
20729 {
20730 if (temp2)
20731 delete arg2;
20732 }
20733 return NULL;
20734 }
20735
20736
20737 static PyObject *_wrap_ColourDatabase_Append(PyObject *, PyObject *args, PyObject *kwargs) {
20738 PyObject *resultobj;
20739 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20740 wxString *arg2 = 0 ;
20741 int arg3 ;
20742 int arg4 ;
20743 int arg5 ;
20744 bool temp2 = false ;
20745 PyObject * obj0 = 0 ;
20746 PyObject * obj1 = 0 ;
20747 PyObject * obj2 = 0 ;
20748 PyObject * obj3 = 0 ;
20749 PyObject * obj4 = 0 ;
20750 char *kwnames[] = {
20751 (char *) "self",(char *) "name",(char *) "red",(char *) "green",(char *) "blue", NULL
20752 };
20753
20754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:ColourDatabase_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20756 if (SWIG_arg_fail(1)) SWIG_fail;
20757 {
20758 arg2 = wxString_in_helper(obj1);
20759 if (arg2 == NULL) SWIG_fail;
20760 temp2 = true;
20761 }
20762 {
20763 arg3 = (int)(SWIG_As_int(obj2));
20764 if (SWIG_arg_fail(3)) SWIG_fail;
20765 }
20766 {
20767 arg4 = (int)(SWIG_As_int(obj3));
20768 if (SWIG_arg_fail(4)) SWIG_fail;
20769 }
20770 {
20771 arg5 = (int)(SWIG_As_int(obj4));
20772 if (SWIG_arg_fail(5)) SWIG_fail;
20773 }
20774 {
20775 PyThreadState* __tstate = wxPyBeginAllowThreads();
20776 wxColourDatabase_Append(arg1,(wxString const &)*arg2,arg3,arg4,arg5);
20777
20778 wxPyEndAllowThreads(__tstate);
20779 if (PyErr_Occurred()) SWIG_fail;
20780 }
20781 Py_INCREF(Py_None); resultobj = Py_None;
20782 {
20783 if (temp2)
20784 delete arg2;
20785 }
20786 return resultobj;
20787 fail:
20788 {
20789 if (temp2)
20790 delete arg2;
20791 }
20792 return NULL;
20793 }
20794
20795
20796 static PyObject * ColourDatabase_swigregister(PyObject *, PyObject *args) {
20797 PyObject *obj;
20798 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20799 SWIG_TypeClientData(SWIGTYPE_p_wxColourDatabase, obj);
20800 Py_INCREF(obj);
20801 return Py_BuildValue((char *)"");
20802 }
20803 static PyObject *_wrap_FontList_AddFont(PyObject *, PyObject *args, PyObject *kwargs) {
20804 PyObject *resultobj;
20805 wxFontList *arg1 = (wxFontList *) 0 ;
20806 wxFont *arg2 = (wxFont *) 0 ;
20807 PyObject * obj0 = 0 ;
20808 PyObject * obj1 = 0 ;
20809 char *kwnames[] = {
20810 (char *) "self",(char *) "font", NULL
20811 };
20812
20813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_AddFont",kwnames,&obj0,&obj1)) goto fail;
20814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20815 if (SWIG_arg_fail(1)) SWIG_fail;
20816 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
20817 if (SWIG_arg_fail(2)) SWIG_fail;
20818 {
20819 PyThreadState* __tstate = wxPyBeginAllowThreads();
20820 (arg1)->AddFont(arg2);
20821
20822 wxPyEndAllowThreads(__tstate);
20823 if (PyErr_Occurred()) SWIG_fail;
20824 }
20825 Py_INCREF(Py_None); resultobj = Py_None;
20826 return resultobj;
20827 fail:
20828 return NULL;
20829 }
20830
20831
20832 static PyObject *_wrap_FontList_FindOrCreateFont(PyObject *, PyObject *args, PyObject *kwargs) {
20833 PyObject *resultobj;
20834 wxFontList *arg1 = (wxFontList *) 0 ;
20835 int arg2 ;
20836 int arg3 ;
20837 int arg4 ;
20838 int arg5 ;
20839 bool arg6 = (bool) false ;
20840 wxString const &arg7_defvalue = wxPyEmptyString ;
20841 wxString *arg7 = (wxString *) &arg7_defvalue ;
20842 wxFontEncoding arg8 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
20843 wxFont *result;
20844 bool temp7 = false ;
20845 PyObject * obj0 = 0 ;
20846 PyObject * obj1 = 0 ;
20847 PyObject * obj2 = 0 ;
20848 PyObject * obj3 = 0 ;
20849 PyObject * obj4 = 0 ;
20850 PyObject * obj5 = 0 ;
20851 PyObject * obj6 = 0 ;
20852 PyObject * obj7 = 0 ;
20853 char *kwnames[] = {
20854 (char *) "self",(char *) "point_size",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "facename",(char *) "encoding", NULL
20855 };
20856
20857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:FontList_FindOrCreateFont",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
20858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20859 if (SWIG_arg_fail(1)) SWIG_fail;
20860 {
20861 arg2 = (int)(SWIG_As_int(obj1));
20862 if (SWIG_arg_fail(2)) SWIG_fail;
20863 }
20864 {
20865 arg3 = (int)(SWIG_As_int(obj2));
20866 if (SWIG_arg_fail(3)) SWIG_fail;
20867 }
20868 {
20869 arg4 = (int)(SWIG_As_int(obj3));
20870 if (SWIG_arg_fail(4)) SWIG_fail;
20871 }
20872 {
20873 arg5 = (int)(SWIG_As_int(obj4));
20874 if (SWIG_arg_fail(5)) SWIG_fail;
20875 }
20876 if (obj5) {
20877 {
20878 arg6 = (bool)(SWIG_As_bool(obj5));
20879 if (SWIG_arg_fail(6)) SWIG_fail;
20880 }
20881 }
20882 if (obj6) {
20883 {
20884 arg7 = wxString_in_helper(obj6);
20885 if (arg7 == NULL) SWIG_fail;
20886 temp7 = true;
20887 }
20888 }
20889 if (obj7) {
20890 {
20891 arg8 = (wxFontEncoding)(SWIG_As_int(obj7));
20892 if (SWIG_arg_fail(8)) SWIG_fail;
20893 }
20894 }
20895 {
20896 PyThreadState* __tstate = wxPyBeginAllowThreads();
20897 result = (wxFont *)(arg1)->FindOrCreateFont(arg2,arg3,arg4,arg5,arg6,(wxString const &)*arg7,(wxFontEncoding )arg8);
20898
20899 wxPyEndAllowThreads(__tstate);
20900 if (PyErr_Occurred()) SWIG_fail;
20901 }
20902 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
20903 {
20904 if (temp7)
20905 delete arg7;
20906 }
20907 return resultobj;
20908 fail:
20909 {
20910 if (temp7)
20911 delete arg7;
20912 }
20913 return NULL;
20914 }
20915
20916
20917 static PyObject *_wrap_FontList_RemoveFont(PyObject *, PyObject *args, PyObject *kwargs) {
20918 PyObject *resultobj;
20919 wxFontList *arg1 = (wxFontList *) 0 ;
20920 wxFont *arg2 = (wxFont *) 0 ;
20921 PyObject * obj0 = 0 ;
20922 PyObject * obj1 = 0 ;
20923 char *kwnames[] = {
20924 (char *) "self",(char *) "font", NULL
20925 };
20926
20927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_RemoveFont",kwnames,&obj0,&obj1)) goto fail;
20928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20929 if (SWIG_arg_fail(1)) SWIG_fail;
20930 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
20931 if (SWIG_arg_fail(2)) SWIG_fail;
20932 {
20933 PyThreadState* __tstate = wxPyBeginAllowThreads();
20934 (arg1)->RemoveFont(arg2);
20935
20936 wxPyEndAllowThreads(__tstate);
20937 if (PyErr_Occurred()) SWIG_fail;
20938 }
20939 Py_INCREF(Py_None); resultobj = Py_None;
20940 return resultobj;
20941 fail:
20942 return NULL;
20943 }
20944
20945
20946 static PyObject *_wrap_FontList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
20947 PyObject *resultobj;
20948 wxFontList *arg1 = (wxFontList *) 0 ;
20949 int result;
20950 PyObject * obj0 = 0 ;
20951 char *kwnames[] = {
20952 (char *) "self", NULL
20953 };
20954
20955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontList_GetCount",kwnames,&obj0)) goto fail;
20956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20957 if (SWIG_arg_fail(1)) SWIG_fail;
20958 {
20959 PyThreadState* __tstate = wxPyBeginAllowThreads();
20960 result = (int)(arg1)->GetCount();
20961
20962 wxPyEndAllowThreads(__tstate);
20963 if (PyErr_Occurred()) SWIG_fail;
20964 }
20965 {
20966 resultobj = SWIG_From_int((int)(result));
20967 }
20968 return resultobj;
20969 fail:
20970 return NULL;
20971 }
20972
20973
20974 static PyObject * FontList_swigregister(PyObject *, PyObject *args) {
20975 PyObject *obj;
20976 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20977 SWIG_TypeClientData(SWIGTYPE_p_wxFontList, obj);
20978 Py_INCREF(obj);
20979 return Py_BuildValue((char *)"");
20980 }
20981 static int _wrap_TheFontList_set(PyObject *) {
20982 PyErr_SetString(PyExc_TypeError,"Variable TheFontList is read-only.");
20983 return 1;
20984 }
20985
20986
20987 static PyObject *_wrap_TheFontList_get(void) {
20988 PyObject *pyobj;
20989
20990 pyobj = SWIG_NewPointerObj((void *)(wxTheFontList), SWIGTYPE_p_wxFontList, 0);
20991 return pyobj;
20992 }
20993
20994
20995 static int _wrap_ThePenList_set(PyObject *) {
20996 PyErr_SetString(PyExc_TypeError,"Variable ThePenList is read-only.");
20997 return 1;
20998 }
20999
21000
21001 static PyObject *_wrap_ThePenList_get(void) {
21002 PyObject *pyobj;
21003
21004 pyobj = SWIG_NewPointerObj((void *)(wxThePenList), SWIGTYPE_p_wxPenList, 0);
21005 return pyobj;
21006 }
21007
21008
21009 static int _wrap_TheBrushList_set(PyObject *) {
21010 PyErr_SetString(PyExc_TypeError,"Variable TheBrushList is read-only.");
21011 return 1;
21012 }
21013
21014
21015 static PyObject *_wrap_TheBrushList_get(void) {
21016 PyObject *pyobj;
21017
21018 pyobj = SWIG_NewPointerObj((void *)(wxTheBrushList), SWIGTYPE_p_wxBrushList, 0);
21019 return pyobj;
21020 }
21021
21022
21023 static int _wrap_TheColourDatabase_set(PyObject *) {
21024 PyErr_SetString(PyExc_TypeError,"Variable TheColourDatabase is read-only.");
21025 return 1;
21026 }
21027
21028
21029 static PyObject *_wrap_TheColourDatabase_get(void) {
21030 PyObject *pyobj;
21031
21032 pyobj = SWIG_NewPointerObj((void *)(wxTheColourDatabase), SWIGTYPE_p_wxColourDatabase, 0);
21033 return pyobj;
21034 }
21035
21036
21037 static PyObject *_wrap_new_Effects(PyObject *, PyObject *args, PyObject *kwargs) {
21038 PyObject *resultobj;
21039 wxEffects *result;
21040 char *kwnames[] = {
21041 NULL
21042 };
21043
21044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Effects",kwnames)) goto fail;
21045 {
21046 PyThreadState* __tstate = wxPyBeginAllowThreads();
21047 result = (wxEffects *)new wxEffects();
21048
21049 wxPyEndAllowThreads(__tstate);
21050 if (PyErr_Occurred()) SWIG_fail;
21051 }
21052 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEffects, 1);
21053 return resultobj;
21054 fail:
21055 return NULL;
21056 }
21057
21058
21059 static PyObject *_wrap_Effects_GetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
21060 PyObject *resultobj;
21061 wxEffects *arg1 = (wxEffects *) 0 ;
21062 wxColour result;
21063 PyObject * obj0 = 0 ;
21064 char *kwnames[] = {
21065 (char *) "self", NULL
21066 };
21067
21068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetHighlightColour",kwnames,&obj0)) goto fail;
21069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21070 if (SWIG_arg_fail(1)) SWIG_fail;
21071 {
21072 PyThreadState* __tstate = wxPyBeginAllowThreads();
21073 result = ((wxEffects const *)arg1)->GetHighlightColour();
21074
21075 wxPyEndAllowThreads(__tstate);
21076 if (PyErr_Occurred()) SWIG_fail;
21077 }
21078 {
21079 wxColour * resultptr;
21080 resultptr = new wxColour((wxColour &)(result));
21081 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
21082 }
21083 return resultobj;
21084 fail:
21085 return NULL;
21086 }
21087
21088
21089 static PyObject *_wrap_Effects_GetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21090 PyObject *resultobj;
21091 wxEffects *arg1 = (wxEffects *) 0 ;
21092 wxColour result;
21093 PyObject * obj0 = 0 ;
21094 char *kwnames[] = {
21095 (char *) "self", NULL
21096 };
21097
21098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetLightShadow",kwnames,&obj0)) goto fail;
21099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21100 if (SWIG_arg_fail(1)) SWIG_fail;
21101 {
21102 PyThreadState* __tstate = wxPyBeginAllowThreads();
21103 result = ((wxEffects const *)arg1)->GetLightShadow();
21104
21105 wxPyEndAllowThreads(__tstate);
21106 if (PyErr_Occurred()) SWIG_fail;
21107 }
21108 {
21109 wxColour * resultptr;
21110 resultptr = new wxColour((wxColour &)(result));
21111 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
21112 }
21113 return resultobj;
21114 fail:
21115 return NULL;
21116 }
21117
21118
21119 static PyObject *_wrap_Effects_GetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
21120 PyObject *resultobj;
21121 wxEffects *arg1 = (wxEffects *) 0 ;
21122 wxColour result;
21123 PyObject * obj0 = 0 ;
21124 char *kwnames[] = {
21125 (char *) "self", NULL
21126 };
21127
21128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetFaceColour",kwnames,&obj0)) goto fail;
21129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21130 if (SWIG_arg_fail(1)) SWIG_fail;
21131 {
21132 PyThreadState* __tstate = wxPyBeginAllowThreads();
21133 result = ((wxEffects const *)arg1)->GetFaceColour();
21134
21135 wxPyEndAllowThreads(__tstate);
21136 if (PyErr_Occurred()) SWIG_fail;
21137 }
21138 {
21139 wxColour * resultptr;
21140 resultptr = new wxColour((wxColour &)(result));
21141 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
21142 }
21143 return resultobj;
21144 fail:
21145 return NULL;
21146 }
21147
21148
21149 static PyObject *_wrap_Effects_GetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21150 PyObject *resultobj;
21151 wxEffects *arg1 = (wxEffects *) 0 ;
21152 wxColour result;
21153 PyObject * obj0 = 0 ;
21154 char *kwnames[] = {
21155 (char *) "self", NULL
21156 };
21157
21158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetMediumShadow",kwnames,&obj0)) goto fail;
21159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21160 if (SWIG_arg_fail(1)) SWIG_fail;
21161 {
21162 PyThreadState* __tstate = wxPyBeginAllowThreads();
21163 result = ((wxEffects const *)arg1)->GetMediumShadow();
21164
21165 wxPyEndAllowThreads(__tstate);
21166 if (PyErr_Occurred()) SWIG_fail;
21167 }
21168 {
21169 wxColour * resultptr;
21170 resultptr = new wxColour((wxColour &)(result));
21171 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
21172 }
21173 return resultobj;
21174 fail:
21175 return NULL;
21176 }
21177
21178
21179 static PyObject *_wrap_Effects_GetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21180 PyObject *resultobj;
21181 wxEffects *arg1 = (wxEffects *) 0 ;
21182 wxColour result;
21183 PyObject * obj0 = 0 ;
21184 char *kwnames[] = {
21185 (char *) "self", NULL
21186 };
21187
21188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetDarkShadow",kwnames,&obj0)) goto fail;
21189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21190 if (SWIG_arg_fail(1)) SWIG_fail;
21191 {
21192 PyThreadState* __tstate = wxPyBeginAllowThreads();
21193 result = ((wxEffects const *)arg1)->GetDarkShadow();
21194
21195 wxPyEndAllowThreads(__tstate);
21196 if (PyErr_Occurred()) SWIG_fail;
21197 }
21198 {
21199 wxColour * resultptr;
21200 resultptr = new wxColour((wxColour &)(result));
21201 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
21202 }
21203 return resultobj;
21204 fail:
21205 return NULL;
21206 }
21207
21208
21209 static PyObject *_wrap_Effects_SetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
21210 PyObject *resultobj;
21211 wxEffects *arg1 = (wxEffects *) 0 ;
21212 wxColour *arg2 = 0 ;
21213 wxColour temp2 ;
21214 PyObject * obj0 = 0 ;
21215 PyObject * obj1 = 0 ;
21216 char *kwnames[] = {
21217 (char *) "self",(char *) "c", NULL
21218 };
21219
21220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetHighlightColour",kwnames,&obj0,&obj1)) goto fail;
21221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21222 if (SWIG_arg_fail(1)) SWIG_fail;
21223 {
21224 arg2 = &temp2;
21225 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21226 }
21227 {
21228 PyThreadState* __tstate = wxPyBeginAllowThreads();
21229 (arg1)->SetHighlightColour((wxColour const &)*arg2);
21230
21231 wxPyEndAllowThreads(__tstate);
21232 if (PyErr_Occurred()) SWIG_fail;
21233 }
21234 Py_INCREF(Py_None); resultobj = Py_None;
21235 return resultobj;
21236 fail:
21237 return NULL;
21238 }
21239
21240
21241 static PyObject *_wrap_Effects_SetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21242 PyObject *resultobj;
21243 wxEffects *arg1 = (wxEffects *) 0 ;
21244 wxColour *arg2 = 0 ;
21245 wxColour temp2 ;
21246 PyObject * obj0 = 0 ;
21247 PyObject * obj1 = 0 ;
21248 char *kwnames[] = {
21249 (char *) "self",(char *) "c", NULL
21250 };
21251
21252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetLightShadow",kwnames,&obj0,&obj1)) goto fail;
21253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21254 if (SWIG_arg_fail(1)) SWIG_fail;
21255 {
21256 arg2 = &temp2;
21257 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21258 }
21259 {
21260 PyThreadState* __tstate = wxPyBeginAllowThreads();
21261 (arg1)->SetLightShadow((wxColour const &)*arg2);
21262
21263 wxPyEndAllowThreads(__tstate);
21264 if (PyErr_Occurred()) SWIG_fail;
21265 }
21266 Py_INCREF(Py_None); resultobj = Py_None;
21267 return resultobj;
21268 fail:
21269 return NULL;
21270 }
21271
21272
21273 static PyObject *_wrap_Effects_SetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
21274 PyObject *resultobj;
21275 wxEffects *arg1 = (wxEffects *) 0 ;
21276 wxColour *arg2 = 0 ;
21277 wxColour temp2 ;
21278 PyObject * obj0 = 0 ;
21279 PyObject * obj1 = 0 ;
21280 char *kwnames[] = {
21281 (char *) "self",(char *) "c", NULL
21282 };
21283
21284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetFaceColour",kwnames,&obj0,&obj1)) goto fail;
21285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21286 if (SWIG_arg_fail(1)) SWIG_fail;
21287 {
21288 arg2 = &temp2;
21289 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21290 }
21291 {
21292 PyThreadState* __tstate = wxPyBeginAllowThreads();
21293 (arg1)->SetFaceColour((wxColour const &)*arg2);
21294
21295 wxPyEndAllowThreads(__tstate);
21296 if (PyErr_Occurred()) SWIG_fail;
21297 }
21298 Py_INCREF(Py_None); resultobj = Py_None;
21299 return resultobj;
21300 fail:
21301 return NULL;
21302 }
21303
21304
21305 static PyObject *_wrap_Effects_SetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21306 PyObject *resultobj;
21307 wxEffects *arg1 = (wxEffects *) 0 ;
21308 wxColour *arg2 = 0 ;
21309 wxColour temp2 ;
21310 PyObject * obj0 = 0 ;
21311 PyObject * obj1 = 0 ;
21312 char *kwnames[] = {
21313 (char *) "self",(char *) "c", NULL
21314 };
21315
21316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetMediumShadow",kwnames,&obj0,&obj1)) goto fail;
21317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21318 if (SWIG_arg_fail(1)) SWIG_fail;
21319 {
21320 arg2 = &temp2;
21321 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21322 }
21323 {
21324 PyThreadState* __tstate = wxPyBeginAllowThreads();
21325 (arg1)->SetMediumShadow((wxColour const &)*arg2);
21326
21327 wxPyEndAllowThreads(__tstate);
21328 if (PyErr_Occurred()) SWIG_fail;
21329 }
21330 Py_INCREF(Py_None); resultobj = Py_None;
21331 return resultobj;
21332 fail:
21333 return NULL;
21334 }
21335
21336
21337 static PyObject *_wrap_Effects_SetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21338 PyObject *resultobj;
21339 wxEffects *arg1 = (wxEffects *) 0 ;
21340 wxColour *arg2 = 0 ;
21341 wxColour temp2 ;
21342 PyObject * obj0 = 0 ;
21343 PyObject * obj1 = 0 ;
21344 char *kwnames[] = {
21345 (char *) "self",(char *) "c", NULL
21346 };
21347
21348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetDarkShadow",kwnames,&obj0,&obj1)) goto fail;
21349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21350 if (SWIG_arg_fail(1)) SWIG_fail;
21351 {
21352 arg2 = &temp2;
21353 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21354 }
21355 {
21356 PyThreadState* __tstate = wxPyBeginAllowThreads();
21357 (arg1)->SetDarkShadow((wxColour const &)*arg2);
21358
21359 wxPyEndAllowThreads(__tstate);
21360 if (PyErr_Occurred()) SWIG_fail;
21361 }
21362 Py_INCREF(Py_None); resultobj = Py_None;
21363 return resultobj;
21364 fail:
21365 return NULL;
21366 }
21367
21368
21369 static PyObject *_wrap_Effects_Set(PyObject *, PyObject *args, PyObject *kwargs) {
21370 PyObject *resultobj;
21371 wxEffects *arg1 = (wxEffects *) 0 ;
21372 wxColour *arg2 = 0 ;
21373 wxColour *arg3 = 0 ;
21374 wxColour *arg4 = 0 ;
21375 wxColour *arg5 = 0 ;
21376 wxColour *arg6 = 0 ;
21377 wxColour temp2 ;
21378 wxColour temp3 ;
21379 wxColour temp4 ;
21380 wxColour temp5 ;
21381 wxColour temp6 ;
21382 PyObject * obj0 = 0 ;
21383 PyObject * obj1 = 0 ;
21384 PyObject * obj2 = 0 ;
21385 PyObject * obj3 = 0 ;
21386 PyObject * obj4 = 0 ;
21387 PyObject * obj5 = 0 ;
21388 char *kwnames[] = {
21389 (char *) "self",(char *) "highlightColour",(char *) "lightShadow",(char *) "faceColour",(char *) "mediumShadow",(char *) "darkShadow", NULL
21390 };
21391
21392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Effects_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
21393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21394 if (SWIG_arg_fail(1)) SWIG_fail;
21395 {
21396 arg2 = &temp2;
21397 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21398 }
21399 {
21400 arg3 = &temp3;
21401 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
21402 }
21403 {
21404 arg4 = &temp4;
21405 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
21406 }
21407 {
21408 arg5 = &temp5;
21409 if ( ! wxColour_helper(obj4, &arg5)) SWIG_fail;
21410 }
21411 {
21412 arg6 = &temp6;
21413 if ( ! wxColour_helper(obj5, &arg6)) SWIG_fail;
21414 }
21415 {
21416 PyThreadState* __tstate = wxPyBeginAllowThreads();
21417 (arg1)->Set((wxColour const &)*arg2,(wxColour const &)*arg3,(wxColour const &)*arg4,(wxColour const &)*arg5,(wxColour const &)*arg6);
21418
21419 wxPyEndAllowThreads(__tstate);
21420 if (PyErr_Occurred()) SWIG_fail;
21421 }
21422 Py_INCREF(Py_None); resultobj = Py_None;
21423 return resultobj;
21424 fail:
21425 return NULL;
21426 }
21427
21428
21429 static PyObject *_wrap_Effects_DrawSunkenEdge(PyObject *, PyObject *args, PyObject *kwargs) {
21430 PyObject *resultobj;
21431 wxEffects *arg1 = (wxEffects *) 0 ;
21432 wxDC *arg2 = 0 ;
21433 wxRect *arg3 = 0 ;
21434 int arg4 = (int) 1 ;
21435 wxRect temp3 ;
21436 PyObject * obj0 = 0 ;
21437 PyObject * obj1 = 0 ;
21438 PyObject * obj2 = 0 ;
21439 PyObject * obj3 = 0 ;
21440 char *kwnames[] = {
21441 (char *) "self",(char *) "dc",(char *) "rect",(char *) "borderSize", NULL
21442 };
21443
21444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Effects_DrawSunkenEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
21445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21446 if (SWIG_arg_fail(1)) SWIG_fail;
21447 {
21448 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21449 if (SWIG_arg_fail(2)) SWIG_fail;
21450 if (arg2 == NULL) {
21451 SWIG_null_ref("wxDC");
21452 }
21453 if (SWIG_arg_fail(2)) SWIG_fail;
21454 }
21455 {
21456 arg3 = &temp3;
21457 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
21458 }
21459 if (obj3) {
21460 {
21461 arg4 = (int)(SWIG_As_int(obj3));
21462 if (SWIG_arg_fail(4)) SWIG_fail;
21463 }
21464 }
21465 {
21466 PyThreadState* __tstate = wxPyBeginAllowThreads();
21467 (arg1)->DrawSunkenEdge(*arg2,(wxRect const &)*arg3,arg4);
21468
21469 wxPyEndAllowThreads(__tstate);
21470 if (PyErr_Occurred()) SWIG_fail;
21471 }
21472 Py_INCREF(Py_None); resultobj = Py_None;
21473 return resultobj;
21474 fail:
21475 return NULL;
21476 }
21477
21478
21479 static PyObject *_wrap_Effects_TileBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
21480 PyObject *resultobj;
21481 wxEffects *arg1 = (wxEffects *) 0 ;
21482 wxRect *arg2 = 0 ;
21483 wxDC *arg3 = 0 ;
21484 wxBitmap *arg4 = 0 ;
21485 bool result;
21486 wxRect temp2 ;
21487 PyObject * obj0 = 0 ;
21488 PyObject * obj1 = 0 ;
21489 PyObject * obj2 = 0 ;
21490 PyObject * obj3 = 0 ;
21491 char *kwnames[] = {
21492 (char *) "self",(char *) "rect",(char *) "dc",(char *) "bitmap", NULL
21493 };
21494
21495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Effects_TileBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
21496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21497 if (SWIG_arg_fail(1)) SWIG_fail;
21498 {
21499 arg2 = &temp2;
21500 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
21501 }
21502 {
21503 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21504 if (SWIG_arg_fail(3)) SWIG_fail;
21505 if (arg3 == NULL) {
21506 SWIG_null_ref("wxDC");
21507 }
21508 if (SWIG_arg_fail(3)) SWIG_fail;
21509 }
21510 {
21511 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
21512 if (SWIG_arg_fail(4)) SWIG_fail;
21513 if (arg4 == NULL) {
21514 SWIG_null_ref("wxBitmap");
21515 }
21516 if (SWIG_arg_fail(4)) SWIG_fail;
21517 }
21518 {
21519 PyThreadState* __tstate = wxPyBeginAllowThreads();
21520 result = (bool)(arg1)->TileBitmap((wxRect const &)*arg2,*arg3,*arg4);
21521
21522 wxPyEndAllowThreads(__tstate);
21523 if (PyErr_Occurred()) SWIG_fail;
21524 }
21525 {
21526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21527 }
21528 return resultobj;
21529 fail:
21530 return NULL;
21531 }
21532
21533
21534 static PyObject * Effects_swigregister(PyObject *, PyObject *args) {
21535 PyObject *obj;
21536 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21537 SWIG_TypeClientData(SWIGTYPE_p_wxEffects, obj);
21538 Py_INCREF(obj);
21539 return Py_BuildValue((char *)"");
21540 }
21541 static PyObject *_wrap_new_SplitterRenderParams(PyObject *, PyObject *args, PyObject *kwargs) {
21542 PyObject *resultobj;
21543 int arg1 ;
21544 int arg2 ;
21545 bool arg3 ;
21546 wxSplitterRenderParams *result;
21547 PyObject * obj0 = 0 ;
21548 PyObject * obj1 = 0 ;
21549 PyObject * obj2 = 0 ;
21550 char *kwnames[] = {
21551 (char *) "widthSash_",(char *) "border_",(char *) "isSens_", NULL
21552 };
21553
21554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_SplitterRenderParams",kwnames,&obj0,&obj1,&obj2)) goto fail;
21555 {
21556 arg1 = (int)(SWIG_As_int(obj0));
21557 if (SWIG_arg_fail(1)) SWIG_fail;
21558 }
21559 {
21560 arg2 = (int)(SWIG_As_int(obj1));
21561 if (SWIG_arg_fail(2)) SWIG_fail;
21562 }
21563 {
21564 arg3 = (bool)(SWIG_As_bool(obj2));
21565 if (SWIG_arg_fail(3)) SWIG_fail;
21566 }
21567 {
21568 PyThreadState* __tstate = wxPyBeginAllowThreads();
21569 result = (wxSplitterRenderParams *)new wxSplitterRenderParams(arg1,arg2,arg3);
21570
21571 wxPyEndAllowThreads(__tstate);
21572 if (PyErr_Occurred()) SWIG_fail;
21573 }
21574 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSplitterRenderParams, 1);
21575 return resultobj;
21576 fail:
21577 return NULL;
21578 }
21579
21580
21581 static PyObject *_wrap_delete_SplitterRenderParams(PyObject *, PyObject *args, PyObject *kwargs) {
21582 PyObject *resultobj;
21583 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
21584 PyObject * obj0 = 0 ;
21585 char *kwnames[] = {
21586 (char *) "self", NULL
21587 };
21588
21589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SplitterRenderParams",kwnames,&obj0)) goto fail;
21590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterRenderParams, SWIG_POINTER_EXCEPTION | 0);
21591 if (SWIG_arg_fail(1)) SWIG_fail;
21592 {
21593 PyThreadState* __tstate = wxPyBeginAllowThreads();
21594 delete arg1;
21595
21596 wxPyEndAllowThreads(__tstate);
21597 if (PyErr_Occurred()) SWIG_fail;
21598 }
21599 Py_INCREF(Py_None); resultobj = Py_None;
21600 return resultobj;
21601 fail:
21602 return NULL;
21603 }
21604
21605
21606 static PyObject *_wrap_SplitterRenderParams_widthSash_get(PyObject *, PyObject *args, PyObject *kwargs) {
21607 PyObject *resultobj;
21608 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
21609 int result;
21610 PyObject * obj0 = 0 ;
21611 char *kwnames[] = {
21612 (char *) "self", NULL
21613 };
21614
21615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterRenderParams_widthSash_get",kwnames,&obj0)) goto fail;
21616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterRenderParams, SWIG_POINTER_EXCEPTION | 0);
21617 if (SWIG_arg_fail(1)) SWIG_fail;
21618 result = (int)(int) ((arg1)->widthSash);
21619
21620 {
21621 resultobj = SWIG_From_int((int)(result));
21622 }
21623 return resultobj;
21624 fail:
21625 return NULL;
21626 }
21627
21628
21629 static PyObject *_wrap_SplitterRenderParams_border_get(PyObject *, PyObject *args, PyObject *kwargs) {
21630 PyObject *resultobj;
21631 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
21632 int result;
21633 PyObject * obj0 = 0 ;
21634 char *kwnames[] = {
21635 (char *) "self", NULL
21636 };
21637
21638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterRenderParams_border_get",kwnames,&obj0)) goto fail;
21639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterRenderParams, SWIG_POINTER_EXCEPTION | 0);
21640 if (SWIG_arg_fail(1)) SWIG_fail;
21641 result = (int)(int) ((arg1)->border);
21642
21643 {
21644 resultobj = SWIG_From_int((int)(result));
21645 }
21646 return resultobj;
21647 fail:
21648 return NULL;
21649 }
21650
21651
21652 static PyObject *_wrap_SplitterRenderParams_isHotSensitive_get(PyObject *, PyObject *args, PyObject *kwargs) {
21653 PyObject *resultobj;
21654 wxSplitterRenderParams *arg1 = (wxSplitterRenderParams *) 0 ;
21655 bool result;
21656 PyObject * obj0 = 0 ;
21657 char *kwnames[] = {
21658 (char *) "self", NULL
21659 };
21660
21661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SplitterRenderParams_isHotSensitive_get",kwnames,&obj0)) goto fail;
21662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSplitterRenderParams, SWIG_POINTER_EXCEPTION | 0);
21663 if (SWIG_arg_fail(1)) SWIG_fail;
21664 result = (bool)(bool) ((arg1)->isHotSensitive);
21665
21666 {
21667 resultobj = SWIG_From_bool((bool)(result));
21668 }
21669 return resultobj;
21670 fail:
21671 return NULL;
21672 }
21673
21674
21675 static PyObject * SplitterRenderParams_swigregister(PyObject *, PyObject *args) {
21676 PyObject *obj;
21677 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21678 SWIG_TypeClientData(SWIGTYPE_p_wxSplitterRenderParams, obj);
21679 Py_INCREF(obj);
21680 return Py_BuildValue((char *)"");
21681 }
21682 static PyObject *_wrap_new_RendererVersion(PyObject *, PyObject *args, PyObject *kwargs) {
21683 PyObject *resultobj;
21684 int arg1 ;
21685 int arg2 ;
21686 wxRendererVersion *result;
21687 PyObject * obj0 = 0 ;
21688 PyObject * obj1 = 0 ;
21689 char *kwnames[] = {
21690 (char *) "version_",(char *) "age_", NULL
21691 };
21692
21693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RendererVersion",kwnames,&obj0,&obj1)) goto fail;
21694 {
21695 arg1 = (int)(SWIG_As_int(obj0));
21696 if (SWIG_arg_fail(1)) SWIG_fail;
21697 }
21698 {
21699 arg2 = (int)(SWIG_As_int(obj1));
21700 if (SWIG_arg_fail(2)) SWIG_fail;
21701 }
21702 {
21703 PyThreadState* __tstate = wxPyBeginAllowThreads();
21704 result = (wxRendererVersion *)new wxRendererVersion(arg1,arg2);
21705
21706 wxPyEndAllowThreads(__tstate);
21707 if (PyErr_Occurred()) SWIG_fail;
21708 }
21709 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRendererVersion, 1);
21710 return resultobj;
21711 fail:
21712 return NULL;
21713 }
21714
21715
21716 static PyObject *_wrap_delete_RendererVersion(PyObject *, PyObject *args, PyObject *kwargs) {
21717 PyObject *resultobj;
21718 wxRendererVersion *arg1 = (wxRendererVersion *) 0 ;
21719 PyObject * obj0 = 0 ;
21720 char *kwnames[] = {
21721 (char *) "self", NULL
21722 };
21723
21724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RendererVersion",kwnames,&obj0)) goto fail;
21725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererVersion, SWIG_POINTER_EXCEPTION | 0);
21726 if (SWIG_arg_fail(1)) SWIG_fail;
21727 {
21728 PyThreadState* __tstate = wxPyBeginAllowThreads();
21729 delete arg1;
21730
21731 wxPyEndAllowThreads(__tstate);
21732 if (PyErr_Occurred()) SWIG_fail;
21733 }
21734 Py_INCREF(Py_None); resultobj = Py_None;
21735 return resultobj;
21736 fail:
21737 return NULL;
21738 }
21739
21740
21741 static PyObject *_wrap_RendererVersion_IsCompatible(PyObject *, PyObject *args, PyObject *kwargs) {
21742 PyObject *resultobj;
21743 wxRendererVersion *arg1 = 0 ;
21744 bool result;
21745 PyObject * obj0 = 0 ;
21746 char *kwnames[] = {
21747 (char *) "ver", NULL
21748 };
21749
21750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RendererVersion_IsCompatible",kwnames,&obj0)) goto fail;
21751 {
21752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererVersion, SWIG_POINTER_EXCEPTION | 0);
21753 if (SWIG_arg_fail(1)) SWIG_fail;
21754 if (arg1 == NULL) {
21755 SWIG_null_ref("wxRendererVersion");
21756 }
21757 if (SWIG_arg_fail(1)) SWIG_fail;
21758 }
21759 {
21760 PyThreadState* __tstate = wxPyBeginAllowThreads();
21761 result = (bool)wxRendererVersion::IsCompatible((wxRendererVersion const &)*arg1);
21762
21763 wxPyEndAllowThreads(__tstate);
21764 if (PyErr_Occurred()) SWIG_fail;
21765 }
21766 {
21767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21768 }
21769 return resultobj;
21770 fail:
21771 return NULL;
21772 }
21773
21774
21775 static PyObject *_wrap_RendererVersion_version_get(PyObject *, PyObject *args, PyObject *kwargs) {
21776 PyObject *resultobj;
21777 wxRendererVersion *arg1 = (wxRendererVersion *) 0 ;
21778 int result;
21779 PyObject * obj0 = 0 ;
21780 char *kwnames[] = {
21781 (char *) "self", NULL
21782 };
21783
21784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RendererVersion_version_get",kwnames,&obj0)) goto fail;
21785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererVersion, SWIG_POINTER_EXCEPTION | 0);
21786 if (SWIG_arg_fail(1)) SWIG_fail;
21787 result = (int)(int) ((arg1)->version);
21788
21789 {
21790 resultobj = SWIG_From_int((int)(result));
21791 }
21792 return resultobj;
21793 fail:
21794 return NULL;
21795 }
21796
21797
21798 static PyObject *_wrap_RendererVersion_age_get(PyObject *, PyObject *args, PyObject *kwargs) {
21799 PyObject *resultobj;
21800 wxRendererVersion *arg1 = (wxRendererVersion *) 0 ;
21801 int result;
21802 PyObject * obj0 = 0 ;
21803 char *kwnames[] = {
21804 (char *) "self", NULL
21805 };
21806
21807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RendererVersion_age_get",kwnames,&obj0)) goto fail;
21808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererVersion, SWIG_POINTER_EXCEPTION | 0);
21809 if (SWIG_arg_fail(1)) SWIG_fail;
21810 result = (int)(int) ((arg1)->age);
21811
21812 {
21813 resultobj = SWIG_From_int((int)(result));
21814 }
21815 return resultobj;
21816 fail:
21817 return NULL;
21818 }
21819
21820
21821 static PyObject * RendererVersion_swigregister(PyObject *, PyObject *args) {
21822 PyObject *obj;
21823 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21824 SWIG_TypeClientData(SWIGTYPE_p_wxRendererVersion, obj);
21825 Py_INCREF(obj);
21826 return Py_BuildValue((char *)"");
21827 }
21828 static PyObject *_wrap_RendererNative_DrawHeaderButton(PyObject *, PyObject *args, PyObject *kwargs) {
21829 PyObject *resultobj;
21830 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
21831 wxWindow *arg2 = (wxWindow *) 0 ;
21832 wxDC *arg3 = 0 ;
21833 wxRect *arg4 = 0 ;
21834 int arg5 = (int) 0 ;
21835 wxRect temp4 ;
21836 PyObject * obj0 = 0 ;
21837 PyObject * obj1 = 0 ;
21838 PyObject * obj2 = 0 ;
21839 PyObject * obj3 = 0 ;
21840 PyObject * obj4 = 0 ;
21841 char *kwnames[] = {
21842 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
21843 };
21844
21845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawHeaderButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
21846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
21847 if (SWIG_arg_fail(1)) SWIG_fail;
21848 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21849 if (SWIG_arg_fail(2)) SWIG_fail;
21850 {
21851 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21852 if (SWIG_arg_fail(3)) SWIG_fail;
21853 if (arg3 == NULL) {
21854 SWIG_null_ref("wxDC");
21855 }
21856 if (SWIG_arg_fail(3)) SWIG_fail;
21857 }
21858 {
21859 arg4 = &temp4;
21860 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
21861 }
21862 if (obj4) {
21863 {
21864 arg5 = (int)(SWIG_As_int(obj4));
21865 if (SWIG_arg_fail(5)) SWIG_fail;
21866 }
21867 }
21868 {
21869 PyThreadState* __tstate = wxPyBeginAllowThreads();
21870 (arg1)->DrawHeaderButton(arg2,*arg3,(wxRect const &)*arg4,arg5);
21871
21872 wxPyEndAllowThreads(__tstate);
21873 if (PyErr_Occurred()) SWIG_fail;
21874 }
21875 Py_INCREF(Py_None); resultobj = Py_None;
21876 return resultobj;
21877 fail:
21878 return NULL;
21879 }
21880
21881
21882 static PyObject *_wrap_RendererNative_DrawTreeItemButton(PyObject *, PyObject *args, PyObject *kwargs) {
21883 PyObject *resultobj;
21884 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
21885 wxWindow *arg2 = (wxWindow *) 0 ;
21886 wxDC *arg3 = 0 ;
21887 wxRect *arg4 = 0 ;
21888 int arg5 = (int) 0 ;
21889 wxRect temp4 ;
21890 PyObject * obj0 = 0 ;
21891 PyObject * obj1 = 0 ;
21892 PyObject * obj2 = 0 ;
21893 PyObject * obj3 = 0 ;
21894 PyObject * obj4 = 0 ;
21895 char *kwnames[] = {
21896 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
21897 };
21898
21899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawTreeItemButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
21900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
21901 if (SWIG_arg_fail(1)) SWIG_fail;
21902 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21903 if (SWIG_arg_fail(2)) SWIG_fail;
21904 {
21905 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21906 if (SWIG_arg_fail(3)) SWIG_fail;
21907 if (arg3 == NULL) {
21908 SWIG_null_ref("wxDC");
21909 }
21910 if (SWIG_arg_fail(3)) SWIG_fail;
21911 }
21912 {
21913 arg4 = &temp4;
21914 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
21915 }
21916 if (obj4) {
21917 {
21918 arg5 = (int)(SWIG_As_int(obj4));
21919 if (SWIG_arg_fail(5)) SWIG_fail;
21920 }
21921 }
21922 {
21923 PyThreadState* __tstate = wxPyBeginAllowThreads();
21924 (arg1)->DrawTreeItemButton(arg2,*arg3,(wxRect const &)*arg4,arg5);
21925
21926 wxPyEndAllowThreads(__tstate);
21927 if (PyErr_Occurred()) SWIG_fail;
21928 }
21929 Py_INCREF(Py_None); resultobj = Py_None;
21930 return resultobj;
21931 fail:
21932 return NULL;
21933 }
21934
21935
21936 static PyObject *_wrap_RendererNative_DrawSplitterBorder(PyObject *, PyObject *args, PyObject *kwargs) {
21937 PyObject *resultobj;
21938 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
21939 wxWindow *arg2 = (wxWindow *) 0 ;
21940 wxDC *arg3 = 0 ;
21941 wxRect *arg4 = 0 ;
21942 int arg5 = (int) 0 ;
21943 wxRect temp4 ;
21944 PyObject * obj0 = 0 ;
21945 PyObject * obj1 = 0 ;
21946 PyObject * obj2 = 0 ;
21947 PyObject * obj3 = 0 ;
21948 PyObject * obj4 = 0 ;
21949 char *kwnames[] = {
21950 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
21951 };
21952
21953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawSplitterBorder",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
21954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
21955 if (SWIG_arg_fail(1)) SWIG_fail;
21956 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21957 if (SWIG_arg_fail(2)) SWIG_fail;
21958 {
21959 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21960 if (SWIG_arg_fail(3)) SWIG_fail;
21961 if (arg3 == NULL) {
21962 SWIG_null_ref("wxDC");
21963 }
21964 if (SWIG_arg_fail(3)) SWIG_fail;
21965 }
21966 {
21967 arg4 = &temp4;
21968 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
21969 }
21970 if (obj4) {
21971 {
21972 arg5 = (int)(SWIG_As_int(obj4));
21973 if (SWIG_arg_fail(5)) SWIG_fail;
21974 }
21975 }
21976 {
21977 PyThreadState* __tstate = wxPyBeginAllowThreads();
21978 (arg1)->DrawSplitterBorder(arg2,*arg3,(wxRect const &)*arg4,arg5);
21979
21980 wxPyEndAllowThreads(__tstate);
21981 if (PyErr_Occurred()) SWIG_fail;
21982 }
21983 Py_INCREF(Py_None); resultobj = Py_None;
21984 return resultobj;
21985 fail:
21986 return NULL;
21987 }
21988
21989
21990 static PyObject *_wrap_RendererNative_DrawSplitterSash(PyObject *, PyObject *args, PyObject *kwargs) {
21991 PyObject *resultobj;
21992 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
21993 wxWindow *arg2 = (wxWindow *) 0 ;
21994 wxDC *arg3 = 0 ;
21995 wxSize *arg4 = 0 ;
21996 int arg5 ;
21997 wxOrientation arg6 ;
21998 int arg7 = (int) 0 ;
21999 wxSize temp4 ;
22000 PyObject * obj0 = 0 ;
22001 PyObject * obj1 = 0 ;
22002 PyObject * obj2 = 0 ;
22003 PyObject * obj3 = 0 ;
22004 PyObject * obj4 = 0 ;
22005 PyObject * obj5 = 0 ;
22006 PyObject * obj6 = 0 ;
22007 char *kwnames[] = {
22008 (char *) "self",(char *) "win",(char *) "dc",(char *) "size",(char *) "position",(char *) "orient",(char *) "flags", NULL
22009 };
22010
22011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:RendererNative_DrawSplitterSash",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
22012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
22013 if (SWIG_arg_fail(1)) SWIG_fail;
22014 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22015 if (SWIG_arg_fail(2)) SWIG_fail;
22016 {
22017 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
22018 if (SWIG_arg_fail(3)) SWIG_fail;
22019 if (arg3 == NULL) {
22020 SWIG_null_ref("wxDC");
22021 }
22022 if (SWIG_arg_fail(3)) SWIG_fail;
22023 }
22024 {
22025 arg4 = &temp4;
22026 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
22027 }
22028 {
22029 arg5 = (int)(SWIG_As_int(obj4));
22030 if (SWIG_arg_fail(5)) SWIG_fail;
22031 }
22032 {
22033 arg6 = (wxOrientation)(SWIG_As_int(obj5));
22034 if (SWIG_arg_fail(6)) SWIG_fail;
22035 }
22036 if (obj6) {
22037 {
22038 arg7 = (int)(SWIG_As_int(obj6));
22039 if (SWIG_arg_fail(7)) SWIG_fail;
22040 }
22041 }
22042 {
22043 PyThreadState* __tstate = wxPyBeginAllowThreads();
22044 (arg1)->DrawSplitterSash(arg2,*arg3,(wxSize const &)*arg4,arg5,(wxOrientation )arg6,arg7);
22045
22046 wxPyEndAllowThreads(__tstate);
22047 if (PyErr_Occurred()) SWIG_fail;
22048 }
22049 Py_INCREF(Py_None); resultobj = Py_None;
22050 return resultobj;
22051 fail:
22052 return NULL;
22053 }
22054
22055
22056 static PyObject *_wrap_RendererNative_DrawComboBoxDropButton(PyObject *, PyObject *args, PyObject *kwargs) {
22057 PyObject *resultobj;
22058 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
22059 wxWindow *arg2 = (wxWindow *) 0 ;
22060 wxDC *arg3 = 0 ;
22061 wxRect *arg4 = 0 ;
22062 int arg5 = (int) 0 ;
22063 wxRect temp4 ;
22064 PyObject * obj0 = 0 ;
22065 PyObject * obj1 = 0 ;
22066 PyObject * obj2 = 0 ;
22067 PyObject * obj3 = 0 ;
22068 PyObject * obj4 = 0 ;
22069 char *kwnames[] = {
22070 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
22071 };
22072
22073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawComboBoxDropButton",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
22074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
22075 if (SWIG_arg_fail(1)) SWIG_fail;
22076 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22077 if (SWIG_arg_fail(2)) SWIG_fail;
22078 {
22079 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
22080 if (SWIG_arg_fail(3)) SWIG_fail;
22081 if (arg3 == NULL) {
22082 SWIG_null_ref("wxDC");
22083 }
22084 if (SWIG_arg_fail(3)) SWIG_fail;
22085 }
22086 {
22087 arg4 = &temp4;
22088 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
22089 }
22090 if (obj4) {
22091 {
22092 arg5 = (int)(SWIG_As_int(obj4));
22093 if (SWIG_arg_fail(5)) SWIG_fail;
22094 }
22095 }
22096 {
22097 PyThreadState* __tstate = wxPyBeginAllowThreads();
22098 (arg1)->DrawComboBoxDropButton(arg2,*arg3,(wxRect const &)*arg4,arg5);
22099
22100 wxPyEndAllowThreads(__tstate);
22101 if (PyErr_Occurred()) SWIG_fail;
22102 }
22103 Py_INCREF(Py_None); resultobj = Py_None;
22104 return resultobj;
22105 fail:
22106 return NULL;
22107 }
22108
22109
22110 static PyObject *_wrap_RendererNative_DrawDropArrow(PyObject *, PyObject *args, PyObject *kwargs) {
22111 PyObject *resultobj;
22112 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
22113 wxWindow *arg2 = (wxWindow *) 0 ;
22114 wxDC *arg3 = 0 ;
22115 wxRect *arg4 = 0 ;
22116 int arg5 = (int) 0 ;
22117 wxRect temp4 ;
22118 PyObject * obj0 = 0 ;
22119 PyObject * obj1 = 0 ;
22120 PyObject * obj2 = 0 ;
22121 PyObject * obj3 = 0 ;
22122 PyObject * obj4 = 0 ;
22123 char *kwnames[] = {
22124 (char *) "self",(char *) "win",(char *) "dc",(char *) "rect",(char *) "flags", NULL
22125 };
22126
22127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RendererNative_DrawDropArrow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
22128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
22129 if (SWIG_arg_fail(1)) SWIG_fail;
22130 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22131 if (SWIG_arg_fail(2)) SWIG_fail;
22132 {
22133 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
22134 if (SWIG_arg_fail(3)) SWIG_fail;
22135 if (arg3 == NULL) {
22136 SWIG_null_ref("wxDC");
22137 }
22138 if (SWIG_arg_fail(3)) SWIG_fail;
22139 }
22140 {
22141 arg4 = &temp4;
22142 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
22143 }
22144 if (obj4) {
22145 {
22146 arg5 = (int)(SWIG_As_int(obj4));
22147 if (SWIG_arg_fail(5)) SWIG_fail;
22148 }
22149 }
22150 {
22151 PyThreadState* __tstate = wxPyBeginAllowThreads();
22152 (arg1)->DrawDropArrow(arg2,*arg3,(wxRect const &)*arg4,arg5);
22153
22154 wxPyEndAllowThreads(__tstate);
22155 if (PyErr_Occurred()) SWIG_fail;
22156 }
22157 Py_INCREF(Py_None); resultobj = Py_None;
22158 return resultobj;
22159 fail:
22160 return NULL;
22161 }
22162
22163
22164 static PyObject *_wrap_RendererNative_GetSplitterParams(PyObject *, PyObject *args, PyObject *kwargs) {
22165 PyObject *resultobj;
22166 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
22167 wxWindow *arg2 = (wxWindow *) 0 ;
22168 SwigValueWrapper<wxSplitterRenderParams > result;
22169 PyObject * obj0 = 0 ;
22170 PyObject * obj1 = 0 ;
22171 char *kwnames[] = {
22172 (char *) "self",(char *) "win", NULL
22173 };
22174
22175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RendererNative_GetSplitterParams",kwnames,&obj0,&obj1)) goto fail;
22176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
22177 if (SWIG_arg_fail(1)) SWIG_fail;
22178 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22179 if (SWIG_arg_fail(2)) SWIG_fail;
22180 {
22181 PyThreadState* __tstate = wxPyBeginAllowThreads();
22182 result = (arg1)->GetSplitterParams((wxWindow const *)arg2);
22183
22184 wxPyEndAllowThreads(__tstate);
22185 if (PyErr_Occurred()) SWIG_fail;
22186 }
22187 {
22188 wxSplitterRenderParams * resultptr;
22189 resultptr = new wxSplitterRenderParams((wxSplitterRenderParams &)(result));
22190 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSplitterRenderParams, 1);
22191 }
22192 return resultobj;
22193 fail:
22194 return NULL;
22195 }
22196
22197
22198 static PyObject *_wrap_RendererNative_Get(PyObject *, PyObject *args, PyObject *kwargs) {
22199 PyObject *resultobj;
22200 wxRendererNative *result;
22201 char *kwnames[] = {
22202 NULL
22203 };
22204
22205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":RendererNative_Get",kwnames)) goto fail;
22206 {
22207 PyThreadState* __tstate = wxPyBeginAllowThreads();
22208 {
22209 wxRendererNative &_result_ref = wxRendererNative::Get();
22210 result = (wxRendererNative *) &_result_ref;
22211 }
22212
22213 wxPyEndAllowThreads(__tstate);
22214 if (PyErr_Occurred()) SWIG_fail;
22215 }
22216 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRendererNative, 0);
22217 return resultobj;
22218 fail:
22219 return NULL;
22220 }
22221
22222
22223 static PyObject *_wrap_RendererNative_GetGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
22224 PyObject *resultobj;
22225 wxRendererNative *result;
22226 char *kwnames[] = {
22227 NULL
22228 };
22229
22230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":RendererNative_GetGeneric",kwnames)) goto fail;
22231 {
22232 PyThreadState* __tstate = wxPyBeginAllowThreads();
22233 {
22234 wxRendererNative &_result_ref = wxRendererNative::GetGeneric();
22235 result = (wxRendererNative *) &_result_ref;
22236 }
22237
22238 wxPyEndAllowThreads(__tstate);
22239 if (PyErr_Occurred()) SWIG_fail;
22240 }
22241 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRendererNative, 0);
22242 return resultobj;
22243 fail:
22244 return NULL;
22245 }
22246
22247
22248 static PyObject *_wrap_RendererNative_GetDefault(PyObject *, PyObject *args, PyObject *kwargs) {
22249 PyObject *resultobj;
22250 wxRendererNative *result;
22251 char *kwnames[] = {
22252 NULL
22253 };
22254
22255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":RendererNative_GetDefault",kwnames)) goto fail;
22256 {
22257 PyThreadState* __tstate = wxPyBeginAllowThreads();
22258 {
22259 wxRendererNative &_result_ref = wxRendererNative::GetDefault();
22260 result = (wxRendererNative *) &_result_ref;
22261 }
22262
22263 wxPyEndAllowThreads(__tstate);
22264 if (PyErr_Occurred()) SWIG_fail;
22265 }
22266 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRendererNative, 0);
22267 return resultobj;
22268 fail:
22269 return NULL;
22270 }
22271
22272
22273 static PyObject *_wrap_RendererNative_Set(PyObject *, PyObject *args, PyObject *kwargs) {
22274 PyObject *resultobj;
22275 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
22276 wxRendererNative *result;
22277 PyObject * obj0 = 0 ;
22278 char *kwnames[] = {
22279 (char *) "renderer", NULL
22280 };
22281
22282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RendererNative_Set",kwnames,&obj0)) goto fail;
22283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
22284 if (SWIG_arg_fail(1)) SWIG_fail;
22285 {
22286 PyThreadState* __tstate = wxPyBeginAllowThreads();
22287 result = (wxRendererNative *)wxRendererNative::Set(arg1);
22288
22289 wxPyEndAllowThreads(__tstate);
22290 if (PyErr_Occurred()) SWIG_fail;
22291 }
22292 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRendererNative, 0);
22293 return resultobj;
22294 fail:
22295 return NULL;
22296 }
22297
22298
22299 static PyObject *_wrap_RendererNative_GetVersion(PyObject *, PyObject *args, PyObject *kwargs) {
22300 PyObject *resultobj;
22301 wxRendererNative *arg1 = (wxRendererNative *) 0 ;
22302 SwigValueWrapper<wxRendererVersion > result;
22303 PyObject * obj0 = 0 ;
22304 char *kwnames[] = {
22305 (char *) "self", NULL
22306 };
22307
22308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RendererNative_GetVersion",kwnames,&obj0)) goto fail;
22309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRendererNative, SWIG_POINTER_EXCEPTION | 0);
22310 if (SWIG_arg_fail(1)) SWIG_fail;
22311 {
22312 PyThreadState* __tstate = wxPyBeginAllowThreads();
22313 result = ((wxRendererNative const *)arg1)->GetVersion();
22314
22315 wxPyEndAllowThreads(__tstate);
22316 if (PyErr_Occurred()) SWIG_fail;
22317 }
22318 {
22319 wxRendererVersion * resultptr;
22320 resultptr = new wxRendererVersion((wxRendererVersion &)(result));
22321 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRendererVersion, 1);
22322 }
22323 return resultobj;
22324 fail:
22325 return NULL;
22326 }
22327
22328
22329 static PyObject * RendererNative_swigregister(PyObject *, PyObject *args) {
22330 PyObject *obj;
22331 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22332 SWIG_TypeClientData(SWIGTYPE_p_wxRendererNative, obj);
22333 Py_INCREF(obj);
22334 return Py_BuildValue((char *)"");
22335 }
22336 static PyMethodDef SwigMethods[] = {
22337 { (char *)"new_GDIObject", (PyCFunction) _wrap_new_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
22338 { (char *)"delete_GDIObject", (PyCFunction) _wrap_delete_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
22339 { (char *)"GDIObject_GetVisible", (PyCFunction) _wrap_GDIObject_GetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
22340 { (char *)"GDIObject_SetVisible", (PyCFunction) _wrap_GDIObject_SetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
22341 { (char *)"GDIObject_IsNull", (PyCFunction) _wrap_GDIObject_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
22342 { (char *)"GDIObject_swigregister", GDIObject_swigregister, METH_VARARGS, NULL},
22343 { (char *)"new_Colour", (PyCFunction) _wrap_new_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
22344 { (char *)"new_NamedColour", (PyCFunction) _wrap_new_NamedColour, METH_VARARGS | METH_KEYWORDS, NULL},
22345 { (char *)"new_ColourRGB", (PyCFunction) _wrap_new_ColourRGB, METH_VARARGS | METH_KEYWORDS, NULL},
22346 { (char *)"delete_Colour", (PyCFunction) _wrap_delete_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
22347 { (char *)"Colour_Red", (PyCFunction) _wrap_Colour_Red, METH_VARARGS | METH_KEYWORDS, NULL},
22348 { (char *)"Colour_Green", (PyCFunction) _wrap_Colour_Green, METH_VARARGS | METH_KEYWORDS, NULL},
22349 { (char *)"Colour_Blue", (PyCFunction) _wrap_Colour_Blue, METH_VARARGS | METH_KEYWORDS, NULL},
22350 { (char *)"Colour_Ok", (PyCFunction) _wrap_Colour_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
22351 { (char *)"Colour_Set", (PyCFunction) _wrap_Colour_Set, METH_VARARGS | METH_KEYWORDS, NULL},
22352 { (char *)"Colour_SetRGB", (PyCFunction) _wrap_Colour_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
22353 { (char *)"Colour_SetFromName", (PyCFunction) _wrap_Colour_SetFromName, METH_VARARGS | METH_KEYWORDS, NULL},
22354 { (char *)"Colour_GetPixel", (PyCFunction) _wrap_Colour_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
22355 { (char *)"Colour___eq__", (PyCFunction) _wrap_Colour___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
22356 { (char *)"Colour___ne__", (PyCFunction) _wrap_Colour___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
22357 { (char *)"Colour_Get", (PyCFunction) _wrap_Colour_Get, METH_VARARGS | METH_KEYWORDS, NULL},
22358 { (char *)"Colour_GetRGB", (PyCFunction) _wrap_Colour_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
22359 { (char *)"Colour_swigregister", Colour_swigregister, METH_VARARGS, NULL},
22360 { (char *)"new_Palette", (PyCFunction) _wrap_new_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
22361 { (char *)"delete_Palette", (PyCFunction) _wrap_delete_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
22362 { (char *)"Palette_GetPixel", (PyCFunction) _wrap_Palette_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
22363 { (char *)"Palette_GetRGB", (PyCFunction) _wrap_Palette_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
22364 { (char *)"Palette_GetColoursCount", (PyCFunction) _wrap_Palette_GetColoursCount, METH_VARARGS | METH_KEYWORDS, NULL},
22365 { (char *)"Palette_Ok", (PyCFunction) _wrap_Palette_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
22366 { (char *)"Palette_swigregister", Palette_swigregister, METH_VARARGS, NULL},
22367 { (char *)"new_Pen", (PyCFunction) _wrap_new_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
22368 { (char *)"delete_Pen", (PyCFunction) _wrap_delete_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
22369 { (char *)"Pen_GetCap", (PyCFunction) _wrap_Pen_GetCap, METH_VARARGS | METH_KEYWORDS, NULL},
22370 { (char *)"Pen_GetColour", (PyCFunction) _wrap_Pen_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
22371 { (char *)"Pen_GetJoin", (PyCFunction) _wrap_Pen_GetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
22372 { (char *)"Pen_GetStyle", (PyCFunction) _wrap_Pen_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
22373 { (char *)"Pen_GetWidth", (PyCFunction) _wrap_Pen_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
22374 { (char *)"Pen_Ok", (PyCFunction) _wrap_Pen_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
22375 { (char *)"Pen_SetCap", (PyCFunction) _wrap_Pen_SetCap, METH_VARARGS | METH_KEYWORDS, NULL},
22376 { (char *)"Pen_SetColour", (PyCFunction) _wrap_Pen_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
22377 { (char *)"Pen_SetJoin", (PyCFunction) _wrap_Pen_SetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
22378 { (char *)"Pen_SetStyle", (PyCFunction) _wrap_Pen_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
22379 { (char *)"Pen_SetWidth", (PyCFunction) _wrap_Pen_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
22380 { (char *)"Pen_SetDashes", (PyCFunction) _wrap_Pen_SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
22381 { (char *)"Pen_GetDashes", (PyCFunction) _wrap_Pen_GetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
22382 { (char *)"Pen__SetDashes", (PyCFunction) _wrap_Pen__SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
22383 { (char *)"Pen_GetDashCount", (PyCFunction) _wrap_Pen_GetDashCount, METH_VARARGS | METH_KEYWORDS, NULL},
22384 { (char *)"Pen_GetStipple", (PyCFunction) _wrap_Pen_GetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
22385 { (char *)"Pen_SetStipple", (PyCFunction) _wrap_Pen_SetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
22386 { (char *)"Pen___eq__", (PyCFunction) _wrap_Pen___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
22387 { (char *)"Pen___ne__", (PyCFunction) _wrap_Pen___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
22388 { (char *)"Pen_swigregister", Pen_swigregister, METH_VARARGS, NULL},
22389 { (char *)"new_Brush", (PyCFunction) _wrap_new_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
22390 { (char *)"new_BrushFromBitmap", (PyCFunction) _wrap_new_BrushFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22391 { (char *)"delete_Brush", (PyCFunction) _wrap_delete_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
22392 { (char *)"Brush_SetColour", (PyCFunction) _wrap_Brush_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
22393 { (char *)"Brush_SetStyle", (PyCFunction) _wrap_Brush_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
22394 { (char *)"Brush_SetStipple", (PyCFunction) _wrap_Brush_SetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
22395 { (char *)"Brush_GetColour", (PyCFunction) _wrap_Brush_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
22396 { (char *)"Brush_GetStyle", (PyCFunction) _wrap_Brush_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
22397 { (char *)"Brush_GetStipple", (PyCFunction) _wrap_Brush_GetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
22398 { (char *)"Brush_IsHatch", (PyCFunction) _wrap_Brush_IsHatch, METH_VARARGS | METH_KEYWORDS, NULL},
22399 { (char *)"Brush_Ok", (PyCFunction) _wrap_Brush_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
22400 { (char *)"Brush_swigregister", Brush_swigregister, METH_VARARGS, NULL},
22401 { (char *)"new_Bitmap", (PyCFunction) _wrap_new_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22402 { (char *)"delete_Bitmap", (PyCFunction) _wrap_delete_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22403 { (char *)"new_EmptyBitmap", (PyCFunction) _wrap_new_EmptyBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22404 { (char *)"new_BitmapFromIcon", (PyCFunction) _wrap_new_BitmapFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
22405 { (char *)"new_BitmapFromImage", (PyCFunction) _wrap_new_BitmapFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
22406 { (char *)"new_BitmapFromXPMData", (PyCFunction) _wrap_new_BitmapFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
22407 { (char *)"new_BitmapFromBits", (PyCFunction) _wrap_new_BitmapFromBits, METH_VARARGS | METH_KEYWORDS, NULL},
22408 { (char *)"Bitmap_GetHandle", (PyCFunction) _wrap_Bitmap_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
22409 { (char *)"Bitmap_SetHandle", (PyCFunction) _wrap_Bitmap_SetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
22410 { (char *)"Bitmap_Ok", (PyCFunction) _wrap_Bitmap_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
22411 { (char *)"Bitmap_GetWidth", (PyCFunction) _wrap_Bitmap_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
22412 { (char *)"Bitmap_GetHeight", (PyCFunction) _wrap_Bitmap_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
22413 { (char *)"Bitmap_GetDepth", (PyCFunction) _wrap_Bitmap_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
22414 { (char *)"Bitmap_GetSize", (PyCFunction) _wrap_Bitmap_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
22415 { (char *)"Bitmap_ConvertToImage", (PyCFunction) _wrap_Bitmap_ConvertToImage, METH_VARARGS | METH_KEYWORDS, NULL},
22416 { (char *)"Bitmap_GetMask", (PyCFunction) _wrap_Bitmap_GetMask, METH_VARARGS | METH_KEYWORDS, NULL},
22417 { (char *)"Bitmap_SetMask", (PyCFunction) _wrap_Bitmap_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
22418 { (char *)"Bitmap_SetMaskColour", (PyCFunction) _wrap_Bitmap_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
22419 { (char *)"Bitmap_GetSubBitmap", (PyCFunction) _wrap_Bitmap_GetSubBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22420 { (char *)"Bitmap_SaveFile", (PyCFunction) _wrap_Bitmap_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
22421 { (char *)"Bitmap_LoadFile", (PyCFunction) _wrap_Bitmap_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
22422 { (char *)"Bitmap_GetPalette", (PyCFunction) _wrap_Bitmap_GetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
22423 { (char *)"Bitmap_SetPalette", (PyCFunction) _wrap_Bitmap_SetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
22424 { (char *)"Bitmap_CopyFromIcon", (PyCFunction) _wrap_Bitmap_CopyFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
22425 { (char *)"Bitmap_SetHeight", (PyCFunction) _wrap_Bitmap_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
22426 { (char *)"Bitmap_SetWidth", (PyCFunction) _wrap_Bitmap_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
22427 { (char *)"Bitmap_SetDepth", (PyCFunction) _wrap_Bitmap_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
22428 { (char *)"Bitmap_SetSize", (PyCFunction) _wrap_Bitmap_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
22429 { (char *)"Bitmap_CopyFromCursor", (PyCFunction) _wrap_Bitmap_CopyFromCursor, METH_VARARGS | METH_KEYWORDS, NULL},
22430 { (char *)"Bitmap_GetQuality", (PyCFunction) _wrap_Bitmap_GetQuality, METH_VARARGS | METH_KEYWORDS, NULL},
22431 { (char *)"Bitmap_SetQuality", (PyCFunction) _wrap_Bitmap_SetQuality, METH_VARARGS | METH_KEYWORDS, NULL},
22432 { (char *)"Bitmap___eq__", (PyCFunction) _wrap_Bitmap___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
22433 { (char *)"Bitmap___ne__", (PyCFunction) _wrap_Bitmap___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
22434 { (char *)"Bitmap_swigregister", Bitmap_swigregister, METH_VARARGS, NULL},
22435 { (char *)"new_Mask", (PyCFunction) _wrap_new_Mask, METH_VARARGS | METH_KEYWORDS, NULL},
22436 { (char *)"Mask_swigregister", Mask_swigregister, METH_VARARGS, NULL},
22437 { (char *)"new_Icon", (PyCFunction) _wrap_new_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
22438 { (char *)"delete_Icon", (PyCFunction) _wrap_delete_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
22439 { (char *)"new_EmptyIcon", (PyCFunction) _wrap_new_EmptyIcon, METH_VARARGS | METH_KEYWORDS, NULL},
22440 { (char *)"new_IconFromLocation", (PyCFunction) _wrap_new_IconFromLocation, METH_VARARGS | METH_KEYWORDS, NULL},
22441 { (char *)"new_IconFromBitmap", (PyCFunction) _wrap_new_IconFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22442 { (char *)"new_IconFromXPMData", (PyCFunction) _wrap_new_IconFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
22443 { (char *)"Icon_LoadFile", (PyCFunction) _wrap_Icon_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
22444 { (char *)"Icon_GetHandle", (PyCFunction) _wrap_Icon_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
22445 { (char *)"Icon_SetHandle", (PyCFunction) _wrap_Icon_SetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
22446 { (char *)"Icon_Ok", (PyCFunction) _wrap_Icon_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
22447 { (char *)"Icon_GetWidth", (PyCFunction) _wrap_Icon_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
22448 { (char *)"Icon_GetHeight", (PyCFunction) _wrap_Icon_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
22449 { (char *)"Icon_GetDepth", (PyCFunction) _wrap_Icon_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
22450 { (char *)"Icon_SetWidth", (PyCFunction) _wrap_Icon_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
22451 { (char *)"Icon_SetHeight", (PyCFunction) _wrap_Icon_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
22452 { (char *)"Icon_SetDepth", (PyCFunction) _wrap_Icon_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
22453 { (char *)"Icon_SetSize", (PyCFunction) _wrap_Icon_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
22454 { (char *)"Icon_CopyFromBitmap", (PyCFunction) _wrap_Icon_CopyFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22455 { (char *)"Icon_swigregister", Icon_swigregister, METH_VARARGS, NULL},
22456 { (char *)"new_IconLocation", (PyCFunction) _wrap_new_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
22457 { (char *)"delete_IconLocation", (PyCFunction) _wrap_delete_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
22458 { (char *)"IconLocation_IsOk", (PyCFunction) _wrap_IconLocation_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
22459 { (char *)"IconLocation_SetFileName", (PyCFunction) _wrap_IconLocation_SetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
22460 { (char *)"IconLocation_GetFileName", (PyCFunction) _wrap_IconLocation_GetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
22461 { (char *)"IconLocation_SetIndex", (PyCFunction) _wrap_IconLocation_SetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
22462 { (char *)"IconLocation_GetIndex", (PyCFunction) _wrap_IconLocation_GetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
22463 { (char *)"IconLocation_swigregister", IconLocation_swigregister, METH_VARARGS, NULL},
22464 { (char *)"new_IconBundle", (PyCFunction) _wrap_new_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
22465 { (char *)"new_IconBundleFromFile", (PyCFunction) _wrap_new_IconBundleFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
22466 { (char *)"new_IconBundleFromIcon", (PyCFunction) _wrap_new_IconBundleFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
22467 { (char *)"delete_IconBundle", (PyCFunction) _wrap_delete_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
22468 { (char *)"IconBundle_AddIcon", (PyCFunction) _wrap_IconBundle_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
22469 { (char *)"IconBundle_AddIconFromFile", (PyCFunction) _wrap_IconBundle_AddIconFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
22470 { (char *)"IconBundle_GetIcon", (PyCFunction) _wrap_IconBundle_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
22471 { (char *)"IconBundle_swigregister", IconBundle_swigregister, METH_VARARGS, NULL},
22472 { (char *)"new_Cursor", (PyCFunction) _wrap_new_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
22473 { (char *)"delete_Cursor", (PyCFunction) _wrap_delete_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
22474 { (char *)"new_StockCursor", (PyCFunction) _wrap_new_StockCursor, METH_VARARGS | METH_KEYWORDS, NULL},
22475 { (char *)"new_CursorFromImage", (PyCFunction) _wrap_new_CursorFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
22476 { (char *)"Cursor_GetHandle", (PyCFunction) _wrap_Cursor_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
22477 { (char *)"Cursor_SetHandle", (PyCFunction) _wrap_Cursor_SetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
22478 { (char *)"Cursor_Ok", (PyCFunction) _wrap_Cursor_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
22479 { (char *)"Cursor_GetWidth", (PyCFunction) _wrap_Cursor_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
22480 { (char *)"Cursor_GetHeight", (PyCFunction) _wrap_Cursor_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
22481 { (char *)"Cursor_GetDepth", (PyCFunction) _wrap_Cursor_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
22482 { (char *)"Cursor_SetWidth", (PyCFunction) _wrap_Cursor_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
22483 { (char *)"Cursor_SetHeight", (PyCFunction) _wrap_Cursor_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
22484 { (char *)"Cursor_SetDepth", (PyCFunction) _wrap_Cursor_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
22485 { (char *)"Cursor_SetSize", (PyCFunction) _wrap_Cursor_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
22486 { (char *)"Cursor_swigregister", Cursor_swigregister, METH_VARARGS, NULL},
22487 { (char *)"new_Region", (PyCFunction) _wrap_new_Region, METH_VARARGS | METH_KEYWORDS, NULL},
22488 { (char *)"new_RegionFromBitmap", (PyCFunction) _wrap_new_RegionFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22489 { (char *)"new_RegionFromBitmapColour", (PyCFunction) _wrap_new_RegionFromBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
22490 { (char *)"new_RegionFromPoints", (PyCFunction) _wrap_new_RegionFromPoints, METH_VARARGS | METH_KEYWORDS, NULL},
22491 { (char *)"delete_Region", (PyCFunction) _wrap_delete_Region, METH_VARARGS | METH_KEYWORDS, NULL},
22492 { (char *)"Region_Clear", (PyCFunction) _wrap_Region_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
22493 { (char *)"Region_Offset", (PyCFunction) _wrap_Region_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
22494 { (char *)"Region_Contains", (PyCFunction) _wrap_Region_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
22495 { (char *)"Region_ContainsPoint", (PyCFunction) _wrap_Region_ContainsPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22496 { (char *)"Region_ContainsRect", (PyCFunction) _wrap_Region_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
22497 { (char *)"Region_ContainsRectDim", (PyCFunction) _wrap_Region_ContainsRectDim, METH_VARARGS | METH_KEYWORDS, NULL},
22498 { (char *)"Region_GetBox", (PyCFunction) _wrap_Region_GetBox, METH_VARARGS | METH_KEYWORDS, NULL},
22499 { (char *)"Region_Intersect", (PyCFunction) _wrap_Region_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
22500 { (char *)"Region_IntersectRect", (PyCFunction) _wrap_Region_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
22501 { (char *)"Region_IntersectRegion", (PyCFunction) _wrap_Region_IntersectRegion, METH_VARARGS | METH_KEYWORDS, NULL},
22502 { (char *)"Region_IsEmpty", (PyCFunction) _wrap_Region_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
22503 { (char *)"Region_Union", (PyCFunction) _wrap_Region_Union, METH_VARARGS | METH_KEYWORDS, NULL},
22504 { (char *)"Region_UnionRect", (PyCFunction) _wrap_Region_UnionRect, METH_VARARGS | METH_KEYWORDS, NULL},
22505 { (char *)"Region_UnionRegion", (PyCFunction) _wrap_Region_UnionRegion, METH_VARARGS | METH_KEYWORDS, NULL},
22506 { (char *)"Region_Subtract", (PyCFunction) _wrap_Region_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
22507 { (char *)"Region_SubtractRect", (PyCFunction) _wrap_Region_SubtractRect, METH_VARARGS | METH_KEYWORDS, NULL},
22508 { (char *)"Region_SubtractRegion", (PyCFunction) _wrap_Region_SubtractRegion, METH_VARARGS | METH_KEYWORDS, NULL},
22509 { (char *)"Region_Xor", (PyCFunction) _wrap_Region_Xor, METH_VARARGS | METH_KEYWORDS, NULL},
22510 { (char *)"Region_XorRect", (PyCFunction) _wrap_Region_XorRect, METH_VARARGS | METH_KEYWORDS, NULL},
22511 { (char *)"Region_XorRegion", (PyCFunction) _wrap_Region_XorRegion, METH_VARARGS | METH_KEYWORDS, NULL},
22512 { (char *)"Region_ConvertToBitmap", (PyCFunction) _wrap_Region_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22513 { (char *)"Region_UnionBitmap", (PyCFunction) _wrap_Region_UnionBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22514 { (char *)"Region_UnionBitmapColour", (PyCFunction) _wrap_Region_UnionBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
22515 { (char *)"Region_swigregister", Region_swigregister, METH_VARARGS, NULL},
22516 { (char *)"new_RegionIterator", (PyCFunction) _wrap_new_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
22517 { (char *)"delete_RegionIterator", (PyCFunction) _wrap_delete_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
22518 { (char *)"RegionIterator_GetX", (PyCFunction) _wrap_RegionIterator_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
22519 { (char *)"RegionIterator_GetY", (PyCFunction) _wrap_RegionIterator_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
22520 { (char *)"RegionIterator_GetW", (PyCFunction) _wrap_RegionIterator_GetW, METH_VARARGS | METH_KEYWORDS, NULL},
22521 { (char *)"RegionIterator_GetWidth", (PyCFunction) _wrap_RegionIterator_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
22522 { (char *)"RegionIterator_GetH", (PyCFunction) _wrap_RegionIterator_GetH, METH_VARARGS | METH_KEYWORDS, NULL},
22523 { (char *)"RegionIterator_GetHeight", (PyCFunction) _wrap_RegionIterator_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
22524 { (char *)"RegionIterator_GetRect", (PyCFunction) _wrap_RegionIterator_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
22525 { (char *)"RegionIterator_HaveRects", (PyCFunction) _wrap_RegionIterator_HaveRects, METH_VARARGS | METH_KEYWORDS, NULL},
22526 { (char *)"RegionIterator_Reset", (PyCFunction) _wrap_RegionIterator_Reset, METH_VARARGS | METH_KEYWORDS, NULL},
22527 { (char *)"RegionIterator_Next", (PyCFunction) _wrap_RegionIterator_Next, METH_VARARGS | METH_KEYWORDS, NULL},
22528 { (char *)"RegionIterator___nonzero__", (PyCFunction) _wrap_RegionIterator___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
22529 { (char *)"RegionIterator_swigregister", RegionIterator_swigregister, METH_VARARGS, NULL},
22530 { (char *)"new_NativeFontInfo", (PyCFunction) _wrap_new_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
22531 { (char *)"delete_NativeFontInfo", (PyCFunction) _wrap_delete_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
22532 { (char *)"NativeFontInfo_Init", (PyCFunction) _wrap_NativeFontInfo_Init, METH_VARARGS | METH_KEYWORDS, NULL},
22533 { (char *)"NativeFontInfo_InitFromFont", (PyCFunction) _wrap_NativeFontInfo_InitFromFont, METH_VARARGS | METH_KEYWORDS, NULL},
22534 { (char *)"NativeFontInfo_GetPointSize", (PyCFunction) _wrap_NativeFontInfo_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
22535 { (char *)"NativeFontInfo_GetPixelSize", (PyCFunction) _wrap_NativeFontInfo_GetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
22536 { (char *)"NativeFontInfo_GetStyle", (PyCFunction) _wrap_NativeFontInfo_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
22537 { (char *)"NativeFontInfo_GetWeight", (PyCFunction) _wrap_NativeFontInfo_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
22538 { (char *)"NativeFontInfo_GetUnderlined", (PyCFunction) _wrap_NativeFontInfo_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
22539 { (char *)"NativeFontInfo_GetFaceName", (PyCFunction) _wrap_NativeFontInfo_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
22540 { (char *)"NativeFontInfo_GetFamily", (PyCFunction) _wrap_NativeFontInfo_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
22541 { (char *)"NativeFontInfo_GetEncoding", (PyCFunction) _wrap_NativeFontInfo_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
22542 { (char *)"NativeFontInfo_SetPointSize", (PyCFunction) _wrap_NativeFontInfo_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
22543 { (char *)"NativeFontInfo_SetPixelSize", (PyCFunction) _wrap_NativeFontInfo_SetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
22544 { (char *)"NativeFontInfo_SetStyle", (PyCFunction) _wrap_NativeFontInfo_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
22545 { (char *)"NativeFontInfo_SetWeight", (PyCFunction) _wrap_NativeFontInfo_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
22546 { (char *)"NativeFontInfo_SetUnderlined", (PyCFunction) _wrap_NativeFontInfo_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
22547 { (char *)"NativeFontInfo_SetFaceName", (PyCFunction) _wrap_NativeFontInfo_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
22548 { (char *)"NativeFontInfo_SetFamily", (PyCFunction) _wrap_NativeFontInfo_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
22549 { (char *)"NativeFontInfo_SetEncoding", (PyCFunction) _wrap_NativeFontInfo_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
22550 { (char *)"NativeFontInfo_FromString", (PyCFunction) _wrap_NativeFontInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
22551 { (char *)"NativeFontInfo_ToString", (PyCFunction) _wrap_NativeFontInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
22552 { (char *)"NativeFontInfo___str__", (PyCFunction) _wrap_NativeFontInfo___str__, METH_VARARGS | METH_KEYWORDS, NULL},
22553 { (char *)"NativeFontInfo_FromUserString", (PyCFunction) _wrap_NativeFontInfo_FromUserString, METH_VARARGS | METH_KEYWORDS, NULL},
22554 { (char *)"NativeFontInfo_ToUserString", (PyCFunction) _wrap_NativeFontInfo_ToUserString, METH_VARARGS | METH_KEYWORDS, NULL},
22555 { (char *)"NativeFontInfo_swigregister", NativeFontInfo_swigregister, METH_VARARGS, NULL},
22556 { (char *)"NativeEncodingInfo_facename_set", (PyCFunction) _wrap_NativeEncodingInfo_facename_set, METH_VARARGS | METH_KEYWORDS, NULL},
22557 { (char *)"NativeEncodingInfo_facename_get", (PyCFunction) _wrap_NativeEncodingInfo_facename_get, METH_VARARGS | METH_KEYWORDS, NULL},
22558 { (char *)"NativeEncodingInfo_encoding_set", (PyCFunction) _wrap_NativeEncodingInfo_encoding_set, METH_VARARGS | METH_KEYWORDS, NULL},
22559 { (char *)"NativeEncodingInfo_encoding_get", (PyCFunction) _wrap_NativeEncodingInfo_encoding_get, METH_VARARGS | METH_KEYWORDS, NULL},
22560 { (char *)"new_NativeEncodingInfo", (PyCFunction) _wrap_new_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
22561 { (char *)"delete_NativeEncodingInfo", (PyCFunction) _wrap_delete_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
22562 { (char *)"NativeEncodingInfo_FromString", (PyCFunction) _wrap_NativeEncodingInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
22563 { (char *)"NativeEncodingInfo_ToString", (PyCFunction) _wrap_NativeEncodingInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
22564 { (char *)"NativeEncodingInfo_swigregister", NativeEncodingInfo_swigregister, METH_VARARGS, NULL},
22565 { (char *)"GetNativeFontEncoding", (PyCFunction) _wrap_GetNativeFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
22566 { (char *)"TestFontEncoding", (PyCFunction) _wrap_TestFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
22567 { (char *)"new_FontMapper", (PyCFunction) _wrap_new_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
22568 { (char *)"delete_FontMapper", (PyCFunction) _wrap_delete_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
22569 { (char *)"FontMapper_Get", (PyCFunction) _wrap_FontMapper_Get, METH_VARARGS | METH_KEYWORDS, NULL},
22570 { (char *)"FontMapper_Set", (PyCFunction) _wrap_FontMapper_Set, METH_VARARGS | METH_KEYWORDS, NULL},
22571 { (char *)"FontMapper_CharsetToEncoding", (PyCFunction) _wrap_FontMapper_CharsetToEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
22572 { (char *)"FontMapper_GetSupportedEncodingsCount", (PyCFunction) _wrap_FontMapper_GetSupportedEncodingsCount, METH_VARARGS | METH_KEYWORDS, NULL},
22573 { (char *)"FontMapper_GetEncoding", (PyCFunction) _wrap_FontMapper_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
22574 { (char *)"FontMapper_GetEncodingName", (PyCFunction) _wrap_FontMapper_GetEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
22575 { (char *)"FontMapper_GetEncodingDescription", (PyCFunction) _wrap_FontMapper_GetEncodingDescription, METH_VARARGS | METH_KEYWORDS, NULL},
22576 { (char *)"FontMapper_GetEncodingFromName", (PyCFunction) _wrap_FontMapper_GetEncodingFromName, METH_VARARGS | METH_KEYWORDS, NULL},
22577 { (char *)"FontMapper_SetConfig", (PyCFunction) _wrap_FontMapper_SetConfig, METH_VARARGS | METH_KEYWORDS, NULL},
22578 { (char *)"FontMapper_SetConfigPath", (PyCFunction) _wrap_FontMapper_SetConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
22579 { (char *)"FontMapper_GetDefaultConfigPath", (PyCFunction) _wrap_FontMapper_GetDefaultConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
22580 { (char *)"FontMapper_GetAltForEncoding", (PyCFunction) _wrap_FontMapper_GetAltForEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
22581 { (char *)"FontMapper_IsEncodingAvailable", (PyCFunction) _wrap_FontMapper_IsEncodingAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
22582 { (char *)"FontMapper_SetDialogParent", (PyCFunction) _wrap_FontMapper_SetDialogParent, METH_VARARGS | METH_KEYWORDS, NULL},
22583 { (char *)"FontMapper_SetDialogTitle", (PyCFunction) _wrap_FontMapper_SetDialogTitle, METH_VARARGS | METH_KEYWORDS, NULL},
22584 { (char *)"FontMapper_swigregister", FontMapper_swigregister, METH_VARARGS, NULL},
22585 { (char *)"new_Font", (PyCFunction) _wrap_new_Font, METH_VARARGS | METH_KEYWORDS, NULL},
22586 { (char *)"delete_Font", (PyCFunction) _wrap_delete_Font, METH_VARARGS | METH_KEYWORDS, NULL},
22587 { (char *)"new_FontFromNativeInfo", (PyCFunction) _wrap_new_FontFromNativeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
22588 { (char *)"new_FontFromNativeInfoString", (PyCFunction) _wrap_new_FontFromNativeInfoString, METH_VARARGS | METH_KEYWORDS, NULL},
22589 { (char *)"new_FFont", (PyCFunction) _wrap_new_FFont, METH_VARARGS | METH_KEYWORDS, NULL},
22590 { (char *)"new_FontFromPixelSize", (PyCFunction) _wrap_new_FontFromPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
22591 { (char *)"new_FFontFromPixelSize", (PyCFunction) _wrap_new_FFontFromPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
22592 { (char *)"Font_Ok", (PyCFunction) _wrap_Font_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
22593 { (char *)"Font___eq__", (PyCFunction) _wrap_Font___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
22594 { (char *)"Font___ne__", (PyCFunction) _wrap_Font___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
22595 { (char *)"Font_GetPointSize", (PyCFunction) _wrap_Font_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
22596 { (char *)"Font_GetPixelSize", (PyCFunction) _wrap_Font_GetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
22597 { (char *)"Font_IsUsingSizeInPixels", (PyCFunction) _wrap_Font_IsUsingSizeInPixels, METH_VARARGS | METH_KEYWORDS, NULL},
22598 { (char *)"Font_GetFamily", (PyCFunction) _wrap_Font_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
22599 { (char *)"Font_GetStyle", (PyCFunction) _wrap_Font_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
22600 { (char *)"Font_GetWeight", (PyCFunction) _wrap_Font_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
22601 { (char *)"Font_GetUnderlined", (PyCFunction) _wrap_Font_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
22602 { (char *)"Font_GetFaceName", (PyCFunction) _wrap_Font_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
22603 { (char *)"Font_GetEncoding", (PyCFunction) _wrap_Font_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
22604 { (char *)"Font_GetNativeFontInfo", (PyCFunction) _wrap_Font_GetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
22605 { (char *)"Font_IsFixedWidth", (PyCFunction) _wrap_Font_IsFixedWidth, METH_VARARGS | METH_KEYWORDS, NULL},
22606 { (char *)"Font_GetNativeFontInfoDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoDesc, METH_VARARGS | METH_KEYWORDS, NULL},
22607 { (char *)"Font_GetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
22608 { (char *)"Font_SetPointSize", (PyCFunction) _wrap_Font_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
22609 { (char *)"Font_SetPixelSize", (PyCFunction) _wrap_Font_SetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
22610 { (char *)"Font_SetFamily", (PyCFunction) _wrap_Font_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
22611 { (char *)"Font_SetStyle", (PyCFunction) _wrap_Font_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
22612 { (char *)"Font_SetWeight", (PyCFunction) _wrap_Font_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
22613 { (char *)"Font_SetFaceName", (PyCFunction) _wrap_Font_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
22614 { (char *)"Font_SetUnderlined", (PyCFunction) _wrap_Font_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
22615 { (char *)"Font_SetEncoding", (PyCFunction) _wrap_Font_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
22616 { (char *)"Font_SetNativeFontInfo", (PyCFunction) _wrap_Font_SetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
22617 { (char *)"Font_SetNativeFontInfoFromString", (PyCFunction) _wrap_Font_SetNativeFontInfoFromString, METH_VARARGS | METH_KEYWORDS, NULL},
22618 { (char *)"Font_SetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_SetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
22619 { (char *)"Font_GetFamilyString", (PyCFunction) _wrap_Font_GetFamilyString, METH_VARARGS | METH_KEYWORDS, NULL},
22620 { (char *)"Font_GetStyleString", (PyCFunction) _wrap_Font_GetStyleString, METH_VARARGS | METH_KEYWORDS, NULL},
22621 { (char *)"Font_GetWeightString", (PyCFunction) _wrap_Font_GetWeightString, METH_VARARGS | METH_KEYWORDS, NULL},
22622 { (char *)"Font_SetNoAntiAliasing", (PyCFunction) _wrap_Font_SetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
22623 { (char *)"Font_GetNoAntiAliasing", (PyCFunction) _wrap_Font_GetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
22624 { (char *)"Font_GetDefaultEncoding", (PyCFunction) _wrap_Font_GetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
22625 { (char *)"Font_SetDefaultEncoding", (PyCFunction) _wrap_Font_SetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
22626 { (char *)"Font_swigregister", Font_swigregister, METH_VARARGS, NULL},
22627 { (char *)"new_FontEnumerator", (PyCFunction) _wrap_new_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
22628 { (char *)"delete_FontEnumerator", (PyCFunction) _wrap_delete_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
22629 { (char *)"FontEnumerator__setCallbackInfo", (PyCFunction) _wrap_FontEnumerator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
22630 { (char *)"FontEnumerator_EnumerateFacenames", (PyCFunction) _wrap_FontEnumerator_EnumerateFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
22631 { (char *)"FontEnumerator_EnumerateEncodings", (PyCFunction) _wrap_FontEnumerator_EnumerateEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
22632 { (char *)"FontEnumerator_GetEncodings", (PyCFunction) _wrap_FontEnumerator_GetEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
22633 { (char *)"FontEnumerator_GetFacenames", (PyCFunction) _wrap_FontEnumerator_GetFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
22634 { (char *)"FontEnumerator_swigregister", FontEnumerator_swigregister, METH_VARARGS, NULL},
22635 { (char *)"LanguageInfo_Language_set", (PyCFunction) _wrap_LanguageInfo_Language_set, METH_VARARGS | METH_KEYWORDS, NULL},
22636 { (char *)"LanguageInfo_Language_get", (PyCFunction) _wrap_LanguageInfo_Language_get, METH_VARARGS | METH_KEYWORDS, NULL},
22637 { (char *)"LanguageInfo_CanonicalName_set", (PyCFunction) _wrap_LanguageInfo_CanonicalName_set, METH_VARARGS | METH_KEYWORDS, NULL},
22638 { (char *)"LanguageInfo_CanonicalName_get", (PyCFunction) _wrap_LanguageInfo_CanonicalName_get, METH_VARARGS | METH_KEYWORDS, NULL},
22639 { (char *)"LanguageInfo_Description_set", (PyCFunction) _wrap_LanguageInfo_Description_set, METH_VARARGS | METH_KEYWORDS, NULL},
22640 { (char *)"LanguageInfo_Description_get", (PyCFunction) _wrap_LanguageInfo_Description_get, METH_VARARGS | METH_KEYWORDS, NULL},
22641 { (char *)"LanguageInfo_swigregister", LanguageInfo_swigregister, METH_VARARGS, NULL},
22642 { (char *)"new_Locale", (PyCFunction) _wrap_new_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
22643 { (char *)"delete_Locale", (PyCFunction) _wrap_delete_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
22644 { (char *)"Locale_Init1", (PyCFunction) _wrap_Locale_Init1, METH_VARARGS | METH_KEYWORDS, NULL},
22645 { (char *)"Locale_Init2", (PyCFunction) _wrap_Locale_Init2, METH_VARARGS | METH_KEYWORDS, NULL},
22646 { (char *)"Locale_GetSystemLanguage", (PyCFunction) _wrap_Locale_GetSystemLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
22647 { (char *)"Locale_GetSystemEncoding", (PyCFunction) _wrap_Locale_GetSystemEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
22648 { (char *)"Locale_GetSystemEncodingName", (PyCFunction) _wrap_Locale_GetSystemEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
22649 { (char *)"Locale_IsOk", (PyCFunction) _wrap_Locale_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
22650 { (char *)"Locale_GetLocale", (PyCFunction) _wrap_Locale_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
22651 { (char *)"Locale_GetLanguage", (PyCFunction) _wrap_Locale_GetLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
22652 { (char *)"Locale_GetSysName", (PyCFunction) _wrap_Locale_GetSysName, METH_VARARGS | METH_KEYWORDS, NULL},
22653 { (char *)"Locale_GetCanonicalName", (PyCFunction) _wrap_Locale_GetCanonicalName, METH_VARARGS | METH_KEYWORDS, NULL},
22654 { (char *)"Locale_AddCatalogLookupPathPrefix", (PyCFunction) _wrap_Locale_AddCatalogLookupPathPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
22655 { (char *)"Locale_AddCatalog", (PyCFunction) _wrap_Locale_AddCatalog, METH_VARARGS | METH_KEYWORDS, NULL},
22656 { (char *)"Locale_IsLoaded", (PyCFunction) _wrap_Locale_IsLoaded, METH_VARARGS | METH_KEYWORDS, NULL},
22657 { (char *)"Locale_GetLanguageInfo", (PyCFunction) _wrap_Locale_GetLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
22658 { (char *)"Locale_GetLanguageName", (PyCFunction) _wrap_Locale_GetLanguageName, METH_VARARGS | METH_KEYWORDS, NULL},
22659 { (char *)"Locale_FindLanguageInfo", (PyCFunction) _wrap_Locale_FindLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
22660 { (char *)"Locale_AddLanguage", (PyCFunction) _wrap_Locale_AddLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
22661 { (char *)"Locale_GetString", (PyCFunction) _wrap_Locale_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
22662 { (char *)"Locale_GetName", (PyCFunction) _wrap_Locale_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
22663 { (char *)"Locale_swigregister", Locale_swigregister, METH_VARARGS, NULL},
22664 { (char *)"GetLocale", (PyCFunction) _wrap_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
22665 { (char *)"GetTranslation", _wrap_GetTranslation, METH_VARARGS, NULL},
22666 { (char *)"new_EncodingConverter", (PyCFunction) _wrap_new_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
22667 { (char *)"delete_EncodingConverter", (PyCFunction) _wrap_delete_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
22668 { (char *)"EncodingConverter_Init", (PyCFunction) _wrap_EncodingConverter_Init, METH_VARARGS | METH_KEYWORDS, NULL},
22669 { (char *)"EncodingConverter_Convert", (PyCFunction) _wrap_EncodingConverter_Convert, METH_VARARGS | METH_KEYWORDS, NULL},
22670 { (char *)"EncodingConverter_GetPlatformEquivalents", (PyCFunction) _wrap_EncodingConverter_GetPlatformEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
22671 { (char *)"EncodingConverter_GetAllEquivalents", (PyCFunction) _wrap_EncodingConverter_GetAllEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
22672 { (char *)"EncodingConverter_CanConvert", (PyCFunction) _wrap_EncodingConverter_CanConvert, METH_VARARGS | METH_KEYWORDS, NULL},
22673 { (char *)"EncodingConverter_swigregister", EncodingConverter_swigregister, METH_VARARGS, NULL},
22674 { (char *)"delete_DC", (PyCFunction) _wrap_delete_DC, METH_VARARGS | METH_KEYWORDS, NULL},
22675 { (char *)"DC_BeginDrawing", (PyCFunction) _wrap_DC_BeginDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
22676 { (char *)"DC_EndDrawing", (PyCFunction) _wrap_DC_EndDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
22677 { (char *)"DC_FloodFill", (PyCFunction) _wrap_DC_FloodFill, METH_VARARGS | METH_KEYWORDS, NULL},
22678 { (char *)"DC_FloodFillPoint", (PyCFunction) _wrap_DC_FloodFillPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22679 { (char *)"DC_GetPixel", (PyCFunction) _wrap_DC_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
22680 { (char *)"DC_GetPixelPoint", (PyCFunction) _wrap_DC_GetPixelPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22681 { (char *)"DC_DrawLine", (PyCFunction) _wrap_DC_DrawLine, METH_VARARGS | METH_KEYWORDS, NULL},
22682 { (char *)"DC_DrawLinePoint", (PyCFunction) _wrap_DC_DrawLinePoint, METH_VARARGS | METH_KEYWORDS, NULL},
22683 { (char *)"DC_CrossHair", (PyCFunction) _wrap_DC_CrossHair, METH_VARARGS | METH_KEYWORDS, NULL},
22684 { (char *)"DC_CrossHairPoint", (PyCFunction) _wrap_DC_CrossHairPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22685 { (char *)"DC_DrawArc", (PyCFunction) _wrap_DC_DrawArc, METH_VARARGS | METH_KEYWORDS, NULL},
22686 { (char *)"DC_DrawArcPoint", (PyCFunction) _wrap_DC_DrawArcPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22687 { (char *)"DC_DrawCheckMark", (PyCFunction) _wrap_DC_DrawCheckMark, METH_VARARGS | METH_KEYWORDS, NULL},
22688 { (char *)"DC_DrawCheckMarkRect", (PyCFunction) _wrap_DC_DrawCheckMarkRect, METH_VARARGS | METH_KEYWORDS, NULL},
22689 { (char *)"DC_DrawEllipticArc", (PyCFunction) _wrap_DC_DrawEllipticArc, METH_VARARGS | METH_KEYWORDS, NULL},
22690 { (char *)"DC_DrawEllipticArcPointSize", (PyCFunction) _wrap_DC_DrawEllipticArcPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
22691 { (char *)"DC_DrawPoint", (PyCFunction) _wrap_DC_DrawPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22692 { (char *)"DC_DrawPointPoint", (PyCFunction) _wrap_DC_DrawPointPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22693 { (char *)"DC_DrawRectangle", (PyCFunction) _wrap_DC_DrawRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
22694 { (char *)"DC_DrawRectangleRect", (PyCFunction) _wrap_DC_DrawRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
22695 { (char *)"DC_DrawRectanglePointSize", (PyCFunction) _wrap_DC_DrawRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
22696 { (char *)"DC_DrawRoundedRectangle", (PyCFunction) _wrap_DC_DrawRoundedRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
22697 { (char *)"DC_DrawRoundedRectangleRect", (PyCFunction) _wrap_DC_DrawRoundedRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
22698 { (char *)"DC_DrawRoundedRectanglePointSize", (PyCFunction) _wrap_DC_DrawRoundedRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
22699 { (char *)"DC_DrawCircle", (PyCFunction) _wrap_DC_DrawCircle, METH_VARARGS | METH_KEYWORDS, NULL},
22700 { (char *)"DC_DrawCirclePoint", (PyCFunction) _wrap_DC_DrawCirclePoint, METH_VARARGS | METH_KEYWORDS, NULL},
22701 { (char *)"DC_DrawEllipse", (PyCFunction) _wrap_DC_DrawEllipse, METH_VARARGS | METH_KEYWORDS, NULL},
22702 { (char *)"DC_DrawEllipseRect", (PyCFunction) _wrap_DC_DrawEllipseRect, METH_VARARGS | METH_KEYWORDS, NULL},
22703 { (char *)"DC_DrawEllipsePointSize", (PyCFunction) _wrap_DC_DrawEllipsePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
22704 { (char *)"DC_DrawIcon", (PyCFunction) _wrap_DC_DrawIcon, METH_VARARGS | METH_KEYWORDS, NULL},
22705 { (char *)"DC_DrawIconPoint", (PyCFunction) _wrap_DC_DrawIconPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22706 { (char *)"DC_DrawBitmap", (PyCFunction) _wrap_DC_DrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22707 { (char *)"DC_DrawBitmapPoint", (PyCFunction) _wrap_DC_DrawBitmapPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22708 { (char *)"DC_DrawText", (PyCFunction) _wrap_DC_DrawText, METH_VARARGS | METH_KEYWORDS, NULL},
22709 { (char *)"DC_DrawTextPoint", (PyCFunction) _wrap_DC_DrawTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22710 { (char *)"DC_DrawRotatedText", (PyCFunction) _wrap_DC_DrawRotatedText, METH_VARARGS | METH_KEYWORDS, NULL},
22711 { (char *)"DC_DrawRotatedTextPoint", (PyCFunction) _wrap_DC_DrawRotatedTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22712 { (char *)"DC_Blit", (PyCFunction) _wrap_DC_Blit, METH_VARARGS | METH_KEYWORDS, NULL},
22713 { (char *)"DC_BlitPointSize", (PyCFunction) _wrap_DC_BlitPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
22714 { (char *)"DC_SetClippingRegion", (PyCFunction) _wrap_DC_SetClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
22715 { (char *)"DC_SetClippingRegionPointSize", (PyCFunction) _wrap_DC_SetClippingRegionPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
22716 { (char *)"DC_SetClippingRegionAsRegion", (PyCFunction) _wrap_DC_SetClippingRegionAsRegion, METH_VARARGS | METH_KEYWORDS, NULL},
22717 { (char *)"DC_SetClippingRect", (PyCFunction) _wrap_DC_SetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
22718 { (char *)"DC_DrawLines", (PyCFunction) _wrap_DC_DrawLines, METH_VARARGS | METH_KEYWORDS, NULL},
22719 { (char *)"DC_DrawPolygon", (PyCFunction) _wrap_DC_DrawPolygon, METH_VARARGS | METH_KEYWORDS, NULL},
22720 { (char *)"DC_DrawLabel", (PyCFunction) _wrap_DC_DrawLabel, METH_VARARGS | METH_KEYWORDS, NULL},
22721 { (char *)"DC_DrawImageLabel", (PyCFunction) _wrap_DC_DrawImageLabel, METH_VARARGS | METH_KEYWORDS, NULL},
22722 { (char *)"DC_DrawSpline", (PyCFunction) _wrap_DC_DrawSpline, METH_VARARGS | METH_KEYWORDS, NULL},
22723 { (char *)"DC_Clear", (PyCFunction) _wrap_DC_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
22724 { (char *)"DC_StartDoc", (PyCFunction) _wrap_DC_StartDoc, METH_VARARGS | METH_KEYWORDS, NULL},
22725 { (char *)"DC_EndDoc", (PyCFunction) _wrap_DC_EndDoc, METH_VARARGS | METH_KEYWORDS, NULL},
22726 { (char *)"DC_StartPage", (PyCFunction) _wrap_DC_StartPage, METH_VARARGS | METH_KEYWORDS, NULL},
22727 { (char *)"DC_EndPage", (PyCFunction) _wrap_DC_EndPage, METH_VARARGS | METH_KEYWORDS, NULL},
22728 { (char *)"DC_SetFont", (PyCFunction) _wrap_DC_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
22729 { (char *)"DC_SetPen", (PyCFunction) _wrap_DC_SetPen, METH_VARARGS | METH_KEYWORDS, NULL},
22730 { (char *)"DC_SetBrush", (PyCFunction) _wrap_DC_SetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
22731 { (char *)"DC_SetBackground", (PyCFunction) _wrap_DC_SetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
22732 { (char *)"DC_SetBackgroundMode", (PyCFunction) _wrap_DC_SetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
22733 { (char *)"DC_SetPalette", (PyCFunction) _wrap_DC_SetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
22734 { (char *)"DC_DestroyClippingRegion", (PyCFunction) _wrap_DC_DestroyClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
22735 { (char *)"DC_GetClippingBox", (PyCFunction) _wrap_DC_GetClippingBox, METH_VARARGS | METH_KEYWORDS, NULL},
22736 { (char *)"DC_GetClippingRect", (PyCFunction) _wrap_DC_GetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
22737 { (char *)"DC_GetCharHeight", (PyCFunction) _wrap_DC_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
22738 { (char *)"DC_GetCharWidth", (PyCFunction) _wrap_DC_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
22739 { (char *)"DC_GetTextExtent", (PyCFunction) _wrap_DC_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
22740 { (char *)"DC_GetFullTextExtent", (PyCFunction) _wrap_DC_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
22741 { (char *)"DC_GetMultiLineTextExtent", (PyCFunction) _wrap_DC_GetMultiLineTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
22742 { (char *)"DC_GetPartialTextExtents", (PyCFunction) _wrap_DC_GetPartialTextExtents, METH_VARARGS | METH_KEYWORDS, NULL},
22743 { (char *)"DC_GetSize", (PyCFunction) _wrap_DC_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
22744 { (char *)"DC_GetSizeTuple", (PyCFunction) _wrap_DC_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
22745 { (char *)"DC_GetSizeMM", (PyCFunction) _wrap_DC_GetSizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
22746 { (char *)"DC_GetSizeMMTuple", (PyCFunction) _wrap_DC_GetSizeMMTuple, METH_VARARGS | METH_KEYWORDS, NULL},
22747 { (char *)"DC_DeviceToLogicalX", (PyCFunction) _wrap_DC_DeviceToLogicalX, METH_VARARGS | METH_KEYWORDS, NULL},
22748 { (char *)"DC_DeviceToLogicalY", (PyCFunction) _wrap_DC_DeviceToLogicalY, METH_VARARGS | METH_KEYWORDS, NULL},
22749 { (char *)"DC_DeviceToLogicalXRel", (PyCFunction) _wrap_DC_DeviceToLogicalXRel, METH_VARARGS | METH_KEYWORDS, NULL},
22750 { (char *)"DC_DeviceToLogicalYRel", (PyCFunction) _wrap_DC_DeviceToLogicalYRel, METH_VARARGS | METH_KEYWORDS, NULL},
22751 { (char *)"DC_LogicalToDeviceX", (PyCFunction) _wrap_DC_LogicalToDeviceX, METH_VARARGS | METH_KEYWORDS, NULL},
22752 { (char *)"DC_LogicalToDeviceY", (PyCFunction) _wrap_DC_LogicalToDeviceY, METH_VARARGS | METH_KEYWORDS, NULL},
22753 { (char *)"DC_LogicalToDeviceXRel", (PyCFunction) _wrap_DC_LogicalToDeviceXRel, METH_VARARGS | METH_KEYWORDS, NULL},
22754 { (char *)"DC_LogicalToDeviceYRel", (PyCFunction) _wrap_DC_LogicalToDeviceYRel, METH_VARARGS | METH_KEYWORDS, NULL},
22755 { (char *)"DC_CanDrawBitmap", (PyCFunction) _wrap_DC_CanDrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22756 { (char *)"DC_CanGetTextExtent", (PyCFunction) _wrap_DC_CanGetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
22757 { (char *)"DC_GetDepth", (PyCFunction) _wrap_DC_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
22758 { (char *)"DC_GetPPI", (PyCFunction) _wrap_DC_GetPPI, METH_VARARGS | METH_KEYWORDS, NULL},
22759 { (char *)"DC_Ok", (PyCFunction) _wrap_DC_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
22760 { (char *)"DC_GetBackgroundMode", (PyCFunction) _wrap_DC_GetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
22761 { (char *)"DC_GetBackground", (PyCFunction) _wrap_DC_GetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
22762 { (char *)"DC_GetBrush", (PyCFunction) _wrap_DC_GetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
22763 { (char *)"DC_GetFont", (PyCFunction) _wrap_DC_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
22764 { (char *)"DC_GetPen", (PyCFunction) _wrap_DC_GetPen, METH_VARARGS | METH_KEYWORDS, NULL},
22765 { (char *)"DC_GetTextBackground", (PyCFunction) _wrap_DC_GetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
22766 { (char *)"DC_GetTextForeground", (PyCFunction) _wrap_DC_GetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
22767 { (char *)"DC_SetTextForeground", (PyCFunction) _wrap_DC_SetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
22768 { (char *)"DC_SetTextBackground", (PyCFunction) _wrap_DC_SetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
22769 { (char *)"DC_GetMapMode", (PyCFunction) _wrap_DC_GetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
22770 { (char *)"DC_SetMapMode", (PyCFunction) _wrap_DC_SetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
22771 { (char *)"DC_GetUserScale", (PyCFunction) _wrap_DC_GetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
22772 { (char *)"DC_SetUserScale", (PyCFunction) _wrap_DC_SetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
22773 { (char *)"DC_GetLogicalScale", (PyCFunction) _wrap_DC_GetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
22774 { (char *)"DC_SetLogicalScale", (PyCFunction) _wrap_DC_SetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
22775 { (char *)"DC_GetLogicalOrigin", (PyCFunction) _wrap_DC_GetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
22776 { (char *)"DC_GetLogicalOriginTuple", (PyCFunction) _wrap_DC_GetLogicalOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
22777 { (char *)"DC_SetLogicalOrigin", (PyCFunction) _wrap_DC_SetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
22778 { (char *)"DC_SetLogicalOriginPoint", (PyCFunction) _wrap_DC_SetLogicalOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22779 { (char *)"DC_GetDeviceOrigin", (PyCFunction) _wrap_DC_GetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
22780 { (char *)"DC_GetDeviceOriginTuple", (PyCFunction) _wrap_DC_GetDeviceOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
22781 { (char *)"DC_SetDeviceOrigin", (PyCFunction) _wrap_DC_SetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
22782 { (char *)"DC_SetDeviceOriginPoint", (PyCFunction) _wrap_DC_SetDeviceOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22783 { (char *)"DC_SetAxisOrientation", (PyCFunction) _wrap_DC_SetAxisOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
22784 { (char *)"DC_GetLogicalFunction", (PyCFunction) _wrap_DC_GetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
22785 { (char *)"DC_SetLogicalFunction", (PyCFunction) _wrap_DC_SetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
22786 { (char *)"DC_ComputeScaleAndOrigin", (PyCFunction) _wrap_DC_ComputeScaleAndOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
22787 { (char *)"DC_CalcBoundingBox", (PyCFunction) _wrap_DC_CalcBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
22788 { (char *)"DC_CalcBoundingBoxPoint", (PyCFunction) _wrap_DC_CalcBoundingBoxPoint, METH_VARARGS | METH_KEYWORDS, NULL},
22789 { (char *)"DC_ResetBoundingBox", (PyCFunction) _wrap_DC_ResetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
22790 { (char *)"DC_MinX", (PyCFunction) _wrap_DC_MinX, METH_VARARGS | METH_KEYWORDS, NULL},
22791 { (char *)"DC_MaxX", (PyCFunction) _wrap_DC_MaxX, METH_VARARGS | METH_KEYWORDS, NULL},
22792 { (char *)"DC_MinY", (PyCFunction) _wrap_DC_MinY, METH_VARARGS | METH_KEYWORDS, NULL},
22793 { (char *)"DC_MaxY", (PyCFunction) _wrap_DC_MaxY, METH_VARARGS | METH_KEYWORDS, NULL},
22794 { (char *)"DC_GetBoundingBox", (PyCFunction) _wrap_DC_GetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
22795 { (char *)"DC_GetHDC", (PyCFunction) _wrap_DC_GetHDC, METH_VARARGS | METH_KEYWORDS, NULL},
22796 { (char *)"DC__DrawPointList", (PyCFunction) _wrap_DC__DrawPointList, METH_VARARGS | METH_KEYWORDS, NULL},
22797 { (char *)"DC__DrawLineList", (PyCFunction) _wrap_DC__DrawLineList, METH_VARARGS | METH_KEYWORDS, NULL},
22798 { (char *)"DC__DrawRectangleList", (PyCFunction) _wrap_DC__DrawRectangleList, METH_VARARGS | METH_KEYWORDS, NULL},
22799 { (char *)"DC__DrawEllipseList", (PyCFunction) _wrap_DC__DrawEllipseList, METH_VARARGS | METH_KEYWORDS, NULL},
22800 { (char *)"DC__DrawPolygonList", (PyCFunction) _wrap_DC__DrawPolygonList, METH_VARARGS | METH_KEYWORDS, NULL},
22801 { (char *)"DC__DrawTextList", (PyCFunction) _wrap_DC__DrawTextList, METH_VARARGS | METH_KEYWORDS, NULL},
22802 { (char *)"DC_swigregister", DC_swigregister, METH_VARARGS, NULL},
22803 { (char *)"new_MemoryDC", (PyCFunction) _wrap_new_MemoryDC, METH_VARARGS | METH_KEYWORDS, NULL},
22804 { (char *)"new_MemoryDCFromDC", (PyCFunction) _wrap_new_MemoryDCFromDC, METH_VARARGS | METH_KEYWORDS, NULL},
22805 { (char *)"MemoryDC_SelectObject", (PyCFunction) _wrap_MemoryDC_SelectObject, METH_VARARGS | METH_KEYWORDS, NULL},
22806 { (char *)"MemoryDC_swigregister", MemoryDC_swigregister, METH_VARARGS, NULL},
22807 { (char *)"new_BufferedDC", _wrap_new_BufferedDC, METH_VARARGS, NULL},
22808 { (char *)"delete_BufferedDC", (PyCFunction) _wrap_delete_BufferedDC, METH_VARARGS | METH_KEYWORDS, NULL},
22809 { (char *)"BufferedDC_UnMask", (PyCFunction) _wrap_BufferedDC_UnMask, METH_VARARGS | METH_KEYWORDS, NULL},
22810 { (char *)"BufferedDC_swigregister", BufferedDC_swigregister, METH_VARARGS, NULL},
22811 { (char *)"new_BufferedPaintDC", (PyCFunction) _wrap_new_BufferedPaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
22812 { (char *)"BufferedPaintDC_swigregister", BufferedPaintDC_swigregister, METH_VARARGS, NULL},
22813 { (char *)"new_ScreenDC", (PyCFunction) _wrap_new_ScreenDC, METH_VARARGS | METH_KEYWORDS, NULL},
22814 { (char *)"ScreenDC_StartDrawingOnTopWin", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTopWin, METH_VARARGS | METH_KEYWORDS, NULL},
22815 { (char *)"ScreenDC_StartDrawingOnTop", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
22816 { (char *)"ScreenDC_EndDrawingOnTop", (PyCFunction) _wrap_ScreenDC_EndDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
22817 { (char *)"ScreenDC_swigregister", ScreenDC_swigregister, METH_VARARGS, NULL},
22818 { (char *)"new_ClientDC", (PyCFunction) _wrap_new_ClientDC, METH_VARARGS | METH_KEYWORDS, NULL},
22819 { (char *)"ClientDC_swigregister", ClientDC_swigregister, METH_VARARGS, NULL},
22820 { (char *)"new_PaintDC", (PyCFunction) _wrap_new_PaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
22821 { (char *)"PaintDC_swigregister", PaintDC_swigregister, METH_VARARGS, NULL},
22822 { (char *)"new_WindowDC", (PyCFunction) _wrap_new_WindowDC, METH_VARARGS | METH_KEYWORDS, NULL},
22823 { (char *)"WindowDC_swigregister", WindowDC_swigregister, METH_VARARGS, NULL},
22824 { (char *)"new_MirrorDC", (PyCFunction) _wrap_new_MirrorDC, METH_VARARGS | METH_KEYWORDS, NULL},
22825 { (char *)"MirrorDC_swigregister", MirrorDC_swigregister, METH_VARARGS, NULL},
22826 { (char *)"new_PostScriptDC", (PyCFunction) _wrap_new_PostScriptDC, METH_VARARGS | METH_KEYWORDS, NULL},
22827 { (char *)"PostScriptDC_GetPrintData", (PyCFunction) _wrap_PostScriptDC_GetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
22828 { (char *)"PostScriptDC_SetPrintData", (PyCFunction) _wrap_PostScriptDC_SetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
22829 { (char *)"PostScriptDC_SetResolution", (PyCFunction) _wrap_PostScriptDC_SetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
22830 { (char *)"PostScriptDC_GetResolution", (PyCFunction) _wrap_PostScriptDC_GetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
22831 { (char *)"PostScriptDC_swigregister", PostScriptDC_swigregister, METH_VARARGS, NULL},
22832 { (char *)"new_MetaFile", (PyCFunction) _wrap_new_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
22833 { (char *)"delete_MetaFile", (PyCFunction) _wrap_delete_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
22834 { (char *)"MetaFile_Ok", (PyCFunction) _wrap_MetaFile_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
22835 { (char *)"MetaFile_SetClipboard", (PyCFunction) _wrap_MetaFile_SetClipboard, METH_VARARGS | METH_KEYWORDS, NULL},
22836 { (char *)"MetaFile_GetSize", (PyCFunction) _wrap_MetaFile_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
22837 { (char *)"MetaFile_GetWidth", (PyCFunction) _wrap_MetaFile_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
22838 { (char *)"MetaFile_GetHeight", (PyCFunction) _wrap_MetaFile_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
22839 { (char *)"MetaFile_GetFileName", (PyCFunction) _wrap_MetaFile_GetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
22840 { (char *)"MetaFile_swigregister", MetaFile_swigregister, METH_VARARGS, NULL},
22841 { (char *)"new_MetaFileDC", (PyCFunction) _wrap_new_MetaFileDC, METH_VARARGS | METH_KEYWORDS, NULL},
22842 { (char *)"MetaFileDC_Close", (PyCFunction) _wrap_MetaFileDC_Close, METH_VARARGS | METH_KEYWORDS, NULL},
22843 { (char *)"MetaFileDC_swigregister", MetaFileDC_swigregister, METH_VARARGS, NULL},
22844 { (char *)"new_PrinterDC", (PyCFunction) _wrap_new_PrinterDC, METH_VARARGS | METH_KEYWORDS, NULL},
22845 { (char *)"PrinterDC_swigregister", PrinterDC_swigregister, METH_VARARGS, NULL},
22846 { (char *)"new_ImageList", (PyCFunction) _wrap_new_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
22847 { (char *)"delete_ImageList", (PyCFunction) _wrap_delete_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
22848 { (char *)"ImageList_Add", (PyCFunction) _wrap_ImageList_Add, METH_VARARGS | METH_KEYWORDS, NULL},
22849 { (char *)"ImageList_AddWithColourMask", (PyCFunction) _wrap_ImageList_AddWithColourMask, METH_VARARGS | METH_KEYWORDS, NULL},
22850 { (char *)"ImageList_AddIcon", (PyCFunction) _wrap_ImageList_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
22851 { (char *)"ImageList_GetBitmap", (PyCFunction) _wrap_ImageList_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22852 { (char *)"ImageList_GetIcon", (PyCFunction) _wrap_ImageList_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
22853 { (char *)"ImageList_Replace", (PyCFunction) _wrap_ImageList_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
22854 { (char *)"ImageList_Draw", (PyCFunction) _wrap_ImageList_Draw, METH_VARARGS | METH_KEYWORDS, NULL},
22855 { (char *)"ImageList_GetImageCount", (PyCFunction) _wrap_ImageList_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
22856 { (char *)"ImageList_Remove", (PyCFunction) _wrap_ImageList_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
22857 { (char *)"ImageList_RemoveAll", (PyCFunction) _wrap_ImageList_RemoveAll, METH_VARARGS | METH_KEYWORDS, NULL},
22858 { (char *)"ImageList_GetSize", (PyCFunction) _wrap_ImageList_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
22859 { (char *)"ImageList_swigregister", ImageList_swigregister, METH_VARARGS, NULL},
22860 { (char *)"PenList_AddPen", (PyCFunction) _wrap_PenList_AddPen, METH_VARARGS | METH_KEYWORDS, NULL},
22861 { (char *)"PenList_FindOrCreatePen", (PyCFunction) _wrap_PenList_FindOrCreatePen, METH_VARARGS | METH_KEYWORDS, NULL},
22862 { (char *)"PenList_RemovePen", (PyCFunction) _wrap_PenList_RemovePen, METH_VARARGS | METH_KEYWORDS, NULL},
22863 { (char *)"PenList_GetCount", (PyCFunction) _wrap_PenList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
22864 { (char *)"PenList_swigregister", PenList_swigregister, METH_VARARGS, NULL},
22865 { (char *)"BrushList_AddBrush", (PyCFunction) _wrap_BrushList_AddBrush, METH_VARARGS | METH_KEYWORDS, NULL},
22866 { (char *)"BrushList_FindOrCreateBrush", (PyCFunction) _wrap_BrushList_FindOrCreateBrush, METH_VARARGS | METH_KEYWORDS, NULL},
22867 { (char *)"BrushList_RemoveBrush", (PyCFunction) _wrap_BrushList_RemoveBrush, METH_VARARGS | METH_KEYWORDS, NULL},
22868 { (char *)"BrushList_GetCount", (PyCFunction) _wrap_BrushList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
22869 { (char *)"BrushList_swigregister", BrushList_swigregister, METH_VARARGS, NULL},
22870 { (char *)"new_ColourDatabase", (PyCFunction) _wrap_new_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
22871 { (char *)"delete_ColourDatabase", (PyCFunction) _wrap_delete_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
22872 { (char *)"ColourDatabase_Find", (PyCFunction) _wrap_ColourDatabase_Find, METH_VARARGS | METH_KEYWORDS, NULL},
22873 { (char *)"ColourDatabase_FindName", (PyCFunction) _wrap_ColourDatabase_FindName, METH_VARARGS | METH_KEYWORDS, NULL},
22874 { (char *)"ColourDatabase_AddColour", (PyCFunction) _wrap_ColourDatabase_AddColour, METH_VARARGS | METH_KEYWORDS, NULL},
22875 { (char *)"ColourDatabase_Append", (PyCFunction) _wrap_ColourDatabase_Append, METH_VARARGS | METH_KEYWORDS, NULL},
22876 { (char *)"ColourDatabase_swigregister", ColourDatabase_swigregister, METH_VARARGS, NULL},
22877 { (char *)"FontList_AddFont", (PyCFunction) _wrap_FontList_AddFont, METH_VARARGS | METH_KEYWORDS, NULL},
22878 { (char *)"FontList_FindOrCreateFont", (PyCFunction) _wrap_FontList_FindOrCreateFont, METH_VARARGS | METH_KEYWORDS, NULL},
22879 { (char *)"FontList_RemoveFont", (PyCFunction) _wrap_FontList_RemoveFont, METH_VARARGS | METH_KEYWORDS, NULL},
22880 { (char *)"FontList_GetCount", (PyCFunction) _wrap_FontList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
22881 { (char *)"FontList_swigregister", FontList_swigregister, METH_VARARGS, NULL},
22882 { (char *)"new_Effects", (PyCFunction) _wrap_new_Effects, METH_VARARGS | METH_KEYWORDS, NULL},
22883 { (char *)"Effects_GetHighlightColour", (PyCFunction) _wrap_Effects_GetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
22884 { (char *)"Effects_GetLightShadow", (PyCFunction) _wrap_Effects_GetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
22885 { (char *)"Effects_GetFaceColour", (PyCFunction) _wrap_Effects_GetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
22886 { (char *)"Effects_GetMediumShadow", (PyCFunction) _wrap_Effects_GetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
22887 { (char *)"Effects_GetDarkShadow", (PyCFunction) _wrap_Effects_GetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
22888 { (char *)"Effects_SetHighlightColour", (PyCFunction) _wrap_Effects_SetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
22889 { (char *)"Effects_SetLightShadow", (PyCFunction) _wrap_Effects_SetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
22890 { (char *)"Effects_SetFaceColour", (PyCFunction) _wrap_Effects_SetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
22891 { (char *)"Effects_SetMediumShadow", (PyCFunction) _wrap_Effects_SetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
22892 { (char *)"Effects_SetDarkShadow", (PyCFunction) _wrap_Effects_SetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
22893 { (char *)"Effects_Set", (PyCFunction) _wrap_Effects_Set, METH_VARARGS | METH_KEYWORDS, NULL},
22894 { (char *)"Effects_DrawSunkenEdge", (PyCFunction) _wrap_Effects_DrawSunkenEdge, METH_VARARGS | METH_KEYWORDS, NULL},
22895 { (char *)"Effects_TileBitmap", (PyCFunction) _wrap_Effects_TileBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22896 { (char *)"Effects_swigregister", Effects_swigregister, METH_VARARGS, NULL},
22897 { (char *)"new_SplitterRenderParams", (PyCFunction) _wrap_new_SplitterRenderParams, METH_VARARGS | METH_KEYWORDS, NULL},
22898 { (char *)"delete_SplitterRenderParams", (PyCFunction) _wrap_delete_SplitterRenderParams, METH_VARARGS | METH_KEYWORDS, NULL},
22899 { (char *)"SplitterRenderParams_widthSash_get", (PyCFunction) _wrap_SplitterRenderParams_widthSash_get, METH_VARARGS | METH_KEYWORDS, NULL},
22900 { (char *)"SplitterRenderParams_border_get", (PyCFunction) _wrap_SplitterRenderParams_border_get, METH_VARARGS | METH_KEYWORDS, NULL},
22901 { (char *)"SplitterRenderParams_isHotSensitive_get", (PyCFunction) _wrap_SplitterRenderParams_isHotSensitive_get, METH_VARARGS | METH_KEYWORDS, NULL},
22902 { (char *)"SplitterRenderParams_swigregister", SplitterRenderParams_swigregister, METH_VARARGS, NULL},
22903 { (char *)"new_RendererVersion", (PyCFunction) _wrap_new_RendererVersion, METH_VARARGS | METH_KEYWORDS, NULL},
22904 { (char *)"delete_RendererVersion", (PyCFunction) _wrap_delete_RendererVersion, METH_VARARGS | METH_KEYWORDS, NULL},
22905 { (char *)"RendererVersion_IsCompatible", (PyCFunction) _wrap_RendererVersion_IsCompatible, METH_VARARGS | METH_KEYWORDS, NULL},
22906 { (char *)"RendererVersion_version_get", (PyCFunction) _wrap_RendererVersion_version_get, METH_VARARGS | METH_KEYWORDS, NULL},
22907 { (char *)"RendererVersion_age_get", (PyCFunction) _wrap_RendererVersion_age_get, METH_VARARGS | METH_KEYWORDS, NULL},
22908 { (char *)"RendererVersion_swigregister", RendererVersion_swigregister, METH_VARARGS, NULL},
22909 { (char *)"RendererNative_DrawHeaderButton", (PyCFunction) _wrap_RendererNative_DrawHeaderButton, METH_VARARGS | METH_KEYWORDS, NULL},
22910 { (char *)"RendererNative_DrawTreeItemButton", (PyCFunction) _wrap_RendererNative_DrawTreeItemButton, METH_VARARGS | METH_KEYWORDS, NULL},
22911 { (char *)"RendererNative_DrawSplitterBorder", (PyCFunction) _wrap_RendererNative_DrawSplitterBorder, METH_VARARGS | METH_KEYWORDS, NULL},
22912 { (char *)"RendererNative_DrawSplitterSash", (PyCFunction) _wrap_RendererNative_DrawSplitterSash, METH_VARARGS | METH_KEYWORDS, NULL},
22913 { (char *)"RendererNative_DrawComboBoxDropButton", (PyCFunction) _wrap_RendererNative_DrawComboBoxDropButton, METH_VARARGS | METH_KEYWORDS, NULL},
22914 { (char *)"RendererNative_DrawDropArrow", (PyCFunction) _wrap_RendererNative_DrawDropArrow, METH_VARARGS | METH_KEYWORDS, NULL},
22915 { (char *)"RendererNative_GetSplitterParams", (PyCFunction) _wrap_RendererNative_GetSplitterParams, METH_VARARGS | METH_KEYWORDS, NULL},
22916 { (char *)"RendererNative_Get", (PyCFunction) _wrap_RendererNative_Get, METH_VARARGS | METH_KEYWORDS, NULL},
22917 { (char *)"RendererNative_GetGeneric", (PyCFunction) _wrap_RendererNative_GetGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
22918 { (char *)"RendererNative_GetDefault", (PyCFunction) _wrap_RendererNative_GetDefault, METH_VARARGS | METH_KEYWORDS, NULL},
22919 { (char *)"RendererNative_Set", (PyCFunction) _wrap_RendererNative_Set, METH_VARARGS | METH_KEYWORDS, NULL},
22920 { (char *)"RendererNative_GetVersion", (PyCFunction) _wrap_RendererNative_GetVersion, METH_VARARGS | METH_KEYWORDS, NULL},
22921 { (char *)"RendererNative_swigregister", RendererNative_swigregister, METH_VARARGS, NULL},
22922 { NULL, NULL, 0, NULL }
22923 };
22924
22925
22926 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
22927
22928 static void *_p_wxBufferedDCTo_p_wxMemoryDC(void *x) {
22929 return (void *)((wxMemoryDC *) ((wxBufferedDC *) x));
22930 }
22931 static void *_p_wxBufferedPaintDCTo_p_wxMemoryDC(void *x) {
22932 return (void *)((wxMemoryDC *) (wxBufferedDC *) ((wxBufferedPaintDC *) x));
22933 }
22934 static void *_p_wxIconTo_p_wxGDIObject(void *x) {
22935 return (void *)((wxGDIObject *) ((wxIcon *) x));
22936 }
22937 static void *_p_wxPaletteTo_p_wxGDIObject(void *x) {
22938 return (void *)((wxGDIObject *) ((wxPalette *) x));
22939 }
22940 static void *_p_wxPenTo_p_wxGDIObject(void *x) {
22941 return (void *)((wxGDIObject *) ((wxPen *) x));
22942 }
22943 static void *_p_wxFontTo_p_wxGDIObject(void *x) {
22944 return (void *)((wxGDIObject *) ((wxFont *) x));
22945 }
22946 static void *_p_wxCursorTo_p_wxGDIObject(void *x) {
22947 return (void *)((wxGDIObject *) ((wxCursor *) x));
22948 }
22949 static void *_p_wxBitmapTo_p_wxGDIObject(void *x) {
22950 return (void *)((wxGDIObject *) ((wxBitmap *) x));
22951 }
22952 static void *_p_wxRegionTo_p_wxGDIObject(void *x) {
22953 return (void *)((wxGDIObject *) ((wxRegion *) x));
22954 }
22955 static void *_p_wxBrushTo_p_wxGDIObject(void *x) {
22956 return (void *)((wxGDIObject *) ((wxBrush *) x));
22957 }
22958 static void *_p_wxBufferedDCTo_p_wxDC(void *x) {
22959 return (void *)((wxDC *) (wxMemoryDC *) ((wxBufferedDC *) x));
22960 }
22961 static void *_p_wxScreenDCTo_p_wxDC(void *x) {
22962 return (void *)((wxDC *) ((wxScreenDC *) x));
22963 }
22964 static void *_p_wxMirrorDCTo_p_wxDC(void *x) {
22965 return (void *)((wxDC *) ((wxMirrorDC *) x));
22966 }
22967 static void *_p_wxMemoryDCTo_p_wxDC(void *x) {
22968 return (void *)((wxDC *) ((wxMemoryDC *) x));
22969 }
22970 static void *_p_wxWindowDCTo_p_wxDC(void *x) {
22971 return (void *)((wxDC *) ((wxWindowDC *) x));
22972 }
22973 static void *_p_wxMetaFileDCTo_p_wxDC(void *x) {
22974 return (void *)((wxDC *) ((wxMetaFileDC *) x));
22975 }
22976 static void *_p_wxBufferedPaintDCTo_p_wxDC(void *x) {
22977 return (void *)((wxDC *) (wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
22978 }
22979 static void *_p_wxClientDCTo_p_wxDC(void *x) {
22980 return (void *)((wxDC *) ((wxClientDC *) x));
22981 }
22982 static void *_p_wxPaintDCTo_p_wxDC(void *x) {
22983 return (void *)((wxDC *) ((wxPaintDC *) x));
22984 }
22985 static void *_p_wxPostScriptDCTo_p_wxDC(void *x) {
22986 return (void *)((wxDC *) ((wxPostScriptDC *) x));
22987 }
22988 static void *_p_wxPrinterDCTo_p_wxDC(void *x) {
22989 return (void *)((wxDC *) ((wxPrinterDC *) x));
22990 }
22991 static void *_p_wxBufferedPaintDCTo_p_wxBufferedDC(void *x) {
22992 return (void *)((wxBufferedDC *) ((wxBufferedPaintDC *) x));
22993 }
22994 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
22995 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
22996 }
22997 static void *_p_wxPenTo_p_wxObject(void *x) {
22998 return (void *)((wxObject *) (wxGDIObject *) ((wxPen *) x));
22999 }
23000 static void *_p_wxRegionIteratorTo_p_wxObject(void *x) {
23001 return (void *)((wxObject *) ((wxRegionIterator *) x));
23002 }
23003 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
23004 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
23005 }
23006 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
23007 return (void *)((wxObject *) ((wxSizerItem *) x));
23008 }
23009 static void *_p_wxColourDatabaseTo_p_wxObject(void *x) {
23010 return (void *)((wxObject *) ((wxColourDatabase *) x));
23011 }
23012 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
23013 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
23014 }
23015 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
23016 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
23017 }
23018 static void *_p_wxIconTo_p_wxObject(void *x) {
23019 return (void *)((wxObject *) (wxGDIObject *) ((wxIcon *) x));
23020 }
23021 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
23022 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
23023 }
23024 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
23025 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
23026 }
23027 static void *_p_wxSizerTo_p_wxObject(void *x) {
23028 return (void *)((wxObject *) ((wxSizer *) x));
23029 }
23030 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
23031 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
23032 }
23033 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
23034 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
23035 }
23036 static void *_p_wxPenListTo_p_wxObject(void *x) {
23037 return (void *)((wxObject *) ((wxPenList *) x));
23038 }
23039 static void *_p_wxEventTo_p_wxObject(void *x) {
23040 return (void *)((wxObject *) ((wxEvent *) x));
23041 }
23042 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
23043 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
23044 }
23045 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
23046 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
23047 }
23048 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
23049 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
23050 }
23051 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
23052 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
23053 }
23054 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
23055 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
23056 }
23057 static void *_p_wxDCTo_p_wxObject(void *x) {
23058 return (void *)((wxObject *) ((wxDC *) x));
23059 }
23060 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
23061 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
23062 }
23063 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
23064 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
23065 }
23066 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
23067 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
23068 }
23069 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
23070 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
23071 }
23072 static void *_p_wxControlTo_p_wxObject(void *x) {
23073 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
23074 }
23075 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
23076 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
23077 }
23078 static void *_p_wxClientDCTo_p_wxObject(void *x) {
23079 return (void *)((wxObject *) (wxDC *) ((wxClientDC *) x));
23080 }
23081 static void *_p_wxFSFileTo_p_wxObject(void *x) {
23082 return (void *)((wxObject *) ((wxFSFile *) x));
23083 }
23084 static void *_p_wxMemoryDCTo_p_wxObject(void *x) {
23085 return (void *)((wxObject *) (wxDC *) ((wxMemoryDC *) x));
23086 }
23087 static void *_p_wxRegionTo_p_wxObject(void *x) {
23088 return (void *)((wxObject *) (wxGDIObject *) ((wxRegion *) x));
23089 }
23090 static void *_p_wxPySizerTo_p_wxObject(void *x) {
23091 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
23092 }
23093 static void *_p_wxWindowDCTo_p_wxObject(void *x) {
23094 return (void *)((wxObject *) (wxDC *) ((wxWindowDC *) x));
23095 }
23096 static void *_p_wxGDIObjectTo_p_wxObject(void *x) {
23097 return (void *)((wxObject *) ((wxGDIObject *) x));
23098 }
23099 static void *_p_wxEffectsTo_p_wxObject(void *x) {
23100 return (void *)((wxObject *) ((wxEffects *) x));
23101 }
23102 static void *_p_wxPyEventTo_p_wxObject(void *x) {
23103 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
23104 }
23105 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
23106 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
23107 }
23108 static void *_p_wxPostScriptDCTo_p_wxObject(void *x) {
23109 return (void *)((wxObject *) (wxDC *) ((wxPostScriptDC *) x));
23110 }
23111 static void *_p_wxShowEventTo_p_wxObject(void *x) {
23112 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
23113 }
23114 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
23115 return (void *)((wxObject *) ((wxMenuItem *) x));
23116 }
23117 static void *_p_wxDateEventTo_p_wxObject(void *x) {
23118 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
23119 }
23120 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
23121 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
23122 }
23123 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
23124 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
23125 }
23126 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
23127 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
23128 }
23129 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
23130 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
23131 }
23132 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
23133 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
23134 }
23135 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
23136 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
23137 }
23138 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
23139 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
23140 }
23141 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
23142 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
23143 }
23144 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
23145 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
23146 }
23147 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
23148 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
23149 }
23150 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
23151 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
23152 }
23153 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
23154 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
23155 }
23156 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
23157 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
23158 }
23159 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
23160 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
23161 }
23162 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
23163 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
23164 }
23165 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
23166 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
23167 }
23168 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
23169 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
23170 }
23171 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
23172 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
23173 }
23174 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
23175 return (void *)((wxObject *) ((wxImageHandler *) x));
23176 }
23177 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
23178 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
23179 }
23180 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
23181 return (void *)((wxObject *) ((wxEvtHandler *) x));
23182 }
23183 static void *_p_wxBufferedPaintDCTo_p_wxObject(void *x) {
23184 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
23185 }
23186 static void *_p_wxPaintDCTo_p_wxObject(void *x) {
23187 return (void *)((wxObject *) (wxDC *) ((wxPaintDC *) x));
23188 }
23189 static void *_p_wxPrinterDCTo_p_wxObject(void *x) {
23190 return (void *)((wxObject *) (wxDC *) ((wxPrinterDC *) x));
23191 }
23192 static void *_p_wxScreenDCTo_p_wxObject(void *x) {
23193 return (void *)((wxObject *) (wxDC *) ((wxScreenDC *) x));
23194 }
23195 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
23196 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
23197 }
23198 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
23199 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
23200 }
23201 static void *_p_wxImageTo_p_wxObject(void *x) {
23202 return (void *)((wxObject *) ((wxImage *) x));
23203 }
23204 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
23205 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
23206 }
23207 static void *_p_wxPaletteTo_p_wxObject(void *x) {
23208 return (void *)((wxObject *) (wxGDIObject *) ((wxPalette *) x));
23209 }
23210 static void *_p_wxBufferedDCTo_p_wxObject(void *x) {
23211 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *) ((wxBufferedDC *) x));
23212 }
23213 static void *_p_wxImageListTo_p_wxObject(void *x) {
23214 return (void *)((wxObject *) ((wxImageList *) x));
23215 }
23216 static void *_p_wxCursorTo_p_wxObject(void *x) {
23217 return (void *)((wxObject *) (wxGDIObject *) ((wxCursor *) x));
23218 }
23219 static void *_p_wxEncodingConverterTo_p_wxObject(void *x) {
23220 return (void *)((wxObject *) ((wxEncodingConverter *) x));
23221 }
23222 static void *_p_wxMirrorDCTo_p_wxObject(void *x) {
23223 return (void *)((wxObject *) (wxDC *) ((wxMirrorDC *) x));
23224 }
23225 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
23226 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
23227 }
23228 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
23229 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
23230 }
23231 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
23232 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
23233 }
23234 static void *_p_wxWindowTo_p_wxObject(void *x) {
23235 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
23236 }
23237 static void *_p_wxMenuTo_p_wxObject(void *x) {
23238 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
23239 }
23240 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
23241 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
23242 }
23243 static void *_p_wxMetaFileDCTo_p_wxObject(void *x) {
23244 return (void *)((wxObject *) (wxDC *) ((wxMetaFileDC *) x));
23245 }
23246 static void *_p_wxBrushListTo_p_wxObject(void *x) {
23247 return (void *)((wxObject *) ((wxBrushList *) x));
23248 }
23249 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
23250 return (void *)((wxObject *) ((wxFileSystem *) x));
23251 }
23252 static void *_p_wxBitmapTo_p_wxObject(void *x) {
23253 return (void *)((wxObject *) (wxGDIObject *) ((wxBitmap *) x));
23254 }
23255 static void *_p_wxMaskTo_p_wxObject(void *x) {
23256 return (void *)((wxObject *) ((wxMask *) x));
23257 }
23258 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
23259 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
23260 }
23261 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
23262 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
23263 }
23264 static void *_p_wxPyAppTo_p_wxObject(void *x) {
23265 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
23266 }
23267 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
23268 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
23269 }
23270 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
23271 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
23272 }
23273 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
23274 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
23275 }
23276 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
23277 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
23278 }
23279 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
23280 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
23281 }
23282 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
23283 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
23284 }
23285 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
23286 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
23287 }
23288 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
23289 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
23290 }
23291 static void *_p_wxFontTo_p_wxObject(void *x) {
23292 return (void *)((wxObject *) (wxGDIObject *) ((wxFont *) x));
23293 }
23294 static void *_p_wxBrushTo_p_wxObject(void *x) {
23295 return (void *)((wxObject *) (wxGDIObject *) ((wxBrush *) x));
23296 }
23297 static void *_p_wxMetaFileTo_p_wxObject(void *x) {
23298 return (void *)((wxObject *) ((wxMetaFile *) x));
23299 }
23300 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
23301 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
23302 }
23303 static void *_p_wxColourTo_p_wxObject(void *x) {
23304 return (void *)((wxObject *) ((wxColour *) x));
23305 }
23306 static void *_p_wxFontListTo_p_wxObject(void *x) {
23307 return (void *)((wxObject *) ((wxFontList *) x));
23308 }
23309 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
23310 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
23311 }
23312 static void *_p_wxValidatorTo_p_wxObject(void *x) {
23313 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
23314 }
23315 static void *_p_wxControlTo_p_wxWindow(void *x) {
23316 return (void *)((wxWindow *) ((wxControl *) x));
23317 }
23318 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
23319 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
23320 }
23321 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
23322 return (void *)((wxWindow *) ((wxMenuBar *) x));
23323 }
23324 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}};
23325 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}};
23326 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}};
23327 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}};
23328 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}};
23329 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}};
23330 static swig_type_info _swigt__p_wxRendererVersion[] = {{"_p_wxRendererVersion", 0, "wxRendererVersion *", 0, 0, 0, 0},{"_p_wxRendererVersion", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23331 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}};
23332 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}};
23333 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}};
23334 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}};
23335 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}};
23336 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}};
23337 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}};
23338 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}};
23339 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}};
23340 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}};
23341 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}};
23342 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}};
23343 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}};
23344 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}};
23345 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}};
23346 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}};
23347 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}};
23348 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}};
23349 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}};
23350 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}};
23351 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}};
23352 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}};
23353 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}};
23354 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}};
23355 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}};
23356 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}};
23357 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}};
23358 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}};
23359 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}};
23360 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}};
23361 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}};
23362 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}};
23363 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}};
23364 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}};
23365 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}};
23366 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}};
23367 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}};
23368 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}};
23369 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}};
23370 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}};
23371 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}};
23372 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}};
23373 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}};
23374 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}};
23375 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}};
23376 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}};
23377 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}};
23378 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}};
23379 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}};
23380 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}};
23381 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}};
23382 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}};
23383 static swig_type_info _swigt__p_wxRendererNative[] = {{"_p_wxRendererNative", 0, "wxRendererNative *", 0, 0, 0, 0},{"_p_wxRendererNative", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23384 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}};
23385 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}};
23386 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}};
23387 static swig_type_info _swigt__p_wxSplitterRenderParams[] = {{"_p_wxSplitterRenderParams", 0, "wxSplitterRenderParams *", 0, 0, 0, 0},{"_p_wxSplitterRenderParams", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
23388 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}};
23389
23390 static swig_type_info *swig_types_initial[] = {
23391 _swigt__p_wxPostScriptDC,
23392 _swigt__p_wxBrush,
23393 _swigt__p_wxColour,
23394 _swigt__p_wxDC,
23395 _swigt__p_wxMirrorDC,
23396 _swigt__p_form_ops_t,
23397 _swigt__p_wxRendererVersion,
23398 _swigt__p_wxDuplexMode,
23399 _swigt__p_wxPyFontEnumerator,
23400 _swigt__p_char,
23401 _swigt__p_wxIconLocation,
23402 _swigt__p_wxImage,
23403 _swigt__p_wxMetaFileDC,
23404 _swigt__p_wxMask,
23405 _swigt__p_wxSize,
23406 _swigt__p_wxFont,
23407 _swigt__p_wxWindow,
23408 _swigt__p_double,
23409 _swigt__p_wxMemoryDC,
23410 _swigt__p_wxFontMapper,
23411 _swigt__p_wxEffects,
23412 _swigt__p_wxNativeEncodingInfo,
23413 _swigt__p_wxPalette,
23414 _swigt__p_wxBitmap,
23415 _swigt__p_wxObject,
23416 _swigt__p_wxRegionIterator,
23417 _swigt__p_wxRect,
23418 _swigt__p_wxPaperSize,
23419 _swigt__p_wxString,
23420 _swigt__unsigned_int,
23421 _swigt__p_unsigned_int,
23422 _swigt__p_wxPrinterDC,
23423 _swigt__p_wxIconBundle,
23424 _swigt__p_wxPoint,
23425 _swigt__p_wxDash,
23426 _swigt__p_wxScreenDC,
23427 _swigt__p_wxCursor,
23428 _swigt__p_wxClientDC,
23429 _swigt__p_wxBufferedDC,
23430 _swigt__p_wxImageList,
23431 _swigt__p_unsigned_char,
23432 _swigt__p_wxGDIObject,
23433 _swigt__p_wxIcon,
23434 _swigt__p_wxLocale,
23435 _swigt__ptrdiff_t,
23436 _swigt__std__ptrdiff_t,
23437 _swigt__p_wxRegion,
23438 _swigt__p_wxConfigBase,
23439 _swigt__p_wxLanguageInfo,
23440 _swigt__p_wxWindowDC,
23441 _swigt__p_wxPrintData,
23442 _swigt__p_wxBrushList,
23443 _swigt__p_wxFontList,
23444 _swigt__p_wxPen,
23445 _swigt__p_wxBufferedPaintDC,
23446 _swigt__p_wxPaintDC,
23447 _swigt__p_wxPenList,
23448 _swigt__p_int,
23449 _swigt__p_wxMetaFile,
23450 _swigt__p_wxRendererNative,
23451 _swigt__p_unsigned_long,
23452 _swigt__p_wxNativeFontInfo,
23453 _swigt__p_wxEncodingConverter,
23454 _swigt__p_wxSplitterRenderParams,
23455 _swigt__p_wxColourDatabase,
23456 0
23457 };
23458
23459
23460 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
23461
23462 static swig_const_info swig_const_table[] = {
23463 {0, 0, 0, 0.0, 0, 0}};
23464
23465 #ifdef __cplusplus
23466 }
23467 #endif
23468
23469
23470 #ifdef __cplusplus
23471 extern "C" {
23472 #endif
23473
23474 /* Python-specific SWIG API */
23475 #define SWIG_newvarlink() SWIG_Python_newvarlink()
23476 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
23477 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
23478
23479 /* -----------------------------------------------------------------------------
23480 * global variable support code.
23481 * ----------------------------------------------------------------------------- */
23482
23483 typedef struct swig_globalvar {
23484 char *name; /* Name of global variable */
23485 PyObject *(*get_attr)(); /* Return the current value */
23486 int (*set_attr)(PyObject *); /* Set the value */
23487 struct swig_globalvar *next;
23488 } swig_globalvar;
23489
23490 typedef struct swig_varlinkobject {
23491 PyObject_HEAD
23492 swig_globalvar *vars;
23493 } swig_varlinkobject;
23494
23495 static PyObject *
23496 swig_varlink_repr(swig_varlinkobject *v) {
23497 v = v;
23498 return PyString_FromString("<Swig global variables>");
23499 }
23500
23501 static int
23502 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
23503 swig_globalvar *var;
23504 flags = flags;
23505 fprintf(fp,"Swig global variables { ");
23506 for (var = v->vars; var; var=var->next) {
23507 fprintf(fp,"%s", var->name);
23508 if (var->next) fprintf(fp,", ");
23509 }
23510 fprintf(fp," }\n");
23511 return 0;
23512 }
23513
23514 static PyObject *
23515 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
23516 swig_globalvar *var = v->vars;
23517 while (var) {
23518 if (strcmp(var->name,n) == 0) {
23519 return (*var->get_attr)();
23520 }
23521 var = var->next;
23522 }
23523 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
23524 return NULL;
23525 }
23526
23527 static int
23528 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
23529 swig_globalvar *var = v->vars;
23530 while (var) {
23531 if (strcmp(var->name,n) == 0) {
23532 return (*var->set_attr)(p);
23533 }
23534 var = var->next;
23535 }
23536 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
23537 return 1;
23538 }
23539
23540 static PyTypeObject varlinktype = {
23541 PyObject_HEAD_INIT(0)
23542 0, /* Number of items in variable part (ob_size) */
23543 (char *)"swigvarlink", /* Type name (tp_name) */
23544 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
23545 0, /* Itemsize (tp_itemsize) */
23546 0, /* Deallocator (tp_dealloc) */
23547 (printfunc) swig_varlink_print, /* Print (tp_print) */
23548 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
23549 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
23550 0, /* tp_compare */
23551 (reprfunc) swig_varlink_repr, /* tp_repr */
23552 0, /* tp_as_number */
23553 0, /* tp_as_sequence */
23554 0, /* tp_as_mapping */
23555 0, /* tp_hash */
23556 0, /* tp_call */
23557 0, /* tp_str */
23558 0, /* tp_getattro */
23559 0, /* tp_setattro */
23560 0, /* tp_as_buffer */
23561 0, /* tp_flags */
23562 0, /* tp_doc */
23563 #if PY_VERSION_HEX >= 0x02000000
23564 0, /* tp_traverse */
23565 0, /* tp_clear */
23566 #endif
23567 #if PY_VERSION_HEX >= 0x02010000
23568 0, /* tp_richcompare */
23569 0, /* tp_weaklistoffset */
23570 #endif
23571 #if PY_VERSION_HEX >= 0x02020000
23572 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
23573 #endif
23574 #if PY_VERSION_HEX >= 0x02030000
23575 0, /* tp_del */
23576 #endif
23577 #ifdef COUNT_ALLOCS
23578 0,0,0,0 /* tp_alloc -> tp_next */
23579 #endif
23580 };
23581
23582 /* Create a variable linking object for use later */
23583 static PyObject *
23584 SWIG_Python_newvarlink(void) {
23585 swig_varlinkobject *result = 0;
23586 result = PyMem_NEW(swig_varlinkobject,1);
23587 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
23588 result->ob_type = &varlinktype;
23589 result->vars = 0;
23590 result->ob_refcnt = 0;
23591 Py_XINCREF((PyObject *) result);
23592 return ((PyObject*) result);
23593 }
23594
23595 static void
23596 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
23597 swig_varlinkobject *v;
23598 swig_globalvar *gv;
23599 v= (swig_varlinkobject *) p;
23600 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
23601 gv->name = (char *) malloc(strlen(name)+1);
23602 strcpy(gv->name,name);
23603 gv->get_attr = get_attr;
23604 gv->set_attr = set_attr;
23605 gv->next = v->vars;
23606 v->vars = gv;
23607 }
23608
23609 /* -----------------------------------------------------------------------------
23610 * constants/methods manipulation
23611 * ----------------------------------------------------------------------------- */
23612
23613 /* Install Constants */
23614 static void
23615 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
23616 PyObject *obj = 0;
23617 size_t i;
23618 for (i = 0; constants[i].type; i++) {
23619 switch(constants[i].type) {
23620 case SWIG_PY_INT:
23621 obj = PyInt_FromLong(constants[i].lvalue);
23622 break;
23623 case SWIG_PY_FLOAT:
23624 obj = PyFloat_FromDouble(constants[i].dvalue);
23625 break;
23626 case SWIG_PY_STRING:
23627 if (constants[i].pvalue) {
23628 obj = PyString_FromString((char *) constants[i].pvalue);
23629 } else {
23630 Py_INCREF(Py_None);
23631 obj = Py_None;
23632 }
23633 break;
23634 case SWIG_PY_POINTER:
23635 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
23636 break;
23637 case SWIG_PY_BINARY:
23638 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
23639 break;
23640 default:
23641 obj = 0;
23642 break;
23643 }
23644 if (obj) {
23645 PyDict_SetItemString(d,constants[i].name,obj);
23646 Py_DECREF(obj);
23647 }
23648 }
23649 }
23650
23651 /* -----------------------------------------------------------------------------*/
23652 /* Fix SwigMethods to carry the callback ptrs when needed */
23653 /* -----------------------------------------------------------------------------*/
23654
23655 static void
23656 SWIG_Python_FixMethods(PyMethodDef *methods,
23657 swig_const_info *const_table,
23658 swig_type_info **types,
23659 swig_type_info **types_initial) {
23660 size_t i;
23661 for (i = 0; methods[i].ml_name; ++i) {
23662 char *c = methods[i].ml_doc;
23663 if (c && (c = strstr(c, "swig_ptr: "))) {
23664 int j;
23665 swig_const_info *ci = 0;
23666 char *name = c + 10;
23667 for (j = 0; const_table[j].type; j++) {
23668 if (strncmp(const_table[j].name, name,
23669 strlen(const_table[j].name)) == 0) {
23670 ci = &(const_table[j]);
23671 break;
23672 }
23673 }
23674 if (ci) {
23675 size_t shift = (ci->ptype) - types;
23676 swig_type_info *ty = types_initial[shift];
23677 size_t ldoc = (c - methods[i].ml_doc);
23678 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
23679 char *ndoc = (char*)malloc(ldoc + lptr + 10);
23680 char *buff = ndoc;
23681 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
23682 strncpy(buff, methods[i].ml_doc, ldoc);
23683 buff += ldoc;
23684 strncpy(buff, "swig_ptr: ", 10);
23685 buff += 10;
23686 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
23687 methods[i].ml_doc = ndoc;
23688 }
23689 }
23690 }
23691 }
23692
23693 /* -----------------------------------------------------------------------------*
23694 * Initialize type list
23695 * -----------------------------------------------------------------------------*/
23696
23697 #if PY_MAJOR_VERSION < 2
23698 /* PyModule_AddObject function was introduced in Python 2.0. The following function
23699 is copied out of Python/modsupport.c in python version 2.3.4 */
23700 static int
23701 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
23702 {
23703 PyObject *dict;
23704 if (!PyModule_Check(m)) {
23705 PyErr_SetString(PyExc_TypeError,
23706 "PyModule_AddObject() needs module as first arg");
23707 return -1;
23708 }
23709 if (!o) {
23710 PyErr_SetString(PyExc_TypeError,
23711 "PyModule_AddObject() needs non-NULL value");
23712 return -1;
23713 }
23714
23715 dict = PyModule_GetDict(m);
23716 if (dict == NULL) {
23717 /* Internal error -- modules must have a dict! */
23718 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
23719 PyModule_GetName(m));
23720 return -1;
23721 }
23722 if (PyDict_SetItemString(dict, name, o))
23723 return -1;
23724 Py_DECREF(o);
23725 return 0;
23726 }
23727 #endif
23728
23729 static swig_type_info **
23730 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
23731 static PyMethodDef swig_empty_runtime_method_table[] = {
23732 {
23733 NULL, NULL, 0, NULL
23734 }
23735 };/* Sentinel */
23736
23737 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
23738 swig_empty_runtime_method_table);
23739 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
23740 if (pointer && module) {
23741 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
23742 }
23743 return type_list_handle;
23744 }
23745
23746 static swig_type_info **
23747 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
23748 swig_type_info **type_pointer;
23749
23750 /* first check if module already created */
23751 type_pointer = SWIG_Python_GetTypeListHandle();
23752 if (type_pointer) {
23753 return type_pointer;
23754 } else {
23755 /* create a new module and variable */
23756 return SWIG_Python_SetTypeListHandle(type_list_handle);
23757 }
23758 }
23759
23760 #ifdef __cplusplus
23761 }
23762 #endif
23763
23764 /* -----------------------------------------------------------------------------*
23765 * Partial Init method
23766 * -----------------------------------------------------------------------------*/
23767
23768 #ifdef SWIG_LINK_RUNTIME
23769 #ifdef __cplusplus
23770 extern "C"
23771 #endif
23772 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
23773 #endif
23774
23775 #ifdef __cplusplus
23776 extern "C"
23777 #endif
23778 SWIGEXPORT(void) SWIG_init(void) {
23779 static PyObject *SWIG_globals = 0;
23780 static int typeinit = 0;
23781 PyObject *m, *d;
23782 int i;
23783 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
23784
23785 /* Fix SwigMethods to carry the callback ptrs when needed */
23786 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
23787
23788 m = Py_InitModule((char *) SWIG_name, SwigMethods);
23789 d = PyModule_GetDict(m);
23790
23791 if (!typeinit) {
23792 #ifdef SWIG_LINK_RUNTIME
23793 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
23794 #else
23795 # ifndef SWIG_STATIC_RUNTIME
23796 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
23797 # endif
23798 #endif
23799 for (i = 0; swig_types_initial[i]; i++) {
23800 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
23801 }
23802 typeinit = 1;
23803 }
23804 SWIG_InstallConstants(d,swig_const_table);
23805
23806 {
23807 PyDict_SetItemString(d,"OutRegion", SWIG_From_int((int)(wxOutRegion)));
23808 }
23809 {
23810 PyDict_SetItemString(d,"PartRegion", SWIG_From_int((int)(wxPartRegion)));
23811 }
23812 {
23813 PyDict_SetItemString(d,"InRegion", SWIG_From_int((int)(wxInRegion)));
23814 }
23815 {
23816 PyDict_SetItemString(d,"FONTFAMILY_DEFAULT", SWIG_From_int((int)(wxFONTFAMILY_DEFAULT)));
23817 }
23818 {
23819 PyDict_SetItemString(d,"FONTFAMILY_DECORATIVE", SWIG_From_int((int)(wxFONTFAMILY_DECORATIVE)));
23820 }
23821 {
23822 PyDict_SetItemString(d,"FONTFAMILY_ROMAN", SWIG_From_int((int)(wxFONTFAMILY_ROMAN)));
23823 }
23824 {
23825 PyDict_SetItemString(d,"FONTFAMILY_SCRIPT", SWIG_From_int((int)(wxFONTFAMILY_SCRIPT)));
23826 }
23827 {
23828 PyDict_SetItemString(d,"FONTFAMILY_SWISS", SWIG_From_int((int)(wxFONTFAMILY_SWISS)));
23829 }
23830 {
23831 PyDict_SetItemString(d,"FONTFAMILY_MODERN", SWIG_From_int((int)(wxFONTFAMILY_MODERN)));
23832 }
23833 {
23834 PyDict_SetItemString(d,"FONTFAMILY_TELETYPE", SWIG_From_int((int)(wxFONTFAMILY_TELETYPE)));
23835 }
23836 {
23837 PyDict_SetItemString(d,"FONTFAMILY_MAX", SWIG_From_int((int)(wxFONTFAMILY_MAX)));
23838 }
23839 {
23840 PyDict_SetItemString(d,"FONTFAMILY_UNKNOWN", SWIG_From_int((int)(wxFONTFAMILY_UNKNOWN)));
23841 }
23842 {
23843 PyDict_SetItemString(d,"FONTSTYLE_NORMAL", SWIG_From_int((int)(wxFONTSTYLE_NORMAL)));
23844 }
23845 {
23846 PyDict_SetItemString(d,"FONTSTYLE_ITALIC", SWIG_From_int((int)(wxFONTSTYLE_ITALIC)));
23847 }
23848 {
23849 PyDict_SetItemString(d,"FONTSTYLE_SLANT", SWIG_From_int((int)(wxFONTSTYLE_SLANT)));
23850 }
23851 {
23852 PyDict_SetItemString(d,"FONTSTYLE_MAX", SWIG_From_int((int)(wxFONTSTYLE_MAX)));
23853 }
23854 {
23855 PyDict_SetItemString(d,"FONTWEIGHT_NORMAL", SWIG_From_int((int)(wxFONTWEIGHT_NORMAL)));
23856 }
23857 {
23858 PyDict_SetItemString(d,"FONTWEIGHT_LIGHT", SWIG_From_int((int)(wxFONTWEIGHT_LIGHT)));
23859 }
23860 {
23861 PyDict_SetItemString(d,"FONTWEIGHT_BOLD", SWIG_From_int((int)(wxFONTWEIGHT_BOLD)));
23862 }
23863 {
23864 PyDict_SetItemString(d,"FONTWEIGHT_MAX", SWIG_From_int((int)(wxFONTWEIGHT_MAX)));
23865 }
23866 {
23867 PyDict_SetItemString(d,"FONTFLAG_DEFAULT", SWIG_From_int((int)(wxFONTFLAG_DEFAULT)));
23868 }
23869 {
23870 PyDict_SetItemString(d,"FONTFLAG_ITALIC", SWIG_From_int((int)(wxFONTFLAG_ITALIC)));
23871 }
23872 {
23873 PyDict_SetItemString(d,"FONTFLAG_SLANT", SWIG_From_int((int)(wxFONTFLAG_SLANT)));
23874 }
23875 {
23876 PyDict_SetItemString(d,"FONTFLAG_LIGHT", SWIG_From_int((int)(wxFONTFLAG_LIGHT)));
23877 }
23878 {
23879 PyDict_SetItemString(d,"FONTFLAG_BOLD", SWIG_From_int((int)(wxFONTFLAG_BOLD)));
23880 }
23881 {
23882 PyDict_SetItemString(d,"FONTFLAG_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_ANTIALIASED)));
23883 }
23884 {
23885 PyDict_SetItemString(d,"FONTFLAG_NOT_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_NOT_ANTIALIASED)));
23886 }
23887 {
23888 PyDict_SetItemString(d,"FONTFLAG_UNDERLINED", SWIG_From_int((int)(wxFONTFLAG_UNDERLINED)));
23889 }
23890 {
23891 PyDict_SetItemString(d,"FONTFLAG_STRIKETHROUGH", SWIG_From_int((int)(wxFONTFLAG_STRIKETHROUGH)));
23892 }
23893 {
23894 PyDict_SetItemString(d,"FONTFLAG_MASK", SWIG_From_int((int)(wxFONTFLAG_MASK)));
23895 }
23896 {
23897 PyDict_SetItemString(d,"FONTENCODING_SYSTEM", SWIG_From_int((int)(wxFONTENCODING_SYSTEM)));
23898 }
23899 {
23900 PyDict_SetItemString(d,"FONTENCODING_DEFAULT", SWIG_From_int((int)(wxFONTENCODING_DEFAULT)));
23901 }
23902 {
23903 PyDict_SetItemString(d,"FONTENCODING_ISO8859_1", SWIG_From_int((int)(wxFONTENCODING_ISO8859_1)));
23904 }
23905 {
23906 PyDict_SetItemString(d,"FONTENCODING_ISO8859_2", SWIG_From_int((int)(wxFONTENCODING_ISO8859_2)));
23907 }
23908 {
23909 PyDict_SetItemString(d,"FONTENCODING_ISO8859_3", SWIG_From_int((int)(wxFONTENCODING_ISO8859_3)));
23910 }
23911 {
23912 PyDict_SetItemString(d,"FONTENCODING_ISO8859_4", SWIG_From_int((int)(wxFONTENCODING_ISO8859_4)));
23913 }
23914 {
23915 PyDict_SetItemString(d,"FONTENCODING_ISO8859_5", SWIG_From_int((int)(wxFONTENCODING_ISO8859_5)));
23916 }
23917 {
23918 PyDict_SetItemString(d,"FONTENCODING_ISO8859_6", SWIG_From_int((int)(wxFONTENCODING_ISO8859_6)));
23919 }
23920 {
23921 PyDict_SetItemString(d,"FONTENCODING_ISO8859_7", SWIG_From_int((int)(wxFONTENCODING_ISO8859_7)));
23922 }
23923 {
23924 PyDict_SetItemString(d,"FONTENCODING_ISO8859_8", SWIG_From_int((int)(wxFONTENCODING_ISO8859_8)));
23925 }
23926 {
23927 PyDict_SetItemString(d,"FONTENCODING_ISO8859_9", SWIG_From_int((int)(wxFONTENCODING_ISO8859_9)));
23928 }
23929 {
23930 PyDict_SetItemString(d,"FONTENCODING_ISO8859_10", SWIG_From_int((int)(wxFONTENCODING_ISO8859_10)));
23931 }
23932 {
23933 PyDict_SetItemString(d,"FONTENCODING_ISO8859_11", SWIG_From_int((int)(wxFONTENCODING_ISO8859_11)));
23934 }
23935 {
23936 PyDict_SetItemString(d,"FONTENCODING_ISO8859_12", SWIG_From_int((int)(wxFONTENCODING_ISO8859_12)));
23937 }
23938 {
23939 PyDict_SetItemString(d,"FONTENCODING_ISO8859_13", SWIG_From_int((int)(wxFONTENCODING_ISO8859_13)));
23940 }
23941 {
23942 PyDict_SetItemString(d,"FONTENCODING_ISO8859_14", SWIG_From_int((int)(wxFONTENCODING_ISO8859_14)));
23943 }
23944 {
23945 PyDict_SetItemString(d,"FONTENCODING_ISO8859_15", SWIG_From_int((int)(wxFONTENCODING_ISO8859_15)));
23946 }
23947 {
23948 PyDict_SetItemString(d,"FONTENCODING_ISO8859_MAX", SWIG_From_int((int)(wxFONTENCODING_ISO8859_MAX)));
23949 }
23950 {
23951 PyDict_SetItemString(d,"FONTENCODING_KOI8", SWIG_From_int((int)(wxFONTENCODING_KOI8)));
23952 }
23953 {
23954 PyDict_SetItemString(d,"FONTENCODING_KOI8_U", SWIG_From_int((int)(wxFONTENCODING_KOI8_U)));
23955 }
23956 {
23957 PyDict_SetItemString(d,"FONTENCODING_ALTERNATIVE", SWIG_From_int((int)(wxFONTENCODING_ALTERNATIVE)));
23958 }
23959 {
23960 PyDict_SetItemString(d,"FONTENCODING_BULGARIAN", SWIG_From_int((int)(wxFONTENCODING_BULGARIAN)));
23961 }
23962 {
23963 PyDict_SetItemString(d,"FONTENCODING_CP437", SWIG_From_int((int)(wxFONTENCODING_CP437)));
23964 }
23965 {
23966 PyDict_SetItemString(d,"FONTENCODING_CP850", SWIG_From_int((int)(wxFONTENCODING_CP850)));
23967 }
23968 {
23969 PyDict_SetItemString(d,"FONTENCODING_CP852", SWIG_From_int((int)(wxFONTENCODING_CP852)));
23970 }
23971 {
23972 PyDict_SetItemString(d,"FONTENCODING_CP855", SWIG_From_int((int)(wxFONTENCODING_CP855)));
23973 }
23974 {
23975 PyDict_SetItemString(d,"FONTENCODING_CP866", SWIG_From_int((int)(wxFONTENCODING_CP866)));
23976 }
23977 {
23978 PyDict_SetItemString(d,"FONTENCODING_CP874", SWIG_From_int((int)(wxFONTENCODING_CP874)));
23979 }
23980 {
23981 PyDict_SetItemString(d,"FONTENCODING_CP932", SWIG_From_int((int)(wxFONTENCODING_CP932)));
23982 }
23983 {
23984 PyDict_SetItemString(d,"FONTENCODING_CP936", SWIG_From_int((int)(wxFONTENCODING_CP936)));
23985 }
23986 {
23987 PyDict_SetItemString(d,"FONTENCODING_CP949", SWIG_From_int((int)(wxFONTENCODING_CP949)));
23988 }
23989 {
23990 PyDict_SetItemString(d,"FONTENCODING_CP950", SWIG_From_int((int)(wxFONTENCODING_CP950)));
23991 }
23992 {
23993 PyDict_SetItemString(d,"FONTENCODING_CP1250", SWIG_From_int((int)(wxFONTENCODING_CP1250)));
23994 }
23995 {
23996 PyDict_SetItemString(d,"FONTENCODING_CP1251", SWIG_From_int((int)(wxFONTENCODING_CP1251)));
23997 }
23998 {
23999 PyDict_SetItemString(d,"FONTENCODING_CP1252", SWIG_From_int((int)(wxFONTENCODING_CP1252)));
24000 }
24001 {
24002 PyDict_SetItemString(d,"FONTENCODING_CP1253", SWIG_From_int((int)(wxFONTENCODING_CP1253)));
24003 }
24004 {
24005 PyDict_SetItemString(d,"FONTENCODING_CP1254", SWIG_From_int((int)(wxFONTENCODING_CP1254)));
24006 }
24007 {
24008 PyDict_SetItemString(d,"FONTENCODING_CP1255", SWIG_From_int((int)(wxFONTENCODING_CP1255)));
24009 }
24010 {
24011 PyDict_SetItemString(d,"FONTENCODING_CP1256", SWIG_From_int((int)(wxFONTENCODING_CP1256)));
24012 }
24013 {
24014 PyDict_SetItemString(d,"FONTENCODING_CP1257", SWIG_From_int((int)(wxFONTENCODING_CP1257)));
24015 }
24016 {
24017 PyDict_SetItemString(d,"FONTENCODING_CP12_MAX", SWIG_From_int((int)(wxFONTENCODING_CP12_MAX)));
24018 }
24019 {
24020 PyDict_SetItemString(d,"FONTENCODING_UTF7", SWIG_From_int((int)(wxFONTENCODING_UTF7)));
24021 }
24022 {
24023 PyDict_SetItemString(d,"FONTENCODING_UTF8", SWIG_From_int((int)(wxFONTENCODING_UTF8)));
24024 }
24025 {
24026 PyDict_SetItemString(d,"FONTENCODING_EUC_JP", SWIG_From_int((int)(wxFONTENCODING_EUC_JP)));
24027 }
24028 {
24029 PyDict_SetItemString(d,"FONTENCODING_UTF16BE", SWIG_From_int((int)(wxFONTENCODING_UTF16BE)));
24030 }
24031 {
24032 PyDict_SetItemString(d,"FONTENCODING_UTF16LE", SWIG_From_int((int)(wxFONTENCODING_UTF16LE)));
24033 }
24034 {
24035 PyDict_SetItemString(d,"FONTENCODING_UTF32BE", SWIG_From_int((int)(wxFONTENCODING_UTF32BE)));
24036 }
24037 {
24038 PyDict_SetItemString(d,"FONTENCODING_UTF32LE", SWIG_From_int((int)(wxFONTENCODING_UTF32LE)));
24039 }
24040 {
24041 PyDict_SetItemString(d,"FONTENCODING_MACROMAN", SWIG_From_int((int)(wxFONTENCODING_MACROMAN)));
24042 }
24043 {
24044 PyDict_SetItemString(d,"FONTENCODING_MACJAPANESE", SWIG_From_int((int)(wxFONTENCODING_MACJAPANESE)));
24045 }
24046 {
24047 PyDict_SetItemString(d,"FONTENCODING_MACCHINESETRAD", SWIG_From_int((int)(wxFONTENCODING_MACCHINESETRAD)));
24048 }
24049 {
24050 PyDict_SetItemString(d,"FONTENCODING_MACKOREAN", SWIG_From_int((int)(wxFONTENCODING_MACKOREAN)));
24051 }
24052 {
24053 PyDict_SetItemString(d,"FONTENCODING_MACARABIC", SWIG_From_int((int)(wxFONTENCODING_MACARABIC)));
24054 }
24055 {
24056 PyDict_SetItemString(d,"FONTENCODING_MACHEBREW", SWIG_From_int((int)(wxFONTENCODING_MACHEBREW)));
24057 }
24058 {
24059 PyDict_SetItemString(d,"FONTENCODING_MACGREEK", SWIG_From_int((int)(wxFONTENCODING_MACGREEK)));
24060 }
24061 {
24062 PyDict_SetItemString(d,"FONTENCODING_MACCYRILLIC", SWIG_From_int((int)(wxFONTENCODING_MACCYRILLIC)));
24063 }
24064 {
24065 PyDict_SetItemString(d,"FONTENCODING_MACDEVANAGARI", SWIG_From_int((int)(wxFONTENCODING_MACDEVANAGARI)));
24066 }
24067 {
24068 PyDict_SetItemString(d,"FONTENCODING_MACGURMUKHI", SWIG_From_int((int)(wxFONTENCODING_MACGURMUKHI)));
24069 }
24070 {
24071 PyDict_SetItemString(d,"FONTENCODING_MACGUJARATI", SWIG_From_int((int)(wxFONTENCODING_MACGUJARATI)));
24072 }
24073 {
24074 PyDict_SetItemString(d,"FONTENCODING_MACORIYA", SWIG_From_int((int)(wxFONTENCODING_MACORIYA)));
24075 }
24076 {
24077 PyDict_SetItemString(d,"FONTENCODING_MACBENGALI", SWIG_From_int((int)(wxFONTENCODING_MACBENGALI)));
24078 }
24079 {
24080 PyDict_SetItemString(d,"FONTENCODING_MACTAMIL", SWIG_From_int((int)(wxFONTENCODING_MACTAMIL)));
24081 }
24082 {
24083 PyDict_SetItemString(d,"FONTENCODING_MACTELUGU", SWIG_From_int((int)(wxFONTENCODING_MACTELUGU)));
24084 }
24085 {
24086 PyDict_SetItemString(d,"FONTENCODING_MACKANNADA", SWIG_From_int((int)(wxFONTENCODING_MACKANNADA)));
24087 }
24088 {
24089 PyDict_SetItemString(d,"FONTENCODING_MACMALAJALAM", SWIG_From_int((int)(wxFONTENCODING_MACMALAJALAM)));
24090 }
24091 {
24092 PyDict_SetItemString(d,"FONTENCODING_MACSINHALESE", SWIG_From_int((int)(wxFONTENCODING_MACSINHALESE)));
24093 }
24094 {
24095 PyDict_SetItemString(d,"FONTENCODING_MACBURMESE", SWIG_From_int((int)(wxFONTENCODING_MACBURMESE)));
24096 }
24097 {
24098 PyDict_SetItemString(d,"FONTENCODING_MACKHMER", SWIG_From_int((int)(wxFONTENCODING_MACKHMER)));
24099 }
24100 {
24101 PyDict_SetItemString(d,"FONTENCODING_MACTHAI", SWIG_From_int((int)(wxFONTENCODING_MACTHAI)));
24102 }
24103 {
24104 PyDict_SetItemString(d,"FONTENCODING_MACLAOTIAN", SWIG_From_int((int)(wxFONTENCODING_MACLAOTIAN)));
24105 }
24106 {
24107 PyDict_SetItemString(d,"FONTENCODING_MACGEORGIAN", SWIG_From_int((int)(wxFONTENCODING_MACGEORGIAN)));
24108 }
24109 {
24110 PyDict_SetItemString(d,"FONTENCODING_MACARMENIAN", SWIG_From_int((int)(wxFONTENCODING_MACARMENIAN)));
24111 }
24112 {
24113 PyDict_SetItemString(d,"FONTENCODING_MACCHINESESIMP", SWIG_From_int((int)(wxFONTENCODING_MACCHINESESIMP)));
24114 }
24115 {
24116 PyDict_SetItemString(d,"FONTENCODING_MACTIBETAN", SWIG_From_int((int)(wxFONTENCODING_MACTIBETAN)));
24117 }
24118 {
24119 PyDict_SetItemString(d,"FONTENCODING_MACMONGOLIAN", SWIG_From_int((int)(wxFONTENCODING_MACMONGOLIAN)));
24120 }
24121 {
24122 PyDict_SetItemString(d,"FONTENCODING_MACETHIOPIC", SWIG_From_int((int)(wxFONTENCODING_MACETHIOPIC)));
24123 }
24124 {
24125 PyDict_SetItemString(d,"FONTENCODING_MACCENTRALEUR", SWIG_From_int((int)(wxFONTENCODING_MACCENTRALEUR)));
24126 }
24127 {
24128 PyDict_SetItemString(d,"FONTENCODING_MACVIATNAMESE", SWIG_From_int((int)(wxFONTENCODING_MACVIATNAMESE)));
24129 }
24130 {
24131 PyDict_SetItemString(d,"FONTENCODING_MACARABICEXT", SWIG_From_int((int)(wxFONTENCODING_MACARABICEXT)));
24132 }
24133 {
24134 PyDict_SetItemString(d,"FONTENCODING_MACSYMBOL", SWIG_From_int((int)(wxFONTENCODING_MACSYMBOL)));
24135 }
24136 {
24137 PyDict_SetItemString(d,"FONTENCODING_MACDINGBATS", SWIG_From_int((int)(wxFONTENCODING_MACDINGBATS)));
24138 }
24139 {
24140 PyDict_SetItemString(d,"FONTENCODING_MACTURKISH", SWIG_From_int((int)(wxFONTENCODING_MACTURKISH)));
24141 }
24142 {
24143 PyDict_SetItemString(d,"FONTENCODING_MACCROATIAN", SWIG_From_int((int)(wxFONTENCODING_MACCROATIAN)));
24144 }
24145 {
24146 PyDict_SetItemString(d,"FONTENCODING_MACICELANDIC", SWIG_From_int((int)(wxFONTENCODING_MACICELANDIC)));
24147 }
24148 {
24149 PyDict_SetItemString(d,"FONTENCODING_MACROMANIAN", SWIG_From_int((int)(wxFONTENCODING_MACROMANIAN)));
24150 }
24151 {
24152 PyDict_SetItemString(d,"FONTENCODING_MACCELTIC", SWIG_From_int((int)(wxFONTENCODING_MACCELTIC)));
24153 }
24154 {
24155 PyDict_SetItemString(d,"FONTENCODING_MACGAELIC", SWIG_From_int((int)(wxFONTENCODING_MACGAELIC)));
24156 }
24157 {
24158 PyDict_SetItemString(d,"FONTENCODING_MACKEYBOARD", SWIG_From_int((int)(wxFONTENCODING_MACKEYBOARD)));
24159 }
24160 {
24161 PyDict_SetItemString(d,"FONTENCODING_MACMIN", SWIG_From_int((int)(wxFONTENCODING_MACMIN)));
24162 }
24163 {
24164 PyDict_SetItemString(d,"FONTENCODING_MACMAX", SWIG_From_int((int)(wxFONTENCODING_MACMAX)));
24165 }
24166 {
24167 PyDict_SetItemString(d,"FONTENCODING_MAX", SWIG_From_int((int)(wxFONTENCODING_MAX)));
24168 }
24169 {
24170 PyDict_SetItemString(d,"FONTENCODING_UTF16", SWIG_From_int((int)(wxFONTENCODING_UTF16)));
24171 }
24172 {
24173 PyDict_SetItemString(d,"FONTENCODING_UTF32", SWIG_From_int((int)(wxFONTENCODING_UTF32)));
24174 }
24175 {
24176 PyDict_SetItemString(d,"FONTENCODING_UNICODE", SWIG_From_int((int)(wxFONTENCODING_UNICODE)));
24177 }
24178 {
24179 PyDict_SetItemString(d,"FONTENCODING_GB2312", SWIG_From_int((int)(wxFONTENCODING_GB2312)));
24180 }
24181 {
24182 PyDict_SetItemString(d,"FONTENCODING_BIG5", SWIG_From_int((int)(wxFONTENCODING_BIG5)));
24183 }
24184 {
24185 PyDict_SetItemString(d,"FONTENCODING_SHIFT_JIS", SWIG_From_int((int)(wxFONTENCODING_SHIFT_JIS)));
24186 }
24187
24188 wxPyPtrTypeMap_Add("wxFontEnumerator", "wxPyFontEnumerator");
24189
24190 {
24191 PyDict_SetItemString(d,"LANGUAGE_DEFAULT", SWIG_From_int((int)(wxLANGUAGE_DEFAULT)));
24192 }
24193 {
24194 PyDict_SetItemString(d,"LANGUAGE_UNKNOWN", SWIG_From_int((int)(wxLANGUAGE_UNKNOWN)));
24195 }
24196 {
24197 PyDict_SetItemString(d,"LANGUAGE_ABKHAZIAN", SWIG_From_int((int)(wxLANGUAGE_ABKHAZIAN)));
24198 }
24199 {
24200 PyDict_SetItemString(d,"LANGUAGE_AFAR", SWIG_From_int((int)(wxLANGUAGE_AFAR)));
24201 }
24202 {
24203 PyDict_SetItemString(d,"LANGUAGE_AFRIKAANS", SWIG_From_int((int)(wxLANGUAGE_AFRIKAANS)));
24204 }
24205 {
24206 PyDict_SetItemString(d,"LANGUAGE_ALBANIAN", SWIG_From_int((int)(wxLANGUAGE_ALBANIAN)));
24207 }
24208 {
24209 PyDict_SetItemString(d,"LANGUAGE_AMHARIC", SWIG_From_int((int)(wxLANGUAGE_AMHARIC)));
24210 }
24211 {
24212 PyDict_SetItemString(d,"LANGUAGE_ARABIC", SWIG_From_int((int)(wxLANGUAGE_ARABIC)));
24213 }
24214 {
24215 PyDict_SetItemString(d,"LANGUAGE_ARABIC_ALGERIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_ALGERIA)));
24216 }
24217 {
24218 PyDict_SetItemString(d,"LANGUAGE_ARABIC_BAHRAIN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_BAHRAIN)));
24219 }
24220 {
24221 PyDict_SetItemString(d,"LANGUAGE_ARABIC_EGYPT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_EGYPT)));
24222 }
24223 {
24224 PyDict_SetItemString(d,"LANGUAGE_ARABIC_IRAQ", SWIG_From_int((int)(wxLANGUAGE_ARABIC_IRAQ)));
24225 }
24226 {
24227 PyDict_SetItemString(d,"LANGUAGE_ARABIC_JORDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_JORDAN)));
24228 }
24229 {
24230 PyDict_SetItemString(d,"LANGUAGE_ARABIC_KUWAIT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_KUWAIT)));
24231 }
24232 {
24233 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LEBANON", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LEBANON)));
24234 }
24235 {
24236 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LIBYA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LIBYA)));
24237 }
24238 {
24239 PyDict_SetItemString(d,"LANGUAGE_ARABIC_MOROCCO", SWIG_From_int((int)(wxLANGUAGE_ARABIC_MOROCCO)));
24240 }
24241 {
24242 PyDict_SetItemString(d,"LANGUAGE_ARABIC_OMAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_OMAN)));
24243 }
24244 {
24245 PyDict_SetItemString(d,"LANGUAGE_ARABIC_QATAR", SWIG_From_int((int)(wxLANGUAGE_ARABIC_QATAR)));
24246 }
24247 {
24248 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SAUDI_ARABIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SAUDI_ARABIA)));
24249 }
24250 {
24251 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SUDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SUDAN)));
24252 }
24253 {
24254 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SYRIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SYRIA)));
24255 }
24256 {
24257 PyDict_SetItemString(d,"LANGUAGE_ARABIC_TUNISIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_TUNISIA)));
24258 }
24259 {
24260 PyDict_SetItemString(d,"LANGUAGE_ARABIC_UAE", SWIG_From_int((int)(wxLANGUAGE_ARABIC_UAE)));
24261 }
24262 {
24263 PyDict_SetItemString(d,"LANGUAGE_ARABIC_YEMEN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_YEMEN)));
24264 }
24265 {
24266 PyDict_SetItemString(d,"LANGUAGE_ARMENIAN", SWIG_From_int((int)(wxLANGUAGE_ARMENIAN)));
24267 }
24268 {
24269 PyDict_SetItemString(d,"LANGUAGE_ASSAMESE", SWIG_From_int((int)(wxLANGUAGE_ASSAMESE)));
24270 }
24271 {
24272 PyDict_SetItemString(d,"LANGUAGE_AYMARA", SWIG_From_int((int)(wxLANGUAGE_AYMARA)));
24273 }
24274 {
24275 PyDict_SetItemString(d,"LANGUAGE_AZERI", SWIG_From_int((int)(wxLANGUAGE_AZERI)));
24276 }
24277 {
24278 PyDict_SetItemString(d,"LANGUAGE_AZERI_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_AZERI_CYRILLIC)));
24279 }
24280 {
24281 PyDict_SetItemString(d,"LANGUAGE_AZERI_LATIN", SWIG_From_int((int)(wxLANGUAGE_AZERI_LATIN)));
24282 }
24283 {
24284 PyDict_SetItemString(d,"LANGUAGE_BASHKIR", SWIG_From_int((int)(wxLANGUAGE_BASHKIR)));
24285 }
24286 {
24287 PyDict_SetItemString(d,"LANGUAGE_BASQUE", SWIG_From_int((int)(wxLANGUAGE_BASQUE)));
24288 }
24289 {
24290 PyDict_SetItemString(d,"LANGUAGE_BELARUSIAN", SWIG_From_int((int)(wxLANGUAGE_BELARUSIAN)));
24291 }
24292 {
24293 PyDict_SetItemString(d,"LANGUAGE_BENGALI", SWIG_From_int((int)(wxLANGUAGE_BENGALI)));
24294 }
24295 {
24296 PyDict_SetItemString(d,"LANGUAGE_BHUTANI", SWIG_From_int((int)(wxLANGUAGE_BHUTANI)));
24297 }
24298 {
24299 PyDict_SetItemString(d,"LANGUAGE_BIHARI", SWIG_From_int((int)(wxLANGUAGE_BIHARI)));
24300 }
24301 {
24302 PyDict_SetItemString(d,"LANGUAGE_BISLAMA", SWIG_From_int((int)(wxLANGUAGE_BISLAMA)));
24303 }
24304 {
24305 PyDict_SetItemString(d,"LANGUAGE_BRETON", SWIG_From_int((int)(wxLANGUAGE_BRETON)));
24306 }
24307 {
24308 PyDict_SetItemString(d,"LANGUAGE_BULGARIAN", SWIG_From_int((int)(wxLANGUAGE_BULGARIAN)));
24309 }
24310 {
24311 PyDict_SetItemString(d,"LANGUAGE_BURMESE", SWIG_From_int((int)(wxLANGUAGE_BURMESE)));
24312 }
24313 {
24314 PyDict_SetItemString(d,"LANGUAGE_CAMBODIAN", SWIG_From_int((int)(wxLANGUAGE_CAMBODIAN)));
24315 }
24316 {
24317 PyDict_SetItemString(d,"LANGUAGE_CATALAN", SWIG_From_int((int)(wxLANGUAGE_CATALAN)));
24318 }
24319 {
24320 PyDict_SetItemString(d,"LANGUAGE_CHINESE", SWIG_From_int((int)(wxLANGUAGE_CHINESE)));
24321 }
24322 {
24323 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SIMPLIFIED", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SIMPLIFIED)));
24324 }
24325 {
24326 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TRADITIONAL", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TRADITIONAL)));
24327 }
24328 {
24329 PyDict_SetItemString(d,"LANGUAGE_CHINESE_HONGKONG", SWIG_From_int((int)(wxLANGUAGE_CHINESE_HONGKONG)));
24330 }
24331 {
24332 PyDict_SetItemString(d,"LANGUAGE_CHINESE_MACAU", SWIG_From_int((int)(wxLANGUAGE_CHINESE_MACAU)));
24333 }
24334 {
24335 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SINGAPORE", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SINGAPORE)));
24336 }
24337 {
24338 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TAIWAN", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TAIWAN)));
24339 }
24340 {
24341 PyDict_SetItemString(d,"LANGUAGE_CORSICAN", SWIG_From_int((int)(wxLANGUAGE_CORSICAN)));
24342 }
24343 {
24344 PyDict_SetItemString(d,"LANGUAGE_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_CROATIAN)));
24345 }
24346 {
24347 PyDict_SetItemString(d,"LANGUAGE_CZECH", SWIG_From_int((int)(wxLANGUAGE_CZECH)));
24348 }
24349 {
24350 PyDict_SetItemString(d,"LANGUAGE_DANISH", SWIG_From_int((int)(wxLANGUAGE_DANISH)));
24351 }
24352 {
24353 PyDict_SetItemString(d,"LANGUAGE_DUTCH", SWIG_From_int((int)(wxLANGUAGE_DUTCH)));
24354 }
24355 {
24356 PyDict_SetItemString(d,"LANGUAGE_DUTCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_DUTCH_BELGIAN)));
24357 }
24358 {
24359 PyDict_SetItemString(d,"LANGUAGE_ENGLISH", SWIG_From_int((int)(wxLANGUAGE_ENGLISH)));
24360 }
24361 {
24362 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_UK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_UK)));
24363 }
24364 {
24365 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_US", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_US)));
24366 }
24367 {
24368 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_AUSTRALIA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_AUSTRALIA)));
24369 }
24370 {
24371 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BELIZE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BELIZE)));
24372 }
24373 {
24374 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BOTSWANA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BOTSWANA)));
24375 }
24376 {
24377 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CANADA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CANADA)));
24378 }
24379 {
24380 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CARIBBEAN", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CARIBBEAN)));
24381 }
24382 {
24383 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_DENMARK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_DENMARK)));
24384 }
24385 {
24386 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_EIRE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_EIRE)));
24387 }
24388 {
24389 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_JAMAICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_JAMAICA)));
24390 }
24391 {
24392 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_NEW_ZEALAND", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_NEW_ZEALAND)));
24393 }
24394 {
24395 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_PHILIPPINES", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_PHILIPPINES)));
24396 }
24397 {
24398 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_SOUTH_AFRICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_SOUTH_AFRICA)));
24399 }
24400 {
24401 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_TRINIDAD", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_TRINIDAD)));
24402 }
24403 {
24404 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_ZIMBABWE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_ZIMBABWE)));
24405 }
24406 {
24407 PyDict_SetItemString(d,"LANGUAGE_ESPERANTO", SWIG_From_int((int)(wxLANGUAGE_ESPERANTO)));
24408 }
24409 {
24410 PyDict_SetItemString(d,"LANGUAGE_ESTONIAN", SWIG_From_int((int)(wxLANGUAGE_ESTONIAN)));
24411 }
24412 {
24413 PyDict_SetItemString(d,"LANGUAGE_FAEROESE", SWIG_From_int((int)(wxLANGUAGE_FAEROESE)));
24414 }
24415 {
24416 PyDict_SetItemString(d,"LANGUAGE_FARSI", SWIG_From_int((int)(wxLANGUAGE_FARSI)));
24417 }
24418 {
24419 PyDict_SetItemString(d,"LANGUAGE_FIJI", SWIG_From_int((int)(wxLANGUAGE_FIJI)));
24420 }
24421 {
24422 PyDict_SetItemString(d,"LANGUAGE_FINNISH", SWIG_From_int((int)(wxLANGUAGE_FINNISH)));
24423 }
24424 {
24425 PyDict_SetItemString(d,"LANGUAGE_FRENCH", SWIG_From_int((int)(wxLANGUAGE_FRENCH)));
24426 }
24427 {
24428 PyDict_SetItemString(d,"LANGUAGE_FRENCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_BELGIAN)));
24429 }
24430 {
24431 PyDict_SetItemString(d,"LANGUAGE_FRENCH_CANADIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_CANADIAN)));
24432 }
24433 {
24434 PyDict_SetItemString(d,"LANGUAGE_FRENCH_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_FRENCH_LUXEMBOURG)));
24435 }
24436 {
24437 PyDict_SetItemString(d,"LANGUAGE_FRENCH_MONACO", SWIG_From_int((int)(wxLANGUAGE_FRENCH_MONACO)));
24438 }
24439 {
24440 PyDict_SetItemString(d,"LANGUAGE_FRENCH_SWISS", SWIG_From_int((int)(wxLANGUAGE_FRENCH_SWISS)));
24441 }
24442 {
24443 PyDict_SetItemString(d,"LANGUAGE_FRISIAN", SWIG_From_int((int)(wxLANGUAGE_FRISIAN)));
24444 }
24445 {
24446 PyDict_SetItemString(d,"LANGUAGE_GALICIAN", SWIG_From_int((int)(wxLANGUAGE_GALICIAN)));
24447 }
24448 {
24449 PyDict_SetItemString(d,"LANGUAGE_GEORGIAN", SWIG_From_int((int)(wxLANGUAGE_GEORGIAN)));
24450 }
24451 {
24452 PyDict_SetItemString(d,"LANGUAGE_GERMAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN)));
24453 }
24454 {
24455 PyDict_SetItemString(d,"LANGUAGE_GERMAN_AUSTRIAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_AUSTRIAN)));
24456 }
24457 {
24458 PyDict_SetItemString(d,"LANGUAGE_GERMAN_BELGIUM", SWIG_From_int((int)(wxLANGUAGE_GERMAN_BELGIUM)));
24459 }
24460 {
24461 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LIECHTENSTEIN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LIECHTENSTEIN)));
24462 }
24463 {
24464 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LUXEMBOURG)));
24465 }
24466 {
24467 PyDict_SetItemString(d,"LANGUAGE_GERMAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_GERMAN_SWISS)));
24468 }
24469 {
24470 PyDict_SetItemString(d,"LANGUAGE_GREEK", SWIG_From_int((int)(wxLANGUAGE_GREEK)));
24471 }
24472 {
24473 PyDict_SetItemString(d,"LANGUAGE_GREENLANDIC", SWIG_From_int((int)(wxLANGUAGE_GREENLANDIC)));
24474 }
24475 {
24476 PyDict_SetItemString(d,"LANGUAGE_GUARANI", SWIG_From_int((int)(wxLANGUAGE_GUARANI)));
24477 }
24478 {
24479 PyDict_SetItemString(d,"LANGUAGE_GUJARATI", SWIG_From_int((int)(wxLANGUAGE_GUJARATI)));
24480 }
24481 {
24482 PyDict_SetItemString(d,"LANGUAGE_HAUSA", SWIG_From_int((int)(wxLANGUAGE_HAUSA)));
24483 }
24484 {
24485 PyDict_SetItemString(d,"LANGUAGE_HEBREW", SWIG_From_int((int)(wxLANGUAGE_HEBREW)));
24486 }
24487 {
24488 PyDict_SetItemString(d,"LANGUAGE_HINDI", SWIG_From_int((int)(wxLANGUAGE_HINDI)));
24489 }
24490 {
24491 PyDict_SetItemString(d,"LANGUAGE_HUNGARIAN", SWIG_From_int((int)(wxLANGUAGE_HUNGARIAN)));
24492 }
24493 {
24494 PyDict_SetItemString(d,"LANGUAGE_ICELANDIC", SWIG_From_int((int)(wxLANGUAGE_ICELANDIC)));
24495 }
24496 {
24497 PyDict_SetItemString(d,"LANGUAGE_INDONESIAN", SWIG_From_int((int)(wxLANGUAGE_INDONESIAN)));
24498 }
24499 {
24500 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUA", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUA)));
24501 }
24502 {
24503 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUE", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUE)));
24504 }
24505 {
24506 PyDict_SetItemString(d,"LANGUAGE_INUKTITUT", SWIG_From_int((int)(wxLANGUAGE_INUKTITUT)));
24507 }
24508 {
24509 PyDict_SetItemString(d,"LANGUAGE_INUPIAK", SWIG_From_int((int)(wxLANGUAGE_INUPIAK)));
24510 }
24511 {
24512 PyDict_SetItemString(d,"LANGUAGE_IRISH", SWIG_From_int((int)(wxLANGUAGE_IRISH)));
24513 }
24514 {
24515 PyDict_SetItemString(d,"LANGUAGE_ITALIAN", SWIG_From_int((int)(wxLANGUAGE_ITALIAN)));
24516 }
24517 {
24518 PyDict_SetItemString(d,"LANGUAGE_ITALIAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_ITALIAN_SWISS)));
24519 }
24520 {
24521 PyDict_SetItemString(d,"LANGUAGE_JAPANESE", SWIG_From_int((int)(wxLANGUAGE_JAPANESE)));
24522 }
24523 {
24524 PyDict_SetItemString(d,"LANGUAGE_JAVANESE", SWIG_From_int((int)(wxLANGUAGE_JAVANESE)));
24525 }
24526 {
24527 PyDict_SetItemString(d,"LANGUAGE_KANNADA", SWIG_From_int((int)(wxLANGUAGE_KANNADA)));
24528 }
24529 {
24530 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI)));
24531 }
24532 {
24533 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI_INDIA", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI_INDIA)));
24534 }
24535 {
24536 PyDict_SetItemString(d,"LANGUAGE_KAZAKH", SWIG_From_int((int)(wxLANGUAGE_KAZAKH)));
24537 }
24538 {
24539 PyDict_SetItemString(d,"LANGUAGE_KERNEWEK", SWIG_From_int((int)(wxLANGUAGE_KERNEWEK)));
24540 }
24541 {
24542 PyDict_SetItemString(d,"LANGUAGE_KINYARWANDA", SWIG_From_int((int)(wxLANGUAGE_KINYARWANDA)));
24543 }
24544 {
24545 PyDict_SetItemString(d,"LANGUAGE_KIRGHIZ", SWIG_From_int((int)(wxLANGUAGE_KIRGHIZ)));
24546 }
24547 {
24548 PyDict_SetItemString(d,"LANGUAGE_KIRUNDI", SWIG_From_int((int)(wxLANGUAGE_KIRUNDI)));
24549 }
24550 {
24551 PyDict_SetItemString(d,"LANGUAGE_KONKANI", SWIG_From_int((int)(wxLANGUAGE_KONKANI)));
24552 }
24553 {
24554 PyDict_SetItemString(d,"LANGUAGE_KOREAN", SWIG_From_int((int)(wxLANGUAGE_KOREAN)));
24555 }
24556 {
24557 PyDict_SetItemString(d,"LANGUAGE_KURDISH", SWIG_From_int((int)(wxLANGUAGE_KURDISH)));
24558 }
24559 {
24560 PyDict_SetItemString(d,"LANGUAGE_LAOTHIAN", SWIG_From_int((int)(wxLANGUAGE_LAOTHIAN)));
24561 }
24562 {
24563 PyDict_SetItemString(d,"LANGUAGE_LATIN", SWIG_From_int((int)(wxLANGUAGE_LATIN)));
24564 }
24565 {
24566 PyDict_SetItemString(d,"LANGUAGE_LATVIAN", SWIG_From_int((int)(wxLANGUAGE_LATVIAN)));
24567 }
24568 {
24569 PyDict_SetItemString(d,"LANGUAGE_LINGALA", SWIG_From_int((int)(wxLANGUAGE_LINGALA)));
24570 }
24571 {
24572 PyDict_SetItemString(d,"LANGUAGE_LITHUANIAN", SWIG_From_int((int)(wxLANGUAGE_LITHUANIAN)));
24573 }
24574 {
24575 PyDict_SetItemString(d,"LANGUAGE_MACEDONIAN", SWIG_From_int((int)(wxLANGUAGE_MACEDONIAN)));
24576 }
24577 {
24578 PyDict_SetItemString(d,"LANGUAGE_MALAGASY", SWIG_From_int((int)(wxLANGUAGE_MALAGASY)));
24579 }
24580 {
24581 PyDict_SetItemString(d,"LANGUAGE_MALAY", SWIG_From_int((int)(wxLANGUAGE_MALAY)));
24582 }
24583 {
24584 PyDict_SetItemString(d,"LANGUAGE_MALAYALAM", SWIG_From_int((int)(wxLANGUAGE_MALAYALAM)));
24585 }
24586 {
24587 PyDict_SetItemString(d,"LANGUAGE_MALAY_BRUNEI_DARUSSALAM", SWIG_From_int((int)(wxLANGUAGE_MALAY_BRUNEI_DARUSSALAM)));
24588 }
24589 {
24590 PyDict_SetItemString(d,"LANGUAGE_MALAY_MALAYSIA", SWIG_From_int((int)(wxLANGUAGE_MALAY_MALAYSIA)));
24591 }
24592 {
24593 PyDict_SetItemString(d,"LANGUAGE_MALTESE", SWIG_From_int((int)(wxLANGUAGE_MALTESE)));
24594 }
24595 {
24596 PyDict_SetItemString(d,"LANGUAGE_MANIPURI", SWIG_From_int((int)(wxLANGUAGE_MANIPURI)));
24597 }
24598 {
24599 PyDict_SetItemString(d,"LANGUAGE_MAORI", SWIG_From_int((int)(wxLANGUAGE_MAORI)));
24600 }
24601 {
24602 PyDict_SetItemString(d,"LANGUAGE_MARATHI", SWIG_From_int((int)(wxLANGUAGE_MARATHI)));
24603 }
24604 {
24605 PyDict_SetItemString(d,"LANGUAGE_MOLDAVIAN", SWIG_From_int((int)(wxLANGUAGE_MOLDAVIAN)));
24606 }
24607 {
24608 PyDict_SetItemString(d,"LANGUAGE_MONGOLIAN", SWIG_From_int((int)(wxLANGUAGE_MONGOLIAN)));
24609 }
24610 {
24611 PyDict_SetItemString(d,"LANGUAGE_NAURU", SWIG_From_int((int)(wxLANGUAGE_NAURU)));
24612 }
24613 {
24614 PyDict_SetItemString(d,"LANGUAGE_NEPALI", SWIG_From_int((int)(wxLANGUAGE_NEPALI)));
24615 }
24616 {
24617 PyDict_SetItemString(d,"LANGUAGE_NEPALI_INDIA", SWIG_From_int((int)(wxLANGUAGE_NEPALI_INDIA)));
24618 }
24619 {
24620 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_BOKMAL", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_BOKMAL)));
24621 }
24622 {
24623 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_NYNORSK", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_NYNORSK)));
24624 }
24625 {
24626 PyDict_SetItemString(d,"LANGUAGE_OCCITAN", SWIG_From_int((int)(wxLANGUAGE_OCCITAN)));
24627 }
24628 {
24629 PyDict_SetItemString(d,"LANGUAGE_ORIYA", SWIG_From_int((int)(wxLANGUAGE_ORIYA)));
24630 }
24631 {
24632 PyDict_SetItemString(d,"LANGUAGE_OROMO", SWIG_From_int((int)(wxLANGUAGE_OROMO)));
24633 }
24634 {
24635 PyDict_SetItemString(d,"LANGUAGE_PASHTO", SWIG_From_int((int)(wxLANGUAGE_PASHTO)));
24636 }
24637 {
24638 PyDict_SetItemString(d,"LANGUAGE_POLISH", SWIG_From_int((int)(wxLANGUAGE_POLISH)));
24639 }
24640 {
24641 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE)));
24642 }
24643 {
24644 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE_BRAZILIAN", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE_BRAZILIAN)));
24645 }
24646 {
24647 PyDict_SetItemString(d,"LANGUAGE_PUNJABI", SWIG_From_int((int)(wxLANGUAGE_PUNJABI)));
24648 }
24649 {
24650 PyDict_SetItemString(d,"LANGUAGE_QUECHUA", SWIG_From_int((int)(wxLANGUAGE_QUECHUA)));
24651 }
24652 {
24653 PyDict_SetItemString(d,"LANGUAGE_RHAETO_ROMANCE", SWIG_From_int((int)(wxLANGUAGE_RHAETO_ROMANCE)));
24654 }
24655 {
24656 PyDict_SetItemString(d,"LANGUAGE_ROMANIAN", SWIG_From_int((int)(wxLANGUAGE_ROMANIAN)));
24657 }
24658 {
24659 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN)));
24660 }
24661 {
24662 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN_UKRAINE", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN_UKRAINE)));
24663 }
24664 {
24665 PyDict_SetItemString(d,"LANGUAGE_SAMOAN", SWIG_From_int((int)(wxLANGUAGE_SAMOAN)));
24666 }
24667 {
24668 PyDict_SetItemString(d,"LANGUAGE_SANGHO", SWIG_From_int((int)(wxLANGUAGE_SANGHO)));
24669 }
24670 {
24671 PyDict_SetItemString(d,"LANGUAGE_SANSKRIT", SWIG_From_int((int)(wxLANGUAGE_SANSKRIT)));
24672 }
24673 {
24674 PyDict_SetItemString(d,"LANGUAGE_SCOTS_GAELIC", SWIG_From_int((int)(wxLANGUAGE_SCOTS_GAELIC)));
24675 }
24676 {
24677 PyDict_SetItemString(d,"LANGUAGE_SERBIAN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN)));
24678 }
24679 {
24680 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_CYRILLIC)));
24681 }
24682 {
24683 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_LATIN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_LATIN)));
24684 }
24685 {
24686 PyDict_SetItemString(d,"LANGUAGE_SERBO_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_SERBO_CROATIAN)));
24687 }
24688 {
24689 PyDict_SetItemString(d,"LANGUAGE_SESOTHO", SWIG_From_int((int)(wxLANGUAGE_SESOTHO)));
24690 }
24691 {
24692 PyDict_SetItemString(d,"LANGUAGE_SETSWANA", SWIG_From_int((int)(wxLANGUAGE_SETSWANA)));
24693 }
24694 {
24695 PyDict_SetItemString(d,"LANGUAGE_SHONA", SWIG_From_int((int)(wxLANGUAGE_SHONA)));
24696 }
24697 {
24698 PyDict_SetItemString(d,"LANGUAGE_SINDHI", SWIG_From_int((int)(wxLANGUAGE_SINDHI)));
24699 }
24700 {
24701 PyDict_SetItemString(d,"LANGUAGE_SINHALESE", SWIG_From_int((int)(wxLANGUAGE_SINHALESE)));
24702 }
24703 {
24704 PyDict_SetItemString(d,"LANGUAGE_SISWATI", SWIG_From_int((int)(wxLANGUAGE_SISWATI)));
24705 }
24706 {
24707 PyDict_SetItemString(d,"LANGUAGE_SLOVAK", SWIG_From_int((int)(wxLANGUAGE_SLOVAK)));
24708 }
24709 {
24710 PyDict_SetItemString(d,"LANGUAGE_SLOVENIAN", SWIG_From_int((int)(wxLANGUAGE_SLOVENIAN)));
24711 }
24712 {
24713 PyDict_SetItemString(d,"LANGUAGE_SOMALI", SWIG_From_int((int)(wxLANGUAGE_SOMALI)));
24714 }
24715 {
24716 PyDict_SetItemString(d,"LANGUAGE_SPANISH", SWIG_From_int((int)(wxLANGUAGE_SPANISH)));
24717 }
24718 {
24719 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ARGENTINA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ARGENTINA)));
24720 }
24721 {
24722 PyDict_SetItemString(d,"LANGUAGE_SPANISH_BOLIVIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_BOLIVIA)));
24723 }
24724 {
24725 PyDict_SetItemString(d,"LANGUAGE_SPANISH_CHILE", SWIG_From_int((int)(wxLANGUAGE_SPANISH_CHILE)));
24726 }
24727 {
24728 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COLOMBIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COLOMBIA)));
24729 }
24730 {
24731 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COSTA_RICA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COSTA_RICA)));
24732 }
24733 {
24734 PyDict_SetItemString(d,"LANGUAGE_SPANISH_DOMINICAN_REPUBLIC", SWIG_From_int((int)(wxLANGUAGE_SPANISH_DOMINICAN_REPUBLIC)));
24735 }
24736 {
24737 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ECUADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ECUADOR)));
24738 }
24739 {
24740 PyDict_SetItemString(d,"LANGUAGE_SPANISH_EL_SALVADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_EL_SALVADOR)));
24741 }
24742 {
24743 PyDict_SetItemString(d,"LANGUAGE_SPANISH_GUATEMALA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_GUATEMALA)));
24744 }
24745 {
24746 PyDict_SetItemString(d,"LANGUAGE_SPANISH_HONDURAS", SWIG_From_int((int)(wxLANGUAGE_SPANISH_HONDURAS)));
24747 }
24748 {
24749 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MEXICAN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MEXICAN)));
24750 }
24751 {
24752 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MODERN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MODERN)));
24753 }
24754 {
24755 PyDict_SetItemString(d,"LANGUAGE_SPANISH_NICARAGUA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_NICARAGUA)));
24756 }
24757 {
24758 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PANAMA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PANAMA)));
24759 }
24760 {
24761 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PARAGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PARAGUAY)));
24762 }
24763 {
24764 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PERU", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PERU)));
24765 }
24766 {
24767 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PUERTO_RICO", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PUERTO_RICO)));
24768 }
24769 {
24770 PyDict_SetItemString(d,"LANGUAGE_SPANISH_URUGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_URUGUAY)));
24771 }
24772 {
24773 PyDict_SetItemString(d,"LANGUAGE_SPANISH_US", SWIG_From_int((int)(wxLANGUAGE_SPANISH_US)));
24774 }
24775 {
24776 PyDict_SetItemString(d,"LANGUAGE_SPANISH_VENEZUELA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_VENEZUELA)));
24777 }
24778 {
24779 PyDict_SetItemString(d,"LANGUAGE_SUNDANESE", SWIG_From_int((int)(wxLANGUAGE_SUNDANESE)));
24780 }
24781 {
24782 PyDict_SetItemString(d,"LANGUAGE_SWAHILI", SWIG_From_int((int)(wxLANGUAGE_SWAHILI)));
24783 }
24784 {
24785 PyDict_SetItemString(d,"LANGUAGE_SWEDISH", SWIG_From_int((int)(wxLANGUAGE_SWEDISH)));
24786 }
24787 {
24788 PyDict_SetItemString(d,"LANGUAGE_SWEDISH_FINLAND", SWIG_From_int((int)(wxLANGUAGE_SWEDISH_FINLAND)));
24789 }
24790 {
24791 PyDict_SetItemString(d,"LANGUAGE_TAGALOG", SWIG_From_int((int)(wxLANGUAGE_TAGALOG)));
24792 }
24793 {
24794 PyDict_SetItemString(d,"LANGUAGE_TAJIK", SWIG_From_int((int)(wxLANGUAGE_TAJIK)));
24795 }
24796 {
24797 PyDict_SetItemString(d,"LANGUAGE_TAMIL", SWIG_From_int((int)(wxLANGUAGE_TAMIL)));
24798 }
24799 {
24800 PyDict_SetItemString(d,"LANGUAGE_TATAR", SWIG_From_int((int)(wxLANGUAGE_TATAR)));
24801 }
24802 {
24803 PyDict_SetItemString(d,"LANGUAGE_TELUGU", SWIG_From_int((int)(wxLANGUAGE_TELUGU)));
24804 }
24805 {
24806 PyDict_SetItemString(d,"LANGUAGE_THAI", SWIG_From_int((int)(wxLANGUAGE_THAI)));
24807 }
24808 {
24809 PyDict_SetItemString(d,"LANGUAGE_TIBETAN", SWIG_From_int((int)(wxLANGUAGE_TIBETAN)));
24810 }
24811 {
24812 PyDict_SetItemString(d,"LANGUAGE_TIGRINYA", SWIG_From_int((int)(wxLANGUAGE_TIGRINYA)));
24813 }
24814 {
24815 PyDict_SetItemString(d,"LANGUAGE_TONGA", SWIG_From_int((int)(wxLANGUAGE_TONGA)));
24816 }
24817 {
24818 PyDict_SetItemString(d,"LANGUAGE_TSONGA", SWIG_From_int((int)(wxLANGUAGE_TSONGA)));
24819 }
24820 {
24821 PyDict_SetItemString(d,"LANGUAGE_TURKISH", SWIG_From_int((int)(wxLANGUAGE_TURKISH)));
24822 }
24823 {
24824 PyDict_SetItemString(d,"LANGUAGE_TURKMEN", SWIG_From_int((int)(wxLANGUAGE_TURKMEN)));
24825 }
24826 {
24827 PyDict_SetItemString(d,"LANGUAGE_TWI", SWIG_From_int((int)(wxLANGUAGE_TWI)));
24828 }
24829 {
24830 PyDict_SetItemString(d,"LANGUAGE_UIGHUR", SWIG_From_int((int)(wxLANGUAGE_UIGHUR)));
24831 }
24832 {
24833 PyDict_SetItemString(d,"LANGUAGE_UKRAINIAN", SWIG_From_int((int)(wxLANGUAGE_UKRAINIAN)));
24834 }
24835 {
24836 PyDict_SetItemString(d,"LANGUAGE_URDU", SWIG_From_int((int)(wxLANGUAGE_URDU)));
24837 }
24838 {
24839 PyDict_SetItemString(d,"LANGUAGE_URDU_INDIA", SWIG_From_int((int)(wxLANGUAGE_URDU_INDIA)));
24840 }
24841 {
24842 PyDict_SetItemString(d,"LANGUAGE_URDU_PAKISTAN", SWIG_From_int((int)(wxLANGUAGE_URDU_PAKISTAN)));
24843 }
24844 {
24845 PyDict_SetItemString(d,"LANGUAGE_UZBEK", SWIG_From_int((int)(wxLANGUAGE_UZBEK)));
24846 }
24847 {
24848 PyDict_SetItemString(d,"LANGUAGE_UZBEK_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_UZBEK_CYRILLIC)));
24849 }
24850 {
24851 PyDict_SetItemString(d,"LANGUAGE_UZBEK_LATIN", SWIG_From_int((int)(wxLANGUAGE_UZBEK_LATIN)));
24852 }
24853 {
24854 PyDict_SetItemString(d,"LANGUAGE_VIETNAMESE", SWIG_From_int((int)(wxLANGUAGE_VIETNAMESE)));
24855 }
24856 {
24857 PyDict_SetItemString(d,"LANGUAGE_VOLAPUK", SWIG_From_int((int)(wxLANGUAGE_VOLAPUK)));
24858 }
24859 {
24860 PyDict_SetItemString(d,"LANGUAGE_WELSH", SWIG_From_int((int)(wxLANGUAGE_WELSH)));
24861 }
24862 {
24863 PyDict_SetItemString(d,"LANGUAGE_WOLOF", SWIG_From_int((int)(wxLANGUAGE_WOLOF)));
24864 }
24865 {
24866 PyDict_SetItemString(d,"LANGUAGE_XHOSA", SWIG_From_int((int)(wxLANGUAGE_XHOSA)));
24867 }
24868 {
24869 PyDict_SetItemString(d,"LANGUAGE_YIDDISH", SWIG_From_int((int)(wxLANGUAGE_YIDDISH)));
24870 }
24871 {
24872 PyDict_SetItemString(d,"LANGUAGE_YORUBA", SWIG_From_int((int)(wxLANGUAGE_YORUBA)));
24873 }
24874 {
24875 PyDict_SetItemString(d,"LANGUAGE_ZHUANG", SWIG_From_int((int)(wxLANGUAGE_ZHUANG)));
24876 }
24877 {
24878 PyDict_SetItemString(d,"LANGUAGE_ZULU", SWIG_From_int((int)(wxLANGUAGE_ZULU)));
24879 }
24880 {
24881 PyDict_SetItemString(d,"LANGUAGE_USER_DEFINED", SWIG_From_int((int)(wxLANGUAGE_USER_DEFINED)));
24882 }
24883 {
24884 PyDict_SetItemString(d,"LOCALE_CAT_NUMBER", SWIG_From_int((int)(wxLOCALE_CAT_NUMBER)));
24885 }
24886 {
24887 PyDict_SetItemString(d,"LOCALE_CAT_DATE", SWIG_From_int((int)(wxLOCALE_CAT_DATE)));
24888 }
24889 {
24890 PyDict_SetItemString(d,"LOCALE_CAT_MONEY", SWIG_From_int((int)(wxLOCALE_CAT_MONEY)));
24891 }
24892 {
24893 PyDict_SetItemString(d,"LOCALE_CAT_MAX", SWIG_From_int((int)(wxLOCALE_CAT_MAX)));
24894 }
24895 {
24896 PyDict_SetItemString(d,"LOCALE_THOUSANDS_SEP", SWIG_From_int((int)(wxLOCALE_THOUSANDS_SEP)));
24897 }
24898 {
24899 PyDict_SetItemString(d,"LOCALE_DECIMAL_POINT", SWIG_From_int((int)(wxLOCALE_DECIMAL_POINT)));
24900 }
24901 {
24902 PyDict_SetItemString(d,"LOCALE_LOAD_DEFAULT", SWIG_From_int((int)(wxLOCALE_LOAD_DEFAULT)));
24903 }
24904 {
24905 PyDict_SetItemString(d,"LOCALE_CONV_ENCODING", SWIG_From_int((int)(wxLOCALE_CONV_ENCODING)));
24906 }
24907 {
24908 PyDict_SetItemString(d,"CONVERT_STRICT", SWIG_From_int((int)(wxCONVERT_STRICT)));
24909 }
24910 {
24911 PyDict_SetItemString(d,"CONVERT_SUBSTITUTE", SWIG_From_int((int)(wxCONVERT_SUBSTITUTE)));
24912 }
24913 {
24914 PyDict_SetItemString(d,"PLATFORM_CURRENT", SWIG_From_int((int)(wxPLATFORM_CURRENT)));
24915 }
24916 {
24917 PyDict_SetItemString(d,"PLATFORM_UNIX", SWIG_From_int((int)(wxPLATFORM_UNIX)));
24918 }
24919 {
24920 PyDict_SetItemString(d,"PLATFORM_WINDOWS", SWIG_From_int((int)(wxPLATFORM_WINDOWS)));
24921 }
24922 {
24923 PyDict_SetItemString(d,"PLATFORM_OS2", SWIG_From_int((int)(wxPLATFORM_OS2)));
24924 }
24925 {
24926 PyDict_SetItemString(d,"PLATFORM_MAC", SWIG_From_int((int)(wxPLATFORM_MAC)));
24927 }
24928 {
24929 PyDict_SetItemString(d,"BUFFER_VIRTUAL_AREA", SWIG_From_int((int)(wxBUFFER_VIRTUAL_AREA)));
24930 }
24931 {
24932 PyDict_SetItemString(d,"BUFFER_CLIENT_AREA", SWIG_From_int((int)(wxBUFFER_CLIENT_AREA)));
24933 }
24934 {
24935 PyDict_SetItemString(d,"IMAGELIST_DRAW_NORMAL", SWIG_From_int((int)(wxIMAGELIST_DRAW_NORMAL)));
24936 }
24937 {
24938 PyDict_SetItemString(d,"IMAGELIST_DRAW_TRANSPARENT", SWIG_From_int((int)(wxIMAGELIST_DRAW_TRANSPARENT)));
24939 }
24940 {
24941 PyDict_SetItemString(d,"IMAGELIST_DRAW_SELECTED", SWIG_From_int((int)(wxIMAGELIST_DRAW_SELECTED)));
24942 }
24943 {
24944 PyDict_SetItemString(d,"IMAGELIST_DRAW_FOCUSED", SWIG_From_int((int)(wxIMAGELIST_DRAW_FOCUSED)));
24945 }
24946 {
24947 PyDict_SetItemString(d,"IMAGE_LIST_NORMAL", SWIG_From_int((int)(wxIMAGE_LIST_NORMAL)));
24948 }
24949 {
24950 PyDict_SetItemString(d,"IMAGE_LIST_SMALL", SWIG_From_int((int)(wxIMAGE_LIST_SMALL)));
24951 }
24952 {
24953 PyDict_SetItemString(d,"IMAGE_LIST_STATE", SWIG_From_int((int)(wxIMAGE_LIST_STATE)));
24954 }
24955 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
24956 SWIG_addvarlink(SWIG_globals,(char*)"NORMAL_FONT",_wrap_NORMAL_FONT_get, _wrap_NORMAL_FONT_set);
24957 SWIG_addvarlink(SWIG_globals,(char*)"SMALL_FONT",_wrap_SMALL_FONT_get, _wrap_SMALL_FONT_set);
24958 SWIG_addvarlink(SWIG_globals,(char*)"ITALIC_FONT",_wrap_ITALIC_FONT_get, _wrap_ITALIC_FONT_set);
24959 SWIG_addvarlink(SWIG_globals,(char*)"SWISS_FONT",_wrap_SWISS_FONT_get, _wrap_SWISS_FONT_set);
24960 SWIG_addvarlink(SWIG_globals,(char*)"RED_PEN",_wrap_RED_PEN_get, _wrap_RED_PEN_set);
24961 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_PEN",_wrap_CYAN_PEN_get, _wrap_CYAN_PEN_set);
24962 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_PEN",_wrap_GREEN_PEN_get, _wrap_GREEN_PEN_set);
24963 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_PEN",_wrap_BLACK_PEN_get, _wrap_BLACK_PEN_set);
24964 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_PEN",_wrap_WHITE_PEN_get, _wrap_WHITE_PEN_set);
24965 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_PEN",_wrap_TRANSPARENT_PEN_get, _wrap_TRANSPARENT_PEN_set);
24966 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_DASHED_PEN",_wrap_BLACK_DASHED_PEN_get, _wrap_BLACK_DASHED_PEN_set);
24967 SWIG_addvarlink(SWIG_globals,(char*)"GREY_PEN",_wrap_GREY_PEN_get, _wrap_GREY_PEN_set);
24968 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_PEN",_wrap_MEDIUM_GREY_PEN_get, _wrap_MEDIUM_GREY_PEN_set);
24969 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_PEN",_wrap_LIGHT_GREY_PEN_get, _wrap_LIGHT_GREY_PEN_set);
24970 SWIG_addvarlink(SWIG_globals,(char*)"BLUE_BRUSH",_wrap_BLUE_BRUSH_get, _wrap_BLUE_BRUSH_set);
24971 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_BRUSH",_wrap_GREEN_BRUSH_get, _wrap_GREEN_BRUSH_set);
24972 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_BRUSH",_wrap_WHITE_BRUSH_get, _wrap_WHITE_BRUSH_set);
24973 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_BRUSH",_wrap_BLACK_BRUSH_get, _wrap_BLACK_BRUSH_set);
24974 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_BRUSH",_wrap_TRANSPARENT_BRUSH_get, _wrap_TRANSPARENT_BRUSH_set);
24975 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_BRUSH",_wrap_CYAN_BRUSH_get, _wrap_CYAN_BRUSH_set);
24976 SWIG_addvarlink(SWIG_globals,(char*)"RED_BRUSH",_wrap_RED_BRUSH_get, _wrap_RED_BRUSH_set);
24977 SWIG_addvarlink(SWIG_globals,(char*)"GREY_BRUSH",_wrap_GREY_BRUSH_get, _wrap_GREY_BRUSH_set);
24978 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_BRUSH",_wrap_MEDIUM_GREY_BRUSH_get, _wrap_MEDIUM_GREY_BRUSH_set);
24979 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_BRUSH",_wrap_LIGHT_GREY_BRUSH_get, _wrap_LIGHT_GREY_BRUSH_set);
24980 SWIG_addvarlink(SWIG_globals,(char*)"BLACK",_wrap_BLACK_get, _wrap_BLACK_set);
24981 SWIG_addvarlink(SWIG_globals,(char*)"WHITE",_wrap_WHITE_get, _wrap_WHITE_set);
24982 SWIG_addvarlink(SWIG_globals,(char*)"RED",_wrap_RED_get, _wrap_RED_set);
24983 SWIG_addvarlink(SWIG_globals,(char*)"BLUE",_wrap_BLUE_get, _wrap_BLUE_set);
24984 SWIG_addvarlink(SWIG_globals,(char*)"GREEN",_wrap_GREEN_get, _wrap_GREEN_set);
24985 SWIG_addvarlink(SWIG_globals,(char*)"CYAN",_wrap_CYAN_get, _wrap_CYAN_set);
24986 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY",_wrap_LIGHT_GREY_get, _wrap_LIGHT_GREY_set);
24987 SWIG_addvarlink(SWIG_globals,(char*)"STANDARD_CURSOR",_wrap_STANDARD_CURSOR_get, _wrap_STANDARD_CURSOR_set);
24988 SWIG_addvarlink(SWIG_globals,(char*)"HOURGLASS_CURSOR",_wrap_HOURGLASS_CURSOR_get, _wrap_HOURGLASS_CURSOR_set);
24989 SWIG_addvarlink(SWIG_globals,(char*)"CROSS_CURSOR",_wrap_CROSS_CURSOR_get, _wrap_CROSS_CURSOR_set);
24990 SWIG_addvarlink(SWIG_globals,(char*)"NullBitmap",_wrap_NullBitmap_get, _wrap_NullBitmap_set);
24991 SWIG_addvarlink(SWIG_globals,(char*)"NullIcon",_wrap_NullIcon_get, _wrap_NullIcon_set);
24992 SWIG_addvarlink(SWIG_globals,(char*)"NullCursor",_wrap_NullCursor_get, _wrap_NullCursor_set);
24993 SWIG_addvarlink(SWIG_globals,(char*)"NullPen",_wrap_NullPen_get, _wrap_NullPen_set);
24994 SWIG_addvarlink(SWIG_globals,(char*)"NullBrush",_wrap_NullBrush_get, _wrap_NullBrush_set);
24995 SWIG_addvarlink(SWIG_globals,(char*)"NullPalette",_wrap_NullPalette_get, _wrap_NullPalette_set);
24996 SWIG_addvarlink(SWIG_globals,(char*)"NullFont",_wrap_NullFont_get, _wrap_NullFont_set);
24997 SWIG_addvarlink(SWIG_globals,(char*)"NullColour",_wrap_NullColour_get, _wrap_NullColour_set);
24998 SWIG_addvarlink(SWIG_globals,(char*)"TheFontList",_wrap_TheFontList_get, _wrap_TheFontList_set);
24999 SWIG_addvarlink(SWIG_globals,(char*)"ThePenList",_wrap_ThePenList_get, _wrap_ThePenList_set);
25000 SWIG_addvarlink(SWIG_globals,(char*)"TheBrushList",_wrap_TheBrushList_get, _wrap_TheBrushList_set);
25001 SWIG_addvarlink(SWIG_globals,(char*)"TheColourDatabase",_wrap_TheColourDatabase_get, _wrap_TheColourDatabase_set);
25002 {
25003 PyDict_SetItemString(d,"CONTROL_DISABLED", SWIG_From_int((int)(wxCONTROL_DISABLED)));
25004 }
25005 {
25006 PyDict_SetItemString(d,"CONTROL_FOCUSED", SWIG_From_int((int)(wxCONTROL_FOCUSED)));
25007 }
25008 {
25009 PyDict_SetItemString(d,"CONTROL_PRESSED", SWIG_From_int((int)(wxCONTROL_PRESSED)));
25010 }
25011 {
25012 PyDict_SetItemString(d,"CONTROL_ISDEFAULT", SWIG_From_int((int)(wxCONTROL_ISDEFAULT)));
25013 }
25014 {
25015 PyDict_SetItemString(d,"CONTROL_ISSUBMENU", SWIG_From_int((int)(wxCONTROL_ISSUBMENU)));
25016 }
25017 {
25018 PyDict_SetItemString(d,"CONTROL_EXPANDED", SWIG_From_int((int)(wxCONTROL_EXPANDED)));
25019 }
25020 {
25021 PyDict_SetItemString(d,"CONTROL_CURRENT", SWIG_From_int((int)(wxCONTROL_CURRENT)));
25022 }
25023 {
25024 PyDict_SetItemString(d,"CONTROL_SELECTED", SWIG_From_int((int)(wxCONTROL_SELECTED)));
25025 }
25026 {
25027 PyDict_SetItemString(d,"CONTROL_CHECKED", SWIG_From_int((int)(wxCONTROL_CHECKED)));
25028 }
25029 {
25030 PyDict_SetItemString(d,"CONTROL_CHECKABLE", SWIG_From_int((int)(wxCONTROL_CHECKABLE)));
25031 }
25032 {
25033 PyDict_SetItemString(d,"CONTROL_UNDETERMINED", SWIG_From_int((int)(wxCONTROL_UNDETERMINED)));
25034 }
25035 {
25036 PyDict_SetItemString(d,"CONTROL_FLAGS_MASK", SWIG_From_int((int)(wxCONTROL_FLAGS_MASK)));
25037 }
25038 {
25039 PyDict_SetItemString(d,"CONTROL_DIRTY", SWIG_From_int((int)(wxCONTROL_DIRTY)));
25040 }
25041 {
25042 PyDict_SetItemString(d,"RendererVersion_Current_Version", SWIG_From_int((int)(wxRendererVersion::Current_Version)));
25043 }
25044 {
25045 PyDict_SetItemString(d,"RendererVersion_Current_Age", SWIG_From_int((int)(wxRendererVersion::Current_Age)));
25046 }
25047
25048 // Work around a chicken/egg problem in drawlist.cpp
25049 wxPyDrawList_SetAPIPtr();
25050
25051 }
25052
wxWidgets (Impactor)