]> 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
wxCheckListBox doesn't require wxUSE_OWNER_DRAWN when using WXUNIVERSAL
[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_wxDuplexMode swig_types[6]
1349 #define SWIGTYPE_p_wxPyFontEnumerator swig_types[7]
1350 #define SWIGTYPE_p_char swig_types[8]
1351 #define SWIGTYPE_p_wxIconLocation swig_types[9]
1352 #define SWIGTYPE_p_wxImage swig_types[10]
1353 #define SWIGTYPE_p_wxMetaFileDC swig_types[11]
1354 #define SWIGTYPE_p_wxMask swig_types[12]
1355 #define SWIGTYPE_p_wxSize swig_types[13]
1356 #define SWIGTYPE_p_wxFont swig_types[14]
1357 #define SWIGTYPE_p_wxWindow swig_types[15]
1358 #define SWIGTYPE_p_double swig_types[16]
1359 #define SWIGTYPE_p_wxMemoryDC swig_types[17]
1360 #define SWIGTYPE_p_wxFontMapper swig_types[18]
1361 #define SWIGTYPE_p_wxEffects swig_types[19]
1362 #define SWIGTYPE_p_wxNativeEncodingInfo swig_types[20]
1363 #define SWIGTYPE_p_wxPalette swig_types[21]
1364 #define SWIGTYPE_p_wxBitmap swig_types[22]
1365 #define SWIGTYPE_p_wxObject swig_types[23]
1366 #define SWIGTYPE_p_wxRegionIterator swig_types[24]
1367 #define SWIGTYPE_p_wxRect swig_types[25]
1368 #define SWIGTYPE_p_wxPaperSize swig_types[26]
1369 #define SWIGTYPE_p_wxString swig_types[27]
1370 #define SWIGTYPE_unsigned_int swig_types[28]
1371 #define SWIGTYPE_p_unsigned_int swig_types[29]
1372 #define SWIGTYPE_p_wxPrinterDC swig_types[30]
1373 #define SWIGTYPE_p_wxIconBundle swig_types[31]
1374 #define SWIGTYPE_p_wxPoint swig_types[32]
1375 #define SWIGTYPE_p_wxDash swig_types[33]
1376 #define SWIGTYPE_p_wxScreenDC swig_types[34]
1377 #define SWIGTYPE_p_wxCursor swig_types[35]
1378 #define SWIGTYPE_p_wxClientDC swig_types[36]
1379 #define SWIGTYPE_p_wxBufferedDC swig_types[37]
1380 #define SWIGTYPE_p_wxImageList swig_types[38]
1381 #define SWIGTYPE_p_unsigned_char swig_types[39]
1382 #define SWIGTYPE_p_wxGDIObject swig_types[40]
1383 #define SWIGTYPE_p_wxIcon swig_types[41]
1384 #define SWIGTYPE_p_wxLocale swig_types[42]
1385 #define SWIGTYPE_ptrdiff_t swig_types[43]
1386 #define SWIGTYPE_std__ptrdiff_t swig_types[44]
1387 #define SWIGTYPE_p_wxRegion swig_types[45]
1388 #define SWIGTYPE_p_wxConfigBase swig_types[46]
1389 #define SWIGTYPE_p_wxLanguageInfo swig_types[47]
1390 #define SWIGTYPE_p_wxWindowDC swig_types[48]
1391 #define SWIGTYPE_p_wxPrintData swig_types[49]
1392 #define SWIGTYPE_p_wxBrushList swig_types[50]
1393 #define SWIGTYPE_p_wxFontList swig_types[51]
1394 #define SWIGTYPE_p_wxPen swig_types[52]
1395 #define SWIGTYPE_p_wxBufferedPaintDC swig_types[53]
1396 #define SWIGTYPE_p_wxPaintDC swig_types[54]
1397 #define SWIGTYPE_p_wxPenList swig_types[55]
1398 #define SWIGTYPE_p_int swig_types[56]
1399 #define SWIGTYPE_p_wxMetaFile swig_types[57]
1400 #define SWIGTYPE_p_unsigned_long swig_types[58]
1401 #define SWIGTYPE_p_wxNativeFontInfo swig_types[59]
1402 #define SWIGTYPE_p_wxEncodingConverter swig_types[60]
1403 #define SWIGTYPE_p_wxColourDatabase swig_types[61]
1404 static swig_type_info *swig_types[63];
1405
1406 /* -------- TYPES TABLE (END) -------- */
1407
1408
1409 /*-----------------------------------------------
1410 @(target):= _gdi_.so
1411 ------------------------------------------------*/
1412 #define SWIG_init init_gdi_
1413
1414 #define SWIG_name "_gdi_"
1415
1416 #include "wx/wxPython/wxPython.h"
1417 #include "wx/wxPython/pyclasses.h"
1418
1419
1420 static const wxString wxPyEmptyString(wxEmptyString);
1421
1422 #include <limits.h>
1423
1424
1425 SWIGINTERN int
1426 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1427 const char *errmsg)
1428 {
1429 if (value < min_value) {
1430 if (errmsg) {
1431 PyErr_Format(PyExc_OverflowError,
1432 "value %ld is less than '%s' minimum %ld",
1433 value, errmsg, min_value);
1434 }
1435 return 0;
1436 } else if (value > max_value) {
1437 if (errmsg) {
1438 PyErr_Format(PyExc_OverflowError,
1439 "value %ld is greater than '%s' maximum %ld",
1440 value, errmsg, max_value);
1441 }
1442 return 0;
1443 }
1444 return 1;
1445 }
1446
1447
1448 SWIGINTERN int
1449 SWIG_AsVal_long(PyObject* obj, long* val)
1450 {
1451 if (PyNumber_Check(obj)) {
1452 if (val) *val = PyInt_AsLong(obj);
1453 return 1;
1454 }
1455 else {
1456 SWIG_type_error("number", obj);
1457 }
1458 return 0;
1459 }
1460
1461
1462 #if INT_MAX != LONG_MAX
1463 SWIGINTERN int
1464 SWIG_AsVal_int(PyObject *obj, int *val)
1465 {
1466 const char* errmsg = val ? "int" : (char*)0;
1467 long v;
1468 if (SWIG_AsVal_long(obj, &v)) {
1469 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1470 if (val) *val = (int)(v);
1471 return 1;
1472 } else {
1473 return 0;
1474 }
1475 } else {
1476 PyErr_Clear();
1477 }
1478 if (val) {
1479 SWIG_type_error(errmsg, obj);
1480 }
1481 return 0;
1482 }
1483 #else
1484 SWIGINTERNSHORT int
1485 SWIG_AsVal_int(PyObject *obj, int *val)
1486 {
1487 return SWIG_AsVal_long(obj,(long*)val);
1488 }
1489 #endif
1490
1491
1492 SWIGINTERN int
1493 SWIG_AsVal_bool(PyObject *obj, bool *val)
1494 {
1495 if (obj == Py_True) {
1496 if (val) *val = true;
1497 return 1;
1498 }
1499 if (obj == Py_False) {
1500 if (val) *val = false;
1501 return 1;
1502 }
1503 int res = 0;
1504 if (SWIG_AsVal_int(obj, &res)) {
1505 if (val) *val = res ? true : false;
1506 return 1;
1507 } else {
1508 PyErr_Clear();
1509 }
1510 if (val) {
1511 SWIG_type_error("bool", obj);
1512 }
1513 return 0;
1514 }
1515
1516
1517 SWIGINTERNSHORT bool
1518 SWIG_As_bool(PyObject* obj)
1519 {
1520 bool v;
1521 if (!SWIG_AsVal_bool(obj, &v)) {
1522 /*
1523 this is needed to make valgrind/purify happier.
1524 */
1525 memset((void*)&v, 0, sizeof(bool));
1526 }
1527 return v;
1528 }
1529
1530
1531 SWIGINTERNSHORT int
1532 SWIG_Check_bool(PyObject* obj)
1533 {
1534 return SWIG_AsVal_bool(obj, (bool*)0);
1535 }
1536
1537
1538 SWIGINTERN int
1539 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1540 {
1541 long v = 0;
1542 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1543 SWIG_type_error("unsigned number", obj);
1544 }
1545 else if (val)
1546 *val = (unsigned long)v;
1547 return 1;
1548 }
1549
1550
1551 SWIGINTERNSHORT int
1552 SWIG_CheckUnsignedLongInRange(unsigned long value,
1553 unsigned long max_value,
1554 const char *errmsg)
1555 {
1556 if (value > max_value) {
1557 if (errmsg) {
1558 PyErr_Format(PyExc_OverflowError,
1559 "value %lu is greater than '%s' minimum %lu",
1560 value, errmsg, max_value);
1561 }
1562 return 0;
1563 }
1564 return 1;
1565 }
1566
1567
1568 SWIGINTERN int
1569 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
1570 {
1571 const char* errmsg = val ? "unsigned char" : (char*)0;
1572 unsigned long v;
1573 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1574 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
1575 if (val) *val = (unsigned char)(v);
1576 return 1;
1577 } else {
1578 return 0;
1579 }
1580 } else {
1581 PyErr_Clear();
1582 }
1583 if (val) {
1584 SWIG_type_error(errmsg, obj);
1585 }
1586 return 0;
1587 }
1588
1589
1590 SWIGINTERNSHORT unsigned char
1591 SWIG_As_unsigned_SS_char(PyObject* obj)
1592 {
1593 unsigned char v;
1594 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
1595 /*
1596 this is needed to make valgrind/purify happier.
1597 */
1598 memset((void*)&v, 0, sizeof(unsigned char));
1599 }
1600 return v;
1601 }
1602
1603
1604 SWIGINTERNSHORT int
1605 SWIG_Check_unsigned_SS_char(PyObject* obj)
1606 {
1607 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
1608 }
1609
1610
1611 SWIGINTERNSHORT unsigned long
1612 SWIG_As_unsigned_SS_long(PyObject* obj)
1613 {
1614 unsigned long v;
1615 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1616 /*
1617 this is needed to make valgrind/purify happier.
1618 */
1619 memset((void*)&v, 0, sizeof(unsigned long));
1620 }
1621 return v;
1622 }
1623
1624
1625 SWIGINTERNSHORT int
1626 SWIG_Check_unsigned_SS_long(PyObject* obj)
1627 {
1628 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1629 }
1630
1631
1632 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1633 #define SWIG_From_unsigned_SS_char PyInt_FromLong
1634 /*@@*/
1635
1636
1637 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1638 #define SWIG_From_long PyInt_FromLong
1639 /*@@*/
1640
1641 static PyObject *wxColour_Get(wxColour *self){
1642 PyObject* rv = PyTuple_New(3);
1643 int red = -1;
1644 int green = -1;
1645 int blue = -1;
1646 if (self->Ok()) {
1647 red = self->Red();
1648 green = self->Green();
1649 blue = self->Blue();
1650 }
1651 PyTuple_SetItem(rv, 0, PyInt_FromLong(red));
1652 PyTuple_SetItem(rv, 1, PyInt_FromLong(green));
1653 PyTuple_SetItem(rv, 2, PyInt_FromLong(blue));
1654 return rv;
1655 }
1656 static unsigned long wxColour_GetRGB(wxColour *self){
1657 return self->Red() | (self->Green() << 8) | (self->Blue() << 16);
1658 }
1659
1660 SWIGINTERNSHORT PyObject*
1661 SWIG_From_unsigned_SS_long(unsigned long value)
1662 {
1663 return (value > LONG_MAX) ?
1664 PyLong_FromUnsignedLong(value)
1665 : PyInt_FromLong((long)(value));
1666 }
1667
1668
1669 SWIGINTERNSHORT int
1670 SWIG_As_int(PyObject* obj)
1671 {
1672 int v;
1673 if (!SWIG_AsVal_int(obj, &v)) {
1674 /*
1675 this is needed to make valgrind/purify happier.
1676 */
1677 memset((void*)&v, 0, sizeof(int));
1678 }
1679 return v;
1680 }
1681
1682
1683 SWIGINTERNSHORT int
1684 SWIG_Check_int(PyObject* obj)
1685 {
1686 return SWIG_AsVal_int(obj, (int*)0);
1687 }
1688
1689
1690 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1691 #define SWIG_From_int PyInt_FromLong
1692 /*@@*/
1693
1694
1695 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1696 PyObject* o2;
1697 PyObject* o3;
1698
1699 if (!target) {
1700 target = o;
1701 } else if (target == Py_None) {
1702 Py_DECREF(Py_None);
1703 target = o;
1704 } else {
1705 if (!PyTuple_Check(target)) {
1706 o2 = target;
1707 target = PyTuple_New(1);
1708 PyTuple_SetItem(target, 0, o2);
1709 }
1710 o3 = PyTuple_New(1);
1711 PyTuple_SetItem(o3, 0, o);
1712
1713 o2 = target;
1714 target = PySequence_Concat(o2, o3);
1715 Py_DECREF(o2);
1716 Py_DECREF(o3);
1717 }
1718 return target;
1719 }
1720
1721
1722 static PyObject *wxPen_GetDashes(wxPen *self){
1723 wxDash* dashes;
1724 int count = self->GetDashes(&dashes);
1725 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1726 PyObject* retval = PyList_New(0);
1727 for (int x=0; x<count; x++) {
1728 PyObject* pyint = PyInt_FromLong(dashes[x]);
1729 PyList_Append(retval, pyint);
1730 Py_DECREF(pyint);
1731 }
1732 wxPyEndBlockThreads(blocked);
1733 return retval;
1734 }
1735 static void wxPen__SetDashes(wxPen *self,PyObject *_self,PyObject *pyDashes){
1736 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1737 int size = PyList_Size(pyDashes);
1738 wxDash* dashes = (wxDash*)byte_LIST_helper(pyDashes);
1739
1740 // black magic warning! The array of wxDashes needs to exist as
1741 // long as the pen does because wxPen does not copy the array. So
1742 // stick a copy in a Python string object and attach it to _self,
1743 // and then call SetDashes with a pointer to that array. Then
1744 // when the Python pen object is destroyed the array will be
1745 // cleaned up too.
1746 PyObject* strDashes = PyString_FromStringAndSize((char*)dashes, size*sizeof(wxDash));
1747 PyObject_SetAttrString(_self, "_dashes", strDashes);
1748
1749 self->SetDashes(size, (wxDash*)PyString_AS_STRING(strDashes));
1750 delete [] dashes;
1751 Py_DECREF(strDashes);
1752 wxPyEndBlockThreads(blocked);
1753 }
1754 static bool wxPen___eq__(wxPen *self,wxPen const *other){ return other ? (*self == *other) : false; }
1755 static bool wxPen___ne__(wxPen *self,wxPen const *other){ return other ? (*self != *other) : true; }
1756
1757 #include <wx/image.h>
1758
1759 static char** ConvertListOfStrings(PyObject* listOfStrings) {
1760 char** cArray = NULL;
1761 int count;
1762
1763 if (!PyList_Check(listOfStrings)) {
1764 PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
1765 return NULL;
1766 }
1767 count = PyList_Size(listOfStrings);
1768 cArray = new char*[count];
1769
1770 for(int x=0; x<count; x++) {
1771 // TODO: Need some validation and error checking here
1772 cArray[x] = PyString_AsString(PyList_GET_ITEM(listOfStrings, x));
1773 }
1774 return cArray;
1775 }
1776
1777
1778 static wxBitmap *new_wxBitmap(PyObject *listOfStrings){
1779 char** cArray = NULL;
1780 wxBitmap* bmp;
1781
1782 cArray = ConvertListOfStrings(listOfStrings);
1783 if (! cArray)
1784 return NULL;
1785 bmp = new wxBitmap(cArray);
1786 delete [] cArray;
1787 return bmp;
1788 }
1789 static wxBitmap *new_wxBitmap(PyObject *bits,int width,int height,int depth=1){
1790 char* buf;
1791 int length;
1792 PyString_AsStringAndSize(bits, &buf, &length);
1793 return new wxBitmap(buf, width, height, depth);
1794 }
1795
1796 SWIGINTERNSHORT long
1797 SWIG_As_long(PyObject* obj)
1798 {
1799 long v;
1800 if (!SWIG_AsVal_long(obj, &v)) {
1801 /*
1802 this is needed to make valgrind/purify happier.
1803 */
1804 memset((void*)&v, 0, sizeof(long));
1805 }
1806 return v;
1807 }
1808
1809
1810 SWIGINTERNSHORT int
1811 SWIG_Check_long(PyObject* obj)
1812 {
1813 return SWIG_AsVal_long(obj, (long*)0);
1814 }
1815
1816 static void wxBitmap_SetHandle(wxBitmap *self,long handle){ self->SetHandle((WXHANDLE)handle); }
1817 static wxSize wxBitmap_GetSize(wxBitmap *self){
1818 wxSize size(self->GetWidth(), self->GetHeight());
1819 return size;
1820 }
1821 static void wxBitmap_SetMaskColour(wxBitmap *self,wxColour const &colour){
1822 wxMask *mask = new wxMask(*self, colour);
1823 self->SetMask(mask);
1824 }
1825 static void wxBitmap_SetSize(wxBitmap *self,wxSize const &size){
1826 self->SetWidth(size.x);
1827 self->SetHeight(size.y);
1828 }
1829 static bool wxBitmap___eq__(wxBitmap *self,wxBitmap const *other){ return other ? (*self == *other) : false; }
1830 static bool wxBitmap___ne__(wxBitmap *self,wxBitmap const *other){ return other ? (*self != *other) : true; }
1831 static wxMask *new_wxMask(wxBitmap const &bitmap,wxColour const &colour=wxNullColour){
1832 if ( !colour.Ok() )
1833 return new wxMask(bitmap, *wxBLACK);
1834 else
1835 return new wxMask(bitmap, colour);
1836 }
1837
1838 #include <wx/iconbndl.h>
1839
1840 static wxIcon *new_wxIcon(wxBitmap const &bmp){
1841 wxIcon* icon = new wxIcon();
1842 icon->CopyFromBitmap(bmp);
1843 return icon;
1844 }
1845 static wxIcon *new_wxIcon(PyObject *listOfStrings){
1846 char** cArray = NULL;
1847 wxIcon* icon;
1848
1849 cArray = ConvertListOfStrings(listOfStrings);
1850 if (! cArray)
1851 return NULL;
1852 icon = new wxIcon(cArray);
1853 delete [] cArray;
1854 return icon;
1855 }
1856 static void wxIcon_SetHandle(wxIcon *self,long handle){ self->SetHandle((WXHANDLE)handle); }
1857 static wxIconLocation *new_wxIconLocation(wxString const *filename=&wxPyEmptyString,int num=0){
1858
1859 return new wxIconLocation(*filename, num);
1860
1861
1862
1863 }
1864 static void wxIconLocation_SetIndex(wxIconLocation *self,int num){
1865
1866 self->SetIndex(num);
1867
1868
1869
1870 }
1871 static int wxIconLocation_GetIndex(wxIconLocation *self){
1872
1873 return self->GetIndex();
1874
1875
1876
1877 }
1878 static wxCursor *new_wxCursor(wxString const &cursorName,long type,int hotSpotX=0,int hotSpotY=0){
1879 #ifdef __WXGTK__
1880 wxImage img(cursorName, type);
1881 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X, hotSpotX);
1882 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y, hotSpotY);
1883 return new wxCursor(img);
1884 #else
1885 return new wxCursor(cursorName, type, hotSpotX, hotSpotY);
1886 #endif
1887 }
1888 static void wxCursor_SetHandle(wxCursor *self,long handle){ self->SetHandle((WXHANDLE)handle); }
1889
1890
1891 static void wxRegionIterator_Next(wxRegionIterator *self){
1892 (*self) ++;
1893 }
1894 static bool wxRegionIterator___nonzero__(wxRegionIterator *self){
1895 return self->operator bool();
1896 }
1897
1898 #include <wx/fontutil.h>
1899 #include <wx/fontmap.h>
1900 #include <wx/fontenum.h>
1901
1902 static wxString wxNativeFontInfo___str__(wxNativeFontInfo *self){
1903 return self->ToString();
1904 }
1905
1906 wxNativeEncodingInfo* wxGetNativeFontEncoding(wxFontEncoding encoding)
1907 { wxPyRaiseNotImplemented(); return NULL; }
1908
1909 bool wxTestFontEncoding(const wxNativeEncodingInfo& info)
1910 { wxPyRaiseNotImplemented(); return false; }
1911
1912 static PyObject *wxFontMapper_GetAltForEncoding(wxFontMapper *self,wxFontEncoding encoding,wxString const &facename=wxPyEmptyString,bool interactive=true){
1913 wxFontEncoding alt_enc;
1914 if (self->GetAltForEncoding(encoding, &alt_enc, facename, interactive))
1915 return PyInt_FromLong(alt_enc);
1916 else {
1917 Py_INCREF(Py_None);
1918 return Py_None;
1919 }
1920 }
1921 static wxFont *new_wxFont(wxString const &info){
1922 wxNativeFontInfo nfi;
1923 nfi.FromString(info);
1924 return new wxFont(nfi);
1925 }
1926 static wxFont *new_wxFont(int pointSize,wxFontFamily family,int flags=wxFONTFLAG_DEFAULT,wxString const &face=wxPyEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1927 return wxFont::New(pointSize, family, flags, face, encoding);
1928 }
1929 static wxFont *new_wxFont(wxSize const &pixelSize,int family,int style,int weight,bool underlined=false,wxString const &face=wxEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1930 return wxFontBase::New(pixelSize, family,
1931 style, weight, underlined,
1932 face, encoding);
1933 }
1934 static wxFont *new_wxFont(wxSize const &pixelSize,wxFontFamily family,int flags=wxFONTFLAG_DEFAULT,wxString const &face=wxEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1935 return wxFontBase::New(pixelSize, family, flags, face, encoding);
1936 }
1937 static bool wxFont___eq__(wxFont *self,wxFont const *other){ return other ? (*self == *other) : false; }
1938 static bool wxFont___ne__(wxFont *self,wxFont const *other){ return other ? (*self != *other) : true; }
1939
1940 class wxPyFontEnumerator : public wxFontEnumerator {
1941 public:
1942 wxPyFontEnumerator() {}
1943 ~wxPyFontEnumerator() {}
1944
1945 DEC_PYCALLBACK_BOOL_STRING(OnFacename);
1946 DEC_PYCALLBACK_BOOL_STRINGSTRING(OnFontEncoding);
1947
1948 PYPRIVATE;
1949 };
1950
1951 IMP_PYCALLBACK_BOOL_STRING(wxPyFontEnumerator, wxFontEnumerator, OnFacename);
1952 IMP_PYCALLBACK_BOOL_STRINGSTRING(wxPyFontEnumerator, wxFontEnumerator, OnFontEncoding);
1953
1954
1955 static PyObject *wxPyFontEnumerator_GetEncodings(wxPyFontEnumerator *self){
1956 wxArrayString* arr = self->GetEncodings();
1957 if (arr)
1958 return wxArrayString2PyList_helper(*arr);
1959 else
1960 return PyList_New(0);
1961 }
1962 static PyObject *wxPyFontEnumerator_GetFacenames(wxPyFontEnumerator *self){
1963 wxArrayString* arr = self->GetFacenames();
1964 if (arr)
1965 return wxArrayString2PyList_helper(*arr);
1966 else
1967 return PyList_New(0);
1968 }
1969
1970 #include <locale.h>
1971
1972 static wxLocale *new_wxLocale(int language=-1,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
1973 wxLocale* loc;
1974 if (language == -1)
1975 loc = new wxLocale();
1976 else
1977 loc = new wxLocale(language, flags);
1978 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1979 // for the floating point conversions and such to work right.
1980 #if PY_VERSION_HEX < 0x02040000
1981 setlocale(LC_NUMERIC, "C");
1982 #endif
1983 return loc;
1984 }
1985 static bool wxLocale_Init1(wxLocale *self,wxString const &szName,wxString const &szShort=wxPyEmptyString,wxString const &szLocale=wxPyEmptyString,bool bLoadDefault=true,bool bConvertEncoding=false){
1986 bool rc = self->Init(szName, szShort, szLocale, bLoadDefault, bConvertEncoding);
1987 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1988 // for the floating point conversions and such to work right.
1989 #if PY_VERSION_HEX < 0x02040000
1990 setlocale(LC_NUMERIC, "C");
1991 #endif
1992 return rc;
1993 }
1994 static bool wxLocale_Init2(wxLocale *self,int language=wxLANGUAGE_DEFAULT,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
1995 bool rc = self->Init(language, flags);
1996 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1997 // for the floating point conversions and such to work right.
1998 #if PY_VERSION_HEX < 0x02040000
1999 setlocale(LC_NUMERIC, "C");
2000 #endif
2001 return rc;
2002 }
2003
2004 #include "wx/wxPython/pydrawxxx.h"
2005
2006 static wxColour wxDC_GetPixel(wxDC *self,int x,int y){
2007 wxColour col;
2008 self->GetPixel(x, y, &col);
2009 return col;
2010 }
2011 static wxColour wxDC_GetPixelPoint(wxDC *self,wxPoint const &pt){
2012 wxColour col;
2013 self->GetPixel(pt, &col);
2014 return col;
2015 }
2016
2017 SWIGINTERN int
2018 SWIG_AsVal_double(PyObject *obj, double* val)
2019 {
2020 if (PyNumber_Check(obj)) {
2021 if (val) *val = PyFloat_AsDouble(obj);
2022 return 1;
2023 }
2024 else {
2025 SWIG_type_error("number", obj);
2026 }
2027 return 0;
2028 }
2029
2030
2031 SWIGINTERNSHORT double
2032 SWIG_As_double(PyObject* obj)
2033 {
2034 double v;
2035 if (!SWIG_AsVal_double(obj, &v)) {
2036 /*
2037 this is needed to make valgrind/purify happier.
2038 */
2039 memset((void*)&v, 0, sizeof(double));
2040 }
2041 return v;
2042 }
2043
2044
2045 SWIGINTERNSHORT int
2046 SWIG_Check_double(PyObject* obj)
2047 {
2048 return SWIG_AsVal_double(obj, (double*)0);
2049 }
2050
2051 static wxRect wxDC_DrawImageLabel(wxDC *self,wxString const &text,wxBitmap const &image,wxRect const &rect,int alignment=wxALIGN_LEFT|wxALIGN_TOP,int indexAccel=-1){
2052 wxRect rv;
2053 self->DrawLabel(text, image, rect, alignment, indexAccel, &rv);
2054 return rv;
2055 }
2056
2057 static wxRect wxDC_GetClippingRect(wxDC *self){
2058 wxRect rect;
2059 self->GetClippingBox(rect);
2060 return rect;
2061 }
2062 static wxArrayInt wxDC_GetPartialTextExtents(wxDC *self,wxString const &text){
2063 wxArrayInt widths;
2064 self->GetPartialTextExtents(text, widths);
2065 return widths;
2066 }
2067
2068 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2069 #define SWIG_From_double PyFloat_FromDouble
2070 /*@@*/
2071
2072
2073 static void wxDC_SetLogicalOriginPoint(wxDC *self,wxPoint const &point){
2074 self->SetLogicalOrigin(point.x, point.y);
2075 }
2076 static void wxDC_SetDeviceOriginPoint(wxDC *self,wxPoint const &point){
2077 self->SetDeviceOrigin(point.x, point.y);
2078 }
2079 static void wxDC_CalcBoundingBoxPoint(wxDC *self,wxPoint const &point){
2080 self->CalcBoundingBox(point.x, point.y);
2081 }
2082 static PyObject *wxDC__DrawPointList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2083 return wxPyDrawXXXList(*self, wxPyDrawXXXPoint, pyCoords, pyPens, pyBrushes);
2084 }
2085 static PyObject *wxDC__DrawLineList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2086 return wxPyDrawXXXList(*self, wxPyDrawXXXLine, pyCoords, pyPens, pyBrushes);
2087 }
2088 static PyObject *wxDC__DrawRectangleList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2089 return wxPyDrawXXXList(*self, wxPyDrawXXXRectangle, pyCoords, pyPens, pyBrushes);
2090 }
2091 static PyObject *wxDC__DrawEllipseList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2092 return wxPyDrawXXXList(*self, wxPyDrawXXXEllipse, pyCoords, pyPens, pyBrushes);
2093 }
2094 static PyObject *wxDC__DrawPolygonList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2095 return wxPyDrawXXXList(*self, wxPyDrawXXXPolygon, pyCoords, pyPens, pyBrushes);
2096 }
2097 static PyObject *wxDC__DrawTextList(wxDC *self,PyObject *textList,PyObject *pyPoints,PyObject *foregroundList,PyObject *backgroundList){
2098 return wxPyDrawTextList(*self, textList, pyPoints, foregroundList, backgroundList);
2099 }
2100
2101 static void wxDC_GetBoundingBox(wxDC* dc, int* x1, int* y1, int* x2, int* y2) {
2102 *x1 = dc->MinX();
2103 *y1 = dc->MinY();
2104 *x2 = dc->MaxX();
2105 *y2 = dc->MaxY();
2106 }
2107
2108
2109 #include <wx/dcbuffer.h>
2110
2111
2112 #include <wx/dcps.h>
2113
2114
2115 #include <wx/metafile.h>
2116
2117
2118
2119 static void wxColourDatabase_Append(wxColourDatabase *self,wxString const &name,int red,int green,int blue){
2120 self->AddColour(name, wxColour(red, green, blue));
2121 }
2122
2123 #include <wx/effects.h>
2124
2125 #ifdef __cplusplus
2126 extern "C" {
2127 #endif
2128 static PyObject *_wrap_new_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2129 PyObject *resultobj;
2130 wxGDIObject *result;
2131 char *kwnames[] = {
2132 NULL
2133 };
2134
2135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GDIObject",kwnames)) goto fail;
2136 {
2137 if (!wxPyCheckForApp()) SWIG_fail;
2138 PyThreadState* __tstate = wxPyBeginAllowThreads();
2139 result = (wxGDIObject *)new wxGDIObject();
2140
2141 wxPyEndAllowThreads(__tstate);
2142 if (PyErr_Occurred()) SWIG_fail;
2143 }
2144 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGDIObject, 1);
2145 return resultobj;
2146 fail:
2147 return NULL;
2148 }
2149
2150
2151 static PyObject *_wrap_delete_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2152 PyObject *resultobj;
2153 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2154 PyObject * obj0 = 0 ;
2155 char *kwnames[] = {
2156 (char *) "self", NULL
2157 };
2158
2159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GDIObject",kwnames,&obj0)) goto fail;
2160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2161 if (SWIG_arg_fail(1)) SWIG_fail;
2162 {
2163 PyThreadState* __tstate = wxPyBeginAllowThreads();
2164 delete arg1;
2165
2166 wxPyEndAllowThreads(__tstate);
2167 if (PyErr_Occurred()) SWIG_fail;
2168 }
2169 Py_INCREF(Py_None); resultobj = Py_None;
2170 return resultobj;
2171 fail:
2172 return NULL;
2173 }
2174
2175
2176 static PyObject *_wrap_GDIObject_GetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2177 PyObject *resultobj;
2178 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2179 bool result;
2180 PyObject * obj0 = 0 ;
2181 char *kwnames[] = {
2182 (char *) "self", NULL
2183 };
2184
2185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_GetVisible",kwnames,&obj0)) goto fail;
2186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2187 if (SWIG_arg_fail(1)) SWIG_fail;
2188 {
2189 PyThreadState* __tstate = wxPyBeginAllowThreads();
2190 result = (bool)(arg1)->GetVisible();
2191
2192 wxPyEndAllowThreads(__tstate);
2193 if (PyErr_Occurred()) SWIG_fail;
2194 }
2195 {
2196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2197 }
2198 return resultobj;
2199 fail:
2200 return NULL;
2201 }
2202
2203
2204 static PyObject *_wrap_GDIObject_SetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2205 PyObject *resultobj;
2206 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2207 bool arg2 ;
2208 PyObject * obj0 = 0 ;
2209 PyObject * obj1 = 0 ;
2210 char *kwnames[] = {
2211 (char *) "self",(char *) "visible", NULL
2212 };
2213
2214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GDIObject_SetVisible",kwnames,&obj0,&obj1)) goto fail;
2215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2216 if (SWIG_arg_fail(1)) SWIG_fail;
2217 {
2218 arg2 = (bool)(SWIG_As_bool(obj1));
2219 if (SWIG_arg_fail(2)) SWIG_fail;
2220 }
2221 {
2222 PyThreadState* __tstate = wxPyBeginAllowThreads();
2223 (arg1)->SetVisible(arg2);
2224
2225 wxPyEndAllowThreads(__tstate);
2226 if (PyErr_Occurred()) SWIG_fail;
2227 }
2228 Py_INCREF(Py_None); resultobj = Py_None;
2229 return resultobj;
2230 fail:
2231 return NULL;
2232 }
2233
2234
2235 static PyObject *_wrap_GDIObject_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
2236 PyObject *resultobj;
2237 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2238 bool result;
2239 PyObject * obj0 = 0 ;
2240 char *kwnames[] = {
2241 (char *) "self", NULL
2242 };
2243
2244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_IsNull",kwnames,&obj0)) goto fail;
2245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2246 if (SWIG_arg_fail(1)) SWIG_fail;
2247 {
2248 PyThreadState* __tstate = wxPyBeginAllowThreads();
2249 result = (bool)(arg1)->IsNull();
2250
2251 wxPyEndAllowThreads(__tstate);
2252 if (PyErr_Occurred()) SWIG_fail;
2253 }
2254 {
2255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2256 }
2257 return resultobj;
2258 fail:
2259 return NULL;
2260 }
2261
2262
2263 static PyObject * GDIObject_swigregister(PyObject *, PyObject *args) {
2264 PyObject *obj;
2265 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2266 SWIG_TypeClientData(SWIGTYPE_p_wxGDIObject, obj);
2267 Py_INCREF(obj);
2268 return Py_BuildValue((char *)"");
2269 }
2270 static PyObject *_wrap_new_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2271 PyObject *resultobj;
2272 byte arg1 = (byte) 0 ;
2273 byte arg2 = (byte) 0 ;
2274 byte arg3 = (byte) 0 ;
2275 wxColour *result;
2276 PyObject * obj0 = 0 ;
2277 PyObject * obj1 = 0 ;
2278 PyObject * obj2 = 0 ;
2279 char *kwnames[] = {
2280 (char *) "red",(char *) "green",(char *) "blue", NULL
2281 };
2282
2283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Colour",kwnames,&obj0,&obj1,&obj2)) goto fail;
2284 if (obj0) {
2285 {
2286 arg1 = (byte)(SWIG_As_unsigned_SS_char(obj0));
2287 if (SWIG_arg_fail(1)) SWIG_fail;
2288 }
2289 }
2290 if (obj1) {
2291 {
2292 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2293 if (SWIG_arg_fail(2)) SWIG_fail;
2294 }
2295 }
2296 if (obj2) {
2297 {
2298 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2299 if (SWIG_arg_fail(3)) SWIG_fail;
2300 }
2301 }
2302 {
2303 PyThreadState* __tstate = wxPyBeginAllowThreads();
2304 result = (wxColour *)new wxColour(arg1,arg2,arg3);
2305
2306 wxPyEndAllowThreads(__tstate);
2307 if (PyErr_Occurred()) SWIG_fail;
2308 }
2309 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2310 return resultobj;
2311 fail:
2312 return NULL;
2313 }
2314
2315
2316 static PyObject *_wrap_new_NamedColour(PyObject *, PyObject *args, PyObject *kwargs) {
2317 PyObject *resultobj;
2318 wxString *arg1 = 0 ;
2319 wxColour *result;
2320 bool temp1 = false ;
2321 PyObject * obj0 = 0 ;
2322 char *kwnames[] = {
2323 (char *) "colorName", NULL
2324 };
2325
2326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_NamedColour",kwnames,&obj0)) goto fail;
2327 {
2328 arg1 = wxString_in_helper(obj0);
2329 if (arg1 == NULL) SWIG_fail;
2330 temp1 = true;
2331 }
2332 {
2333 if (!wxPyCheckForApp()) SWIG_fail;
2334 PyThreadState* __tstate = wxPyBeginAllowThreads();
2335 result = (wxColour *)new wxColour((wxString const &)*arg1);
2336
2337 wxPyEndAllowThreads(__tstate);
2338 if (PyErr_Occurred()) SWIG_fail;
2339 }
2340 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2341 {
2342 if (temp1)
2343 delete arg1;
2344 }
2345 return resultobj;
2346 fail:
2347 {
2348 if (temp1)
2349 delete arg1;
2350 }
2351 return NULL;
2352 }
2353
2354
2355 static PyObject *_wrap_new_ColourRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2356 PyObject *resultobj;
2357 unsigned long arg1 ;
2358 wxColour *result;
2359 PyObject * obj0 = 0 ;
2360 char *kwnames[] = {
2361 (char *) "colRGB", NULL
2362 };
2363
2364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ColourRGB",kwnames,&obj0)) goto fail;
2365 {
2366 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
2367 if (SWIG_arg_fail(1)) SWIG_fail;
2368 }
2369 {
2370 PyThreadState* __tstate = wxPyBeginAllowThreads();
2371 result = (wxColour *)new wxColour(arg1);
2372
2373 wxPyEndAllowThreads(__tstate);
2374 if (PyErr_Occurred()) SWIG_fail;
2375 }
2376 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2377 return resultobj;
2378 fail:
2379 return NULL;
2380 }
2381
2382
2383 static PyObject *_wrap_delete_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2384 PyObject *resultobj;
2385 wxColour *arg1 = (wxColour *) 0 ;
2386 PyObject * obj0 = 0 ;
2387 char *kwnames[] = {
2388 (char *) "self", NULL
2389 };
2390
2391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Colour",kwnames,&obj0)) goto fail;
2392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2393 if (SWIG_arg_fail(1)) SWIG_fail;
2394 {
2395 PyThreadState* __tstate = wxPyBeginAllowThreads();
2396 delete arg1;
2397
2398 wxPyEndAllowThreads(__tstate);
2399 if (PyErr_Occurred()) SWIG_fail;
2400 }
2401 Py_INCREF(Py_None); resultobj = Py_None;
2402 return resultobj;
2403 fail:
2404 return NULL;
2405 }
2406
2407
2408 static PyObject *_wrap_Colour_Red(PyObject *, PyObject *args, PyObject *kwargs) {
2409 PyObject *resultobj;
2410 wxColour *arg1 = (wxColour *) 0 ;
2411 byte result;
2412 PyObject * obj0 = 0 ;
2413 char *kwnames[] = {
2414 (char *) "self", NULL
2415 };
2416
2417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Red",kwnames,&obj0)) goto fail;
2418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2419 if (SWIG_arg_fail(1)) SWIG_fail;
2420 {
2421 PyThreadState* __tstate = wxPyBeginAllowThreads();
2422 result = (byte)(arg1)->Red();
2423
2424 wxPyEndAllowThreads(__tstate);
2425 if (PyErr_Occurred()) SWIG_fail;
2426 }
2427 {
2428 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2429 }
2430 return resultobj;
2431 fail:
2432 return NULL;
2433 }
2434
2435
2436 static PyObject *_wrap_Colour_Green(PyObject *, PyObject *args, PyObject *kwargs) {
2437 PyObject *resultobj;
2438 wxColour *arg1 = (wxColour *) 0 ;
2439 byte result;
2440 PyObject * obj0 = 0 ;
2441 char *kwnames[] = {
2442 (char *) "self", NULL
2443 };
2444
2445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Green",kwnames,&obj0)) goto fail;
2446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2447 if (SWIG_arg_fail(1)) SWIG_fail;
2448 {
2449 PyThreadState* __tstate = wxPyBeginAllowThreads();
2450 result = (byte)(arg1)->Green();
2451
2452 wxPyEndAllowThreads(__tstate);
2453 if (PyErr_Occurred()) SWIG_fail;
2454 }
2455 {
2456 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2457 }
2458 return resultobj;
2459 fail:
2460 return NULL;
2461 }
2462
2463
2464 static PyObject *_wrap_Colour_Blue(PyObject *, PyObject *args, PyObject *kwargs) {
2465 PyObject *resultobj;
2466 wxColour *arg1 = (wxColour *) 0 ;
2467 byte result;
2468 PyObject * obj0 = 0 ;
2469 char *kwnames[] = {
2470 (char *) "self", NULL
2471 };
2472
2473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Blue",kwnames,&obj0)) goto fail;
2474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2475 if (SWIG_arg_fail(1)) SWIG_fail;
2476 {
2477 PyThreadState* __tstate = wxPyBeginAllowThreads();
2478 result = (byte)(arg1)->Blue();
2479
2480 wxPyEndAllowThreads(__tstate);
2481 if (PyErr_Occurred()) SWIG_fail;
2482 }
2483 {
2484 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2485 }
2486 return resultobj;
2487 fail:
2488 return NULL;
2489 }
2490
2491
2492 static PyObject *_wrap_Colour_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
2493 PyObject *resultobj;
2494 wxColour *arg1 = (wxColour *) 0 ;
2495 bool result;
2496 PyObject * obj0 = 0 ;
2497 char *kwnames[] = {
2498 (char *) "self", NULL
2499 };
2500
2501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Ok",kwnames,&obj0)) goto fail;
2502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2503 if (SWIG_arg_fail(1)) SWIG_fail;
2504 {
2505 PyThreadState* __tstate = wxPyBeginAllowThreads();
2506 result = (bool)(arg1)->Ok();
2507
2508 wxPyEndAllowThreads(__tstate);
2509 if (PyErr_Occurred()) SWIG_fail;
2510 }
2511 {
2512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2513 }
2514 return resultobj;
2515 fail:
2516 return NULL;
2517 }
2518
2519
2520 static PyObject *_wrap_Colour_Set(PyObject *, PyObject *args, PyObject *kwargs) {
2521 PyObject *resultobj;
2522 wxColour *arg1 = (wxColour *) 0 ;
2523 byte arg2 ;
2524 byte arg3 ;
2525 byte arg4 ;
2526 PyObject * obj0 = 0 ;
2527 PyObject * obj1 = 0 ;
2528 PyObject * obj2 = 0 ;
2529 PyObject * obj3 = 0 ;
2530 char *kwnames[] = {
2531 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2532 };
2533
2534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Colour_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2536 if (SWIG_arg_fail(1)) SWIG_fail;
2537 {
2538 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2539 if (SWIG_arg_fail(2)) SWIG_fail;
2540 }
2541 {
2542 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2543 if (SWIG_arg_fail(3)) SWIG_fail;
2544 }
2545 {
2546 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2547 if (SWIG_arg_fail(4)) SWIG_fail;
2548 }
2549 {
2550 PyThreadState* __tstate = wxPyBeginAllowThreads();
2551 (arg1)->Set(arg2,arg3,arg4);
2552
2553 wxPyEndAllowThreads(__tstate);
2554 if (PyErr_Occurred()) SWIG_fail;
2555 }
2556 Py_INCREF(Py_None); resultobj = Py_None;
2557 return resultobj;
2558 fail:
2559 return NULL;
2560 }
2561
2562
2563 static PyObject *_wrap_Colour_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2564 PyObject *resultobj;
2565 wxColour *arg1 = (wxColour *) 0 ;
2566 unsigned long arg2 ;
2567 PyObject * obj0 = 0 ;
2568 PyObject * obj1 = 0 ;
2569 char *kwnames[] = {
2570 (char *) "self",(char *) "colRGB", NULL
2571 };
2572
2573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetRGB",kwnames,&obj0,&obj1)) goto fail;
2574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2575 if (SWIG_arg_fail(1)) SWIG_fail;
2576 {
2577 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
2578 if (SWIG_arg_fail(2)) SWIG_fail;
2579 }
2580 {
2581 PyThreadState* __tstate = wxPyBeginAllowThreads();
2582 (arg1)->Set(arg2);
2583
2584 wxPyEndAllowThreads(__tstate);
2585 if (PyErr_Occurred()) SWIG_fail;
2586 }
2587 Py_INCREF(Py_None); resultobj = Py_None;
2588 return resultobj;
2589 fail:
2590 return NULL;
2591 }
2592
2593
2594 static PyObject *_wrap_Colour_SetFromName(PyObject *, PyObject *args, PyObject *kwargs) {
2595 PyObject *resultobj;
2596 wxColour *arg1 = (wxColour *) 0 ;
2597 wxString *arg2 = 0 ;
2598 bool temp2 = false ;
2599 PyObject * obj0 = 0 ;
2600 PyObject * obj1 = 0 ;
2601 char *kwnames[] = {
2602 (char *) "self",(char *) "colourName", NULL
2603 };
2604
2605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetFromName",kwnames,&obj0,&obj1)) goto fail;
2606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2607 if (SWIG_arg_fail(1)) SWIG_fail;
2608 {
2609 arg2 = wxString_in_helper(obj1);
2610 if (arg2 == NULL) SWIG_fail;
2611 temp2 = true;
2612 }
2613 {
2614 PyThreadState* __tstate = wxPyBeginAllowThreads();
2615 (arg1)->InitFromName((wxString const &)*arg2);
2616
2617 wxPyEndAllowThreads(__tstate);
2618 if (PyErr_Occurred()) SWIG_fail;
2619 }
2620 Py_INCREF(Py_None); resultobj = Py_None;
2621 {
2622 if (temp2)
2623 delete arg2;
2624 }
2625 return resultobj;
2626 fail:
2627 {
2628 if (temp2)
2629 delete arg2;
2630 }
2631 return NULL;
2632 }
2633
2634
2635 static PyObject *_wrap_Colour_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2636 PyObject *resultobj;
2637 wxColour *arg1 = (wxColour *) 0 ;
2638 long result;
2639 PyObject * obj0 = 0 ;
2640 char *kwnames[] = {
2641 (char *) "self", NULL
2642 };
2643
2644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetPixel",kwnames,&obj0)) goto fail;
2645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2646 if (SWIG_arg_fail(1)) SWIG_fail;
2647 {
2648 PyThreadState* __tstate = wxPyBeginAllowThreads();
2649 result = (long)((wxColour const *)arg1)->GetPixel();
2650
2651 wxPyEndAllowThreads(__tstate);
2652 if (PyErr_Occurred()) SWIG_fail;
2653 }
2654 {
2655 resultobj = SWIG_From_long((long)(result));
2656 }
2657 return resultobj;
2658 fail:
2659 return NULL;
2660 }
2661
2662
2663 static PyObject *_wrap_Colour___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
2664 PyObject *resultobj;
2665 wxColour *arg1 = (wxColour *) 0 ;
2666 wxColour *arg2 = 0 ;
2667 bool result;
2668 wxColour temp2 ;
2669 PyObject * obj0 = 0 ;
2670 PyObject * obj1 = 0 ;
2671 char *kwnames[] = {
2672 (char *) "self",(char *) "colour", NULL
2673 };
2674
2675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___eq__",kwnames,&obj0,&obj1)) goto fail;
2676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2677 if (SWIG_arg_fail(1)) SWIG_fail;
2678 {
2679 arg2 = &temp2;
2680 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2681 }
2682 {
2683 PyThreadState* __tstate = wxPyBeginAllowThreads();
2684 result = (bool)((wxColour const *)arg1)->operator ==((wxColour const &)*arg2);
2685
2686 wxPyEndAllowThreads(__tstate);
2687 if (PyErr_Occurred()) SWIG_fail;
2688 }
2689 {
2690 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2691 }
2692 return resultobj;
2693 fail:
2694 return NULL;
2695 }
2696
2697
2698 static PyObject *_wrap_Colour___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
2699 PyObject *resultobj;
2700 wxColour *arg1 = (wxColour *) 0 ;
2701 wxColour *arg2 = 0 ;
2702 bool result;
2703 wxColour temp2 ;
2704 PyObject * obj0 = 0 ;
2705 PyObject * obj1 = 0 ;
2706 char *kwnames[] = {
2707 (char *) "self",(char *) "colour", NULL
2708 };
2709
2710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___ne__",kwnames,&obj0,&obj1)) goto fail;
2711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2712 if (SWIG_arg_fail(1)) SWIG_fail;
2713 {
2714 arg2 = &temp2;
2715 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2716 }
2717 {
2718 PyThreadState* __tstate = wxPyBeginAllowThreads();
2719 result = (bool)((wxColour const *)arg1)->operator !=((wxColour const &)*arg2);
2720
2721 wxPyEndAllowThreads(__tstate);
2722 if (PyErr_Occurred()) SWIG_fail;
2723 }
2724 {
2725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2726 }
2727 return resultobj;
2728 fail:
2729 return NULL;
2730 }
2731
2732
2733 static PyObject *_wrap_Colour_Get(PyObject *, PyObject *args, PyObject *kwargs) {
2734 PyObject *resultobj;
2735 wxColour *arg1 = (wxColour *) 0 ;
2736 PyObject *result;
2737 PyObject * obj0 = 0 ;
2738 char *kwnames[] = {
2739 (char *) "self", NULL
2740 };
2741
2742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Get",kwnames,&obj0)) goto fail;
2743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2744 if (SWIG_arg_fail(1)) SWIG_fail;
2745 {
2746 PyThreadState* __tstate = wxPyBeginAllowThreads();
2747 result = (PyObject *)wxColour_Get(arg1);
2748
2749 wxPyEndAllowThreads(__tstate);
2750 if (PyErr_Occurred()) SWIG_fail;
2751 }
2752 resultobj = result;
2753 return resultobj;
2754 fail:
2755 return NULL;
2756 }
2757
2758
2759 static PyObject *_wrap_Colour_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2760 PyObject *resultobj;
2761 wxColour *arg1 = (wxColour *) 0 ;
2762 unsigned long result;
2763 PyObject * obj0 = 0 ;
2764 char *kwnames[] = {
2765 (char *) "self", NULL
2766 };
2767
2768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetRGB",kwnames,&obj0)) goto fail;
2769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2770 if (SWIG_arg_fail(1)) SWIG_fail;
2771 {
2772 PyThreadState* __tstate = wxPyBeginAllowThreads();
2773 result = (unsigned long)wxColour_GetRGB(arg1);
2774
2775 wxPyEndAllowThreads(__tstate);
2776 if (PyErr_Occurred()) SWIG_fail;
2777 }
2778 {
2779 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
2780 }
2781 return resultobj;
2782 fail:
2783 return NULL;
2784 }
2785
2786
2787 static PyObject * Colour_swigregister(PyObject *, PyObject *args) {
2788 PyObject *obj;
2789 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2790 SWIG_TypeClientData(SWIGTYPE_p_wxColour, obj);
2791 Py_INCREF(obj);
2792 return Py_BuildValue((char *)"");
2793 }
2794 static PyObject *_wrap_new_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2795 PyObject *resultobj;
2796 int arg1 ;
2797 unsigned char *arg2 = (unsigned char *) 0 ;
2798 unsigned char *arg3 = (unsigned char *) 0 ;
2799 unsigned char *arg4 = (unsigned char *) 0 ;
2800 wxPalette *result;
2801 PyObject * obj0 = 0 ;
2802 PyObject * obj1 = 0 ;
2803 PyObject * obj2 = 0 ;
2804 PyObject * obj3 = 0 ;
2805 char *kwnames[] = {
2806 (char *) "n",(char *) "red",(char *) "green",(char *) "blue", NULL
2807 };
2808
2809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_Palette",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2810 {
2811 arg1 = (int)(SWIG_As_int(obj0));
2812 if (SWIG_arg_fail(1)) SWIG_fail;
2813 }
2814 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2815 if (SWIG_arg_fail(2)) SWIG_fail;
2816 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2817 if (SWIG_arg_fail(3)) SWIG_fail;
2818 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2819 if (SWIG_arg_fail(4)) SWIG_fail;
2820 {
2821 if (!wxPyCheckForApp()) SWIG_fail;
2822 PyThreadState* __tstate = wxPyBeginAllowThreads();
2823 result = (wxPalette *)new wxPalette(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
2824
2825 wxPyEndAllowThreads(__tstate);
2826 if (PyErr_Occurred()) SWIG_fail;
2827 }
2828 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 1);
2829 return resultobj;
2830 fail:
2831 return NULL;
2832 }
2833
2834
2835 static PyObject *_wrap_delete_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2836 PyObject *resultobj;
2837 wxPalette *arg1 = (wxPalette *) 0 ;
2838 PyObject * obj0 = 0 ;
2839 char *kwnames[] = {
2840 (char *) "self", NULL
2841 };
2842
2843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Palette",kwnames,&obj0)) goto fail;
2844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2845 if (SWIG_arg_fail(1)) SWIG_fail;
2846 {
2847 PyThreadState* __tstate = wxPyBeginAllowThreads();
2848 delete arg1;
2849
2850 wxPyEndAllowThreads(__tstate);
2851 if (PyErr_Occurred()) SWIG_fail;
2852 }
2853 Py_INCREF(Py_None); resultobj = Py_None;
2854 return resultobj;
2855 fail:
2856 return NULL;
2857 }
2858
2859
2860 static PyObject *_wrap_Palette_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2861 PyObject *resultobj;
2862 wxPalette *arg1 = (wxPalette *) 0 ;
2863 byte arg2 ;
2864 byte arg3 ;
2865 byte arg4 ;
2866 int result;
2867 PyObject * obj0 = 0 ;
2868 PyObject * obj1 = 0 ;
2869 PyObject * obj2 = 0 ;
2870 PyObject * obj3 = 0 ;
2871 char *kwnames[] = {
2872 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2873 };
2874
2875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Palette_GetPixel",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2877 if (SWIG_arg_fail(1)) SWIG_fail;
2878 {
2879 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2880 if (SWIG_arg_fail(2)) SWIG_fail;
2881 }
2882 {
2883 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2884 if (SWIG_arg_fail(3)) SWIG_fail;
2885 }
2886 {
2887 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2888 if (SWIG_arg_fail(4)) SWIG_fail;
2889 }
2890 {
2891 PyThreadState* __tstate = wxPyBeginAllowThreads();
2892 result = (int)(arg1)->GetPixel(arg2,arg3,arg4);
2893
2894 wxPyEndAllowThreads(__tstate);
2895 if (PyErr_Occurred()) SWIG_fail;
2896 }
2897 {
2898 resultobj = SWIG_From_int((int)(result));
2899 }
2900 return resultobj;
2901 fail:
2902 return NULL;
2903 }
2904
2905
2906 static PyObject *_wrap_Palette_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2907 PyObject *resultobj;
2908 wxPalette *arg1 = (wxPalette *) 0 ;
2909 int arg2 ;
2910 byte *arg3 = (byte *) 0 ;
2911 byte *arg4 = (byte *) 0 ;
2912 byte *arg5 = (byte *) 0 ;
2913 bool result;
2914 byte temp3 ;
2915 int res3 = 0 ;
2916 byte temp4 ;
2917 int res4 = 0 ;
2918 byte temp5 ;
2919 int res5 = 0 ;
2920 PyObject * obj0 = 0 ;
2921 PyObject * obj1 = 0 ;
2922 char *kwnames[] = {
2923 (char *) "self",(char *) "pixel", NULL
2924 };
2925
2926 arg3 = &temp3; res3 = SWIG_NEWOBJ;
2927 arg4 = &temp4; res4 = SWIG_NEWOBJ;
2928 arg5 = &temp5; res5 = SWIG_NEWOBJ;
2929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Palette_GetRGB",kwnames,&obj0,&obj1)) goto fail;
2930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2931 if (SWIG_arg_fail(1)) SWIG_fail;
2932 {
2933 arg2 = (int)(SWIG_As_int(obj1));
2934 if (SWIG_arg_fail(2)) SWIG_fail;
2935 }
2936 {
2937 PyThreadState* __tstate = wxPyBeginAllowThreads();
2938 result = (bool)(arg1)->GetRGB(arg2,arg3,arg4,arg5);
2939
2940 wxPyEndAllowThreads(__tstate);
2941 if (PyErr_Occurred()) SWIG_fail;
2942 }
2943 {
2944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2945 }
2946 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
2947 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
2948 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
2949 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
2950 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
2951 SWIG_From_unsigned_SS_char((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_unsigned_char, 0)));
2952 return resultobj;
2953 fail:
2954 return NULL;
2955 }
2956
2957
2958 static PyObject *_wrap_Palette_GetColoursCount(PyObject *, PyObject *args, PyObject *kwargs) {
2959 PyObject *resultobj;
2960 wxPalette *arg1 = (wxPalette *) 0 ;
2961 int result;
2962 PyObject * obj0 = 0 ;
2963 char *kwnames[] = {
2964 (char *) "self", NULL
2965 };
2966
2967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_GetColoursCount",kwnames,&obj0)) goto fail;
2968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2969 if (SWIG_arg_fail(1)) SWIG_fail;
2970 {
2971 PyThreadState* __tstate = wxPyBeginAllowThreads();
2972 result = (int)((wxPalette const *)arg1)->GetColoursCount();
2973
2974 wxPyEndAllowThreads(__tstate);
2975 if (PyErr_Occurred()) SWIG_fail;
2976 }
2977 {
2978 resultobj = SWIG_From_int((int)(result));
2979 }
2980 return resultobj;
2981 fail:
2982 return NULL;
2983 }
2984
2985
2986 static PyObject *_wrap_Palette_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
2987 PyObject *resultobj;
2988 wxPalette *arg1 = (wxPalette *) 0 ;
2989 bool result;
2990 PyObject * obj0 = 0 ;
2991 char *kwnames[] = {
2992 (char *) "self", NULL
2993 };
2994
2995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_Ok",kwnames,&obj0)) goto fail;
2996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2997 if (SWIG_arg_fail(1)) SWIG_fail;
2998 {
2999 PyThreadState* __tstate = wxPyBeginAllowThreads();
3000 result = (bool)(arg1)->Ok();
3001
3002 wxPyEndAllowThreads(__tstate);
3003 if (PyErr_Occurred()) SWIG_fail;
3004 }
3005 {
3006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3007 }
3008 return resultobj;
3009 fail:
3010 return NULL;
3011 }
3012
3013
3014 static PyObject * Palette_swigregister(PyObject *, PyObject *args) {
3015 PyObject *obj;
3016 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3017 SWIG_TypeClientData(SWIGTYPE_p_wxPalette, obj);
3018 Py_INCREF(obj);
3019 return Py_BuildValue((char *)"");
3020 }
3021 static PyObject *_wrap_new_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3022 PyObject *resultobj;
3023 wxColour *arg1 = 0 ;
3024 int arg2 = (int) 1 ;
3025 int arg3 = (int) wxSOLID ;
3026 wxPen *result;
3027 wxColour temp1 ;
3028 PyObject * obj0 = 0 ;
3029 PyObject * obj1 = 0 ;
3030 PyObject * obj2 = 0 ;
3031 char *kwnames[] = {
3032 (char *) "colour",(char *) "width",(char *) "style", NULL
3033 };
3034
3035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Pen",kwnames,&obj0,&obj1,&obj2)) goto fail;
3036 {
3037 arg1 = &temp1;
3038 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3039 }
3040 if (obj1) {
3041 {
3042 arg2 = (int)(SWIG_As_int(obj1));
3043 if (SWIG_arg_fail(2)) SWIG_fail;
3044 }
3045 }
3046 if (obj2) {
3047 {
3048 arg3 = (int)(SWIG_As_int(obj2));
3049 if (SWIG_arg_fail(3)) SWIG_fail;
3050 }
3051 }
3052 {
3053 if (!wxPyCheckForApp()) SWIG_fail;
3054 PyThreadState* __tstate = wxPyBeginAllowThreads();
3055 result = (wxPen *)new wxPen(*arg1,arg2,arg3);
3056
3057 wxPyEndAllowThreads(__tstate);
3058 if (PyErr_Occurred()) SWIG_fail;
3059 }
3060 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 1);
3061 return resultobj;
3062 fail:
3063 return NULL;
3064 }
3065
3066
3067 static PyObject *_wrap_delete_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3068 PyObject *resultobj;
3069 wxPen *arg1 = (wxPen *) 0 ;
3070 PyObject * obj0 = 0 ;
3071 char *kwnames[] = {
3072 (char *) "self", NULL
3073 };
3074
3075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Pen",kwnames,&obj0)) goto fail;
3076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3077 if (SWIG_arg_fail(1)) SWIG_fail;
3078 {
3079 PyThreadState* __tstate = wxPyBeginAllowThreads();
3080 delete arg1;
3081
3082 wxPyEndAllowThreads(__tstate);
3083 if (PyErr_Occurred()) SWIG_fail;
3084 }
3085 Py_INCREF(Py_None); resultobj = Py_None;
3086 return resultobj;
3087 fail:
3088 return NULL;
3089 }
3090
3091
3092 static PyObject *_wrap_Pen_GetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3093 PyObject *resultobj;
3094 wxPen *arg1 = (wxPen *) 0 ;
3095 int result;
3096 PyObject * obj0 = 0 ;
3097 char *kwnames[] = {
3098 (char *) "self", NULL
3099 };
3100
3101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetCap",kwnames,&obj0)) goto fail;
3102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3103 if (SWIG_arg_fail(1)) SWIG_fail;
3104 {
3105 PyThreadState* __tstate = wxPyBeginAllowThreads();
3106 result = (int)(arg1)->GetCap();
3107
3108 wxPyEndAllowThreads(__tstate);
3109 if (PyErr_Occurred()) SWIG_fail;
3110 }
3111 {
3112 resultobj = SWIG_From_int((int)(result));
3113 }
3114 return resultobj;
3115 fail:
3116 return NULL;
3117 }
3118
3119
3120 static PyObject *_wrap_Pen_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3121 PyObject *resultobj;
3122 wxPen *arg1 = (wxPen *) 0 ;
3123 wxColour result;
3124 PyObject * obj0 = 0 ;
3125 char *kwnames[] = {
3126 (char *) "self", NULL
3127 };
3128
3129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetColour",kwnames,&obj0)) goto fail;
3130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3131 if (SWIG_arg_fail(1)) SWIG_fail;
3132 {
3133 PyThreadState* __tstate = wxPyBeginAllowThreads();
3134 result = (arg1)->GetColour();
3135
3136 wxPyEndAllowThreads(__tstate);
3137 if (PyErr_Occurred()) SWIG_fail;
3138 }
3139 {
3140 wxColour * resultptr;
3141 resultptr = new wxColour((wxColour &)(result));
3142 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3143 }
3144 return resultobj;
3145 fail:
3146 return NULL;
3147 }
3148
3149
3150 static PyObject *_wrap_Pen_GetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3151 PyObject *resultobj;
3152 wxPen *arg1 = (wxPen *) 0 ;
3153 int result;
3154 PyObject * obj0 = 0 ;
3155 char *kwnames[] = {
3156 (char *) "self", NULL
3157 };
3158
3159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetJoin",kwnames,&obj0)) goto fail;
3160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3161 if (SWIG_arg_fail(1)) SWIG_fail;
3162 {
3163 PyThreadState* __tstate = wxPyBeginAllowThreads();
3164 result = (int)(arg1)->GetJoin();
3165
3166 wxPyEndAllowThreads(__tstate);
3167 if (PyErr_Occurred()) SWIG_fail;
3168 }
3169 {
3170 resultobj = SWIG_From_int((int)(result));
3171 }
3172 return resultobj;
3173 fail:
3174 return NULL;
3175 }
3176
3177
3178 static PyObject *_wrap_Pen_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3179 PyObject *resultobj;
3180 wxPen *arg1 = (wxPen *) 0 ;
3181 int result;
3182 PyObject * obj0 = 0 ;
3183 char *kwnames[] = {
3184 (char *) "self", NULL
3185 };
3186
3187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetStyle",kwnames,&obj0)) goto fail;
3188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3189 if (SWIG_arg_fail(1)) SWIG_fail;
3190 {
3191 PyThreadState* __tstate = wxPyBeginAllowThreads();
3192 result = (int)(arg1)->GetStyle();
3193
3194 wxPyEndAllowThreads(__tstate);
3195 if (PyErr_Occurred()) SWIG_fail;
3196 }
3197 {
3198 resultobj = SWIG_From_int((int)(result));
3199 }
3200 return resultobj;
3201 fail:
3202 return NULL;
3203 }
3204
3205
3206 static PyObject *_wrap_Pen_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3207 PyObject *resultobj;
3208 wxPen *arg1 = (wxPen *) 0 ;
3209 int result;
3210 PyObject * obj0 = 0 ;
3211 char *kwnames[] = {
3212 (char *) "self", NULL
3213 };
3214
3215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetWidth",kwnames,&obj0)) goto fail;
3216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3217 if (SWIG_arg_fail(1)) SWIG_fail;
3218 {
3219 PyThreadState* __tstate = wxPyBeginAllowThreads();
3220 result = (int)(arg1)->GetWidth();
3221
3222 wxPyEndAllowThreads(__tstate);
3223 if (PyErr_Occurred()) SWIG_fail;
3224 }
3225 {
3226 resultobj = SWIG_From_int((int)(result));
3227 }
3228 return resultobj;
3229 fail:
3230 return NULL;
3231 }
3232
3233
3234 static PyObject *_wrap_Pen_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3235 PyObject *resultobj;
3236 wxPen *arg1 = (wxPen *) 0 ;
3237 bool result;
3238 PyObject * obj0 = 0 ;
3239 char *kwnames[] = {
3240 (char *) "self", NULL
3241 };
3242
3243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_Ok",kwnames,&obj0)) goto fail;
3244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3245 if (SWIG_arg_fail(1)) SWIG_fail;
3246 {
3247 PyThreadState* __tstate = wxPyBeginAllowThreads();
3248 result = (bool)(arg1)->Ok();
3249
3250 wxPyEndAllowThreads(__tstate);
3251 if (PyErr_Occurred()) SWIG_fail;
3252 }
3253 {
3254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3255 }
3256 return resultobj;
3257 fail:
3258 return NULL;
3259 }
3260
3261
3262 static PyObject *_wrap_Pen_SetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3263 PyObject *resultobj;
3264 wxPen *arg1 = (wxPen *) 0 ;
3265 int arg2 ;
3266 PyObject * obj0 = 0 ;
3267 PyObject * obj1 = 0 ;
3268 char *kwnames[] = {
3269 (char *) "self",(char *) "cap_style", NULL
3270 };
3271
3272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetCap",kwnames,&obj0,&obj1)) goto fail;
3273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3274 if (SWIG_arg_fail(1)) SWIG_fail;
3275 {
3276 arg2 = (int)(SWIG_As_int(obj1));
3277 if (SWIG_arg_fail(2)) SWIG_fail;
3278 }
3279 {
3280 PyThreadState* __tstate = wxPyBeginAllowThreads();
3281 (arg1)->SetCap(arg2);
3282
3283 wxPyEndAllowThreads(__tstate);
3284 if (PyErr_Occurred()) SWIG_fail;
3285 }
3286 Py_INCREF(Py_None); resultobj = Py_None;
3287 return resultobj;
3288 fail:
3289 return NULL;
3290 }
3291
3292
3293 static PyObject *_wrap_Pen_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3294 PyObject *resultobj;
3295 wxPen *arg1 = (wxPen *) 0 ;
3296 wxColour *arg2 = 0 ;
3297 wxColour temp2 ;
3298 PyObject * obj0 = 0 ;
3299 PyObject * obj1 = 0 ;
3300 char *kwnames[] = {
3301 (char *) "self",(char *) "colour", NULL
3302 };
3303
3304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetColour",kwnames,&obj0,&obj1)) goto fail;
3305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3306 if (SWIG_arg_fail(1)) SWIG_fail;
3307 {
3308 arg2 = &temp2;
3309 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3310 }
3311 {
3312 PyThreadState* __tstate = wxPyBeginAllowThreads();
3313 (arg1)->SetColour(*arg2);
3314
3315 wxPyEndAllowThreads(__tstate);
3316 if (PyErr_Occurred()) SWIG_fail;
3317 }
3318 Py_INCREF(Py_None); resultobj = Py_None;
3319 return resultobj;
3320 fail:
3321 return NULL;
3322 }
3323
3324
3325 static PyObject *_wrap_Pen_SetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3326 PyObject *resultobj;
3327 wxPen *arg1 = (wxPen *) 0 ;
3328 int arg2 ;
3329 PyObject * obj0 = 0 ;
3330 PyObject * obj1 = 0 ;
3331 char *kwnames[] = {
3332 (char *) "self",(char *) "join_style", NULL
3333 };
3334
3335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetJoin",kwnames,&obj0,&obj1)) goto fail;
3336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3337 if (SWIG_arg_fail(1)) SWIG_fail;
3338 {
3339 arg2 = (int)(SWIG_As_int(obj1));
3340 if (SWIG_arg_fail(2)) SWIG_fail;
3341 }
3342 {
3343 PyThreadState* __tstate = wxPyBeginAllowThreads();
3344 (arg1)->SetJoin(arg2);
3345
3346 wxPyEndAllowThreads(__tstate);
3347 if (PyErr_Occurred()) SWIG_fail;
3348 }
3349 Py_INCREF(Py_None); resultobj = Py_None;
3350 return resultobj;
3351 fail:
3352 return NULL;
3353 }
3354
3355
3356 static PyObject *_wrap_Pen_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3357 PyObject *resultobj;
3358 wxPen *arg1 = (wxPen *) 0 ;
3359 int arg2 ;
3360 PyObject * obj0 = 0 ;
3361 PyObject * obj1 = 0 ;
3362 char *kwnames[] = {
3363 (char *) "self",(char *) "style", NULL
3364 };
3365
3366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3368 if (SWIG_arg_fail(1)) SWIG_fail;
3369 {
3370 arg2 = (int)(SWIG_As_int(obj1));
3371 if (SWIG_arg_fail(2)) SWIG_fail;
3372 }
3373 {
3374 PyThreadState* __tstate = wxPyBeginAllowThreads();
3375 (arg1)->SetStyle(arg2);
3376
3377 wxPyEndAllowThreads(__tstate);
3378 if (PyErr_Occurred()) SWIG_fail;
3379 }
3380 Py_INCREF(Py_None); resultobj = Py_None;
3381 return resultobj;
3382 fail:
3383 return NULL;
3384 }
3385
3386
3387 static PyObject *_wrap_Pen_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3388 PyObject *resultobj;
3389 wxPen *arg1 = (wxPen *) 0 ;
3390 int arg2 ;
3391 PyObject * obj0 = 0 ;
3392 PyObject * obj1 = 0 ;
3393 char *kwnames[] = {
3394 (char *) "self",(char *) "width", NULL
3395 };
3396
3397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3399 if (SWIG_arg_fail(1)) SWIG_fail;
3400 {
3401 arg2 = (int)(SWIG_As_int(obj1));
3402 if (SWIG_arg_fail(2)) SWIG_fail;
3403 }
3404 {
3405 PyThreadState* __tstate = wxPyBeginAllowThreads();
3406 (arg1)->SetWidth(arg2);
3407
3408 wxPyEndAllowThreads(__tstate);
3409 if (PyErr_Occurred()) SWIG_fail;
3410 }
3411 Py_INCREF(Py_None); resultobj = Py_None;
3412 return resultobj;
3413 fail:
3414 return NULL;
3415 }
3416
3417
3418 static PyObject *_wrap_Pen_SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3419 PyObject *resultobj;
3420 wxPen *arg1 = (wxPen *) 0 ;
3421 int arg2 ;
3422 wxDash *arg3 = (wxDash *) 0 ;
3423 PyObject * obj0 = 0 ;
3424 PyObject * obj1 = 0 ;
3425 char *kwnames[] = {
3426 (char *) "self",(char *) "dashes", NULL
3427 };
3428
3429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetDashes",kwnames,&obj0,&obj1)) goto fail;
3430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3431 if (SWIG_arg_fail(1)) SWIG_fail;
3432 {
3433 arg2 = PyList_Size(obj1);
3434 arg3 = (wxDash*)byte_LIST_helper(obj1);
3435 if (arg3 == NULL) SWIG_fail;
3436 }
3437 {
3438 PyThreadState* __tstate = wxPyBeginAllowThreads();
3439 (arg1)->SetDashes(arg2,arg3);
3440
3441 wxPyEndAllowThreads(__tstate);
3442 if (PyErr_Occurred()) SWIG_fail;
3443 }
3444 Py_INCREF(Py_None); resultobj = Py_None;
3445 {
3446 if (arg3) delete [] arg3;
3447 }
3448 return resultobj;
3449 fail:
3450 {
3451 if (arg3) delete [] arg3;
3452 }
3453 return NULL;
3454 }
3455
3456
3457 static PyObject *_wrap_Pen_GetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3458 PyObject *resultobj;
3459 wxPen *arg1 = (wxPen *) 0 ;
3460 PyObject *result;
3461 PyObject * obj0 = 0 ;
3462 char *kwnames[] = {
3463 (char *) "self", NULL
3464 };
3465
3466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetDashes",kwnames,&obj0)) goto fail;
3467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3468 if (SWIG_arg_fail(1)) SWIG_fail;
3469 {
3470 PyThreadState* __tstate = wxPyBeginAllowThreads();
3471 result = (PyObject *)wxPen_GetDashes(arg1);
3472
3473 wxPyEndAllowThreads(__tstate);
3474 if (PyErr_Occurred()) SWIG_fail;
3475 }
3476 resultobj = result;
3477 return resultobj;
3478 fail:
3479 return NULL;
3480 }
3481
3482
3483 static PyObject *_wrap_Pen__SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3484 PyObject *resultobj;
3485 wxPen *arg1 = (wxPen *) 0 ;
3486 PyObject *arg2 = (PyObject *) 0 ;
3487 PyObject *arg3 = (PyObject *) 0 ;
3488 PyObject * obj0 = 0 ;
3489 PyObject * obj1 = 0 ;
3490 PyObject * obj2 = 0 ;
3491 char *kwnames[] = {
3492 (char *) "self",(char *) "_self",(char *) "pyDashes", NULL
3493 };
3494
3495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Pen__SetDashes",kwnames,&obj0,&obj1,&obj2)) goto fail;
3496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3497 if (SWIG_arg_fail(1)) SWIG_fail;
3498 arg2 = obj1;
3499 arg3 = obj2;
3500 {
3501 PyThreadState* __tstate = wxPyBeginAllowThreads();
3502 wxPen__SetDashes(arg1,arg2,arg3);
3503
3504 wxPyEndAllowThreads(__tstate);
3505 if (PyErr_Occurred()) SWIG_fail;
3506 }
3507 Py_INCREF(Py_None); resultobj = Py_None;
3508 return resultobj;
3509 fail:
3510 return NULL;
3511 }
3512
3513
3514 static PyObject *_wrap_Pen_GetDashCount(PyObject *, PyObject *args, PyObject *kwargs) {
3515 PyObject *resultobj;
3516 wxPen *arg1 = (wxPen *) 0 ;
3517 int result;
3518 PyObject * obj0 = 0 ;
3519 char *kwnames[] = {
3520 (char *) "self", NULL
3521 };
3522
3523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetDashCount",kwnames,&obj0)) goto fail;
3524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3525 if (SWIG_arg_fail(1)) SWIG_fail;
3526 {
3527 PyThreadState* __tstate = wxPyBeginAllowThreads();
3528 result = (int)((wxPen const *)arg1)->GetDashCount();
3529
3530 wxPyEndAllowThreads(__tstate);
3531 if (PyErr_Occurred()) SWIG_fail;
3532 }
3533 {
3534 resultobj = SWIG_From_int((int)(result));
3535 }
3536 return resultobj;
3537 fail:
3538 return NULL;
3539 }
3540
3541
3542 static PyObject *_wrap_Pen_GetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3543 PyObject *resultobj;
3544 wxPen *arg1 = (wxPen *) 0 ;
3545 wxBitmap *result;
3546 PyObject * obj0 = 0 ;
3547 char *kwnames[] = {
3548 (char *) "self", NULL
3549 };
3550
3551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetStipple",kwnames,&obj0)) goto fail;
3552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3553 if (SWIG_arg_fail(1)) SWIG_fail;
3554 {
3555 PyThreadState* __tstate = wxPyBeginAllowThreads();
3556 result = (wxBitmap *)(arg1)->GetStipple();
3557
3558 wxPyEndAllowThreads(__tstate);
3559 if (PyErr_Occurred()) SWIG_fail;
3560 }
3561 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 0);
3562 return resultobj;
3563 fail:
3564 return NULL;
3565 }
3566
3567
3568 static PyObject *_wrap_Pen_SetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3569 PyObject *resultobj;
3570 wxPen *arg1 = (wxPen *) 0 ;
3571 wxBitmap *arg2 = 0 ;
3572 PyObject * obj0 = 0 ;
3573 PyObject * obj1 = 0 ;
3574 char *kwnames[] = {
3575 (char *) "self",(char *) "stipple", NULL
3576 };
3577
3578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetStipple",kwnames,&obj0,&obj1)) goto fail;
3579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3580 if (SWIG_arg_fail(1)) SWIG_fail;
3581 {
3582 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3583 if (SWIG_arg_fail(2)) SWIG_fail;
3584 if (arg2 == NULL) {
3585 SWIG_null_ref("wxBitmap");
3586 }
3587 if (SWIG_arg_fail(2)) SWIG_fail;
3588 }
3589 {
3590 PyThreadState* __tstate = wxPyBeginAllowThreads();
3591 (arg1)->SetStipple(*arg2);
3592
3593 wxPyEndAllowThreads(__tstate);
3594 if (PyErr_Occurred()) SWIG_fail;
3595 }
3596 Py_INCREF(Py_None); resultobj = Py_None;
3597 return resultobj;
3598 fail:
3599 return NULL;
3600 }
3601
3602
3603 static PyObject *_wrap_Pen___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3604 PyObject *resultobj;
3605 wxPen *arg1 = (wxPen *) 0 ;
3606 wxPen *arg2 = (wxPen *) 0 ;
3607 bool result;
3608 PyObject * obj0 = 0 ;
3609 PyObject * obj1 = 0 ;
3610 char *kwnames[] = {
3611 (char *) "self",(char *) "other", NULL
3612 };
3613
3614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___eq__",kwnames,&obj0,&obj1)) goto fail;
3615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3616 if (SWIG_arg_fail(1)) SWIG_fail;
3617 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3618 if (SWIG_arg_fail(2)) SWIG_fail;
3619 {
3620 PyThreadState* __tstate = wxPyBeginAllowThreads();
3621 result = (bool)wxPen___eq__(arg1,(wxPen const *)arg2);
3622
3623 wxPyEndAllowThreads(__tstate);
3624 if (PyErr_Occurred()) SWIG_fail;
3625 }
3626 {
3627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3628 }
3629 return resultobj;
3630 fail:
3631 return NULL;
3632 }
3633
3634
3635 static PyObject *_wrap_Pen___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3636 PyObject *resultobj;
3637 wxPen *arg1 = (wxPen *) 0 ;
3638 wxPen *arg2 = (wxPen *) 0 ;
3639 bool result;
3640 PyObject * obj0 = 0 ;
3641 PyObject * obj1 = 0 ;
3642 char *kwnames[] = {
3643 (char *) "self",(char *) "other", NULL
3644 };
3645
3646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___ne__",kwnames,&obj0,&obj1)) goto fail;
3647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3648 if (SWIG_arg_fail(1)) SWIG_fail;
3649 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3650 if (SWIG_arg_fail(2)) SWIG_fail;
3651 {
3652 PyThreadState* __tstate = wxPyBeginAllowThreads();
3653 result = (bool)wxPen___ne__(arg1,(wxPen const *)arg2);
3654
3655 wxPyEndAllowThreads(__tstate);
3656 if (PyErr_Occurred()) SWIG_fail;
3657 }
3658 {
3659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3660 }
3661 return resultobj;
3662 fail:
3663 return NULL;
3664 }
3665
3666
3667 static PyObject * Pen_swigregister(PyObject *, PyObject *args) {
3668 PyObject *obj;
3669 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3670 SWIG_TypeClientData(SWIGTYPE_p_wxPen, obj);
3671 Py_INCREF(obj);
3672 return Py_BuildValue((char *)"");
3673 }
3674 static PyObject *_wrap_new_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3675 PyObject *resultobj;
3676 wxColour *arg1 = 0 ;
3677 int arg2 = (int) wxSOLID ;
3678 wxBrush *result;
3679 wxColour temp1 ;
3680 PyObject * obj0 = 0 ;
3681 PyObject * obj1 = 0 ;
3682 char *kwnames[] = {
3683 (char *) "colour",(char *) "style", NULL
3684 };
3685
3686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Brush",kwnames,&obj0,&obj1)) goto fail;
3687 {
3688 arg1 = &temp1;
3689 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3690 }
3691 if (obj1) {
3692 {
3693 arg2 = (int)(SWIG_As_int(obj1));
3694 if (SWIG_arg_fail(2)) SWIG_fail;
3695 }
3696 }
3697 {
3698 if (!wxPyCheckForApp()) SWIG_fail;
3699 PyThreadState* __tstate = wxPyBeginAllowThreads();
3700 result = (wxBrush *)new wxBrush((wxColour const &)*arg1,arg2);
3701
3702 wxPyEndAllowThreads(__tstate);
3703 if (PyErr_Occurred()) SWIG_fail;
3704 }
3705 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 1);
3706 return resultobj;
3707 fail:
3708 return NULL;
3709 }
3710
3711
3712 static PyObject *_wrap_new_BrushFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
3713 PyObject *resultobj;
3714 wxBitmap *arg1 = 0 ;
3715 wxBrush *result;
3716 PyObject * obj0 = 0 ;
3717 char *kwnames[] = {
3718 (char *) "stippleBitmap", NULL
3719 };
3720
3721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BrushFromBitmap",kwnames,&obj0)) goto fail;
3722 {
3723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3724 if (SWIG_arg_fail(1)) SWIG_fail;
3725 if (arg1 == NULL) {
3726 SWIG_null_ref("wxBitmap");
3727 }
3728 if (SWIG_arg_fail(1)) SWIG_fail;
3729 }
3730 {
3731 if (!wxPyCheckForApp()) SWIG_fail;
3732 PyThreadState* __tstate = wxPyBeginAllowThreads();
3733 result = (wxBrush *)new wxBrush((wxBitmap const &)*arg1);
3734
3735 wxPyEndAllowThreads(__tstate);
3736 if (PyErr_Occurred()) SWIG_fail;
3737 }
3738 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 1);
3739 return resultobj;
3740 fail:
3741 return NULL;
3742 }
3743
3744
3745 static PyObject *_wrap_delete_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3746 PyObject *resultobj;
3747 wxBrush *arg1 = (wxBrush *) 0 ;
3748 PyObject * obj0 = 0 ;
3749 char *kwnames[] = {
3750 (char *) "self", NULL
3751 };
3752
3753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Brush",kwnames,&obj0)) goto fail;
3754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3755 if (SWIG_arg_fail(1)) SWIG_fail;
3756 {
3757 PyThreadState* __tstate = wxPyBeginAllowThreads();
3758 delete arg1;
3759
3760 wxPyEndAllowThreads(__tstate);
3761 if (PyErr_Occurred()) SWIG_fail;
3762 }
3763 Py_INCREF(Py_None); resultobj = Py_None;
3764 return resultobj;
3765 fail:
3766 return NULL;
3767 }
3768
3769
3770 static PyObject *_wrap_Brush_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3771 PyObject *resultobj;
3772 wxBrush *arg1 = (wxBrush *) 0 ;
3773 wxColour *arg2 = 0 ;
3774 wxColour temp2 ;
3775 PyObject * obj0 = 0 ;
3776 PyObject * obj1 = 0 ;
3777 char *kwnames[] = {
3778 (char *) "self",(char *) "col", NULL
3779 };
3780
3781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetColour",kwnames,&obj0,&obj1)) goto fail;
3782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3783 if (SWIG_arg_fail(1)) SWIG_fail;
3784 {
3785 arg2 = &temp2;
3786 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3787 }
3788 {
3789 PyThreadState* __tstate = wxPyBeginAllowThreads();
3790 (arg1)->SetColour((wxColour const &)*arg2);
3791
3792 wxPyEndAllowThreads(__tstate);
3793 if (PyErr_Occurred()) SWIG_fail;
3794 }
3795 Py_INCREF(Py_None); resultobj = Py_None;
3796 return resultobj;
3797 fail:
3798 return NULL;
3799 }
3800
3801
3802 static PyObject *_wrap_Brush_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3803 PyObject *resultobj;
3804 wxBrush *arg1 = (wxBrush *) 0 ;
3805 int arg2 ;
3806 PyObject * obj0 = 0 ;
3807 PyObject * obj1 = 0 ;
3808 char *kwnames[] = {
3809 (char *) "self",(char *) "style", NULL
3810 };
3811
3812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3814 if (SWIG_arg_fail(1)) SWIG_fail;
3815 {
3816 arg2 = (int)(SWIG_As_int(obj1));
3817 if (SWIG_arg_fail(2)) SWIG_fail;
3818 }
3819 {
3820 PyThreadState* __tstate = wxPyBeginAllowThreads();
3821 (arg1)->SetStyle(arg2);
3822
3823 wxPyEndAllowThreads(__tstate);
3824 if (PyErr_Occurred()) SWIG_fail;
3825 }
3826 Py_INCREF(Py_None); resultobj = Py_None;
3827 return resultobj;
3828 fail:
3829 return NULL;
3830 }
3831
3832
3833 static PyObject *_wrap_Brush_SetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3834 PyObject *resultobj;
3835 wxBrush *arg1 = (wxBrush *) 0 ;
3836 wxBitmap *arg2 = 0 ;
3837 PyObject * obj0 = 0 ;
3838 PyObject * obj1 = 0 ;
3839 char *kwnames[] = {
3840 (char *) "self",(char *) "stipple", NULL
3841 };
3842
3843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStipple",kwnames,&obj0,&obj1)) goto fail;
3844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3845 if (SWIG_arg_fail(1)) SWIG_fail;
3846 {
3847 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3848 if (SWIG_arg_fail(2)) SWIG_fail;
3849 if (arg2 == NULL) {
3850 SWIG_null_ref("wxBitmap");
3851 }
3852 if (SWIG_arg_fail(2)) SWIG_fail;
3853 }
3854 {
3855 PyThreadState* __tstate = wxPyBeginAllowThreads();
3856 (arg1)->SetStipple((wxBitmap const &)*arg2);
3857
3858 wxPyEndAllowThreads(__tstate);
3859 if (PyErr_Occurred()) SWIG_fail;
3860 }
3861 Py_INCREF(Py_None); resultobj = Py_None;
3862 return resultobj;
3863 fail:
3864 return NULL;
3865 }
3866
3867
3868 static PyObject *_wrap_Brush_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3869 PyObject *resultobj;
3870 wxBrush *arg1 = (wxBrush *) 0 ;
3871 wxColour result;
3872 PyObject * obj0 = 0 ;
3873 char *kwnames[] = {
3874 (char *) "self", NULL
3875 };
3876
3877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetColour",kwnames,&obj0)) goto fail;
3878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3879 if (SWIG_arg_fail(1)) SWIG_fail;
3880 {
3881 PyThreadState* __tstate = wxPyBeginAllowThreads();
3882 result = ((wxBrush const *)arg1)->GetColour();
3883
3884 wxPyEndAllowThreads(__tstate);
3885 if (PyErr_Occurred()) SWIG_fail;
3886 }
3887 {
3888 wxColour * resultptr;
3889 resultptr = new wxColour((wxColour &)(result));
3890 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3891 }
3892 return resultobj;
3893 fail:
3894 return NULL;
3895 }
3896
3897
3898 static PyObject *_wrap_Brush_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3899 PyObject *resultobj;
3900 wxBrush *arg1 = (wxBrush *) 0 ;
3901 int result;
3902 PyObject * obj0 = 0 ;
3903 char *kwnames[] = {
3904 (char *) "self", NULL
3905 };
3906
3907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStyle",kwnames,&obj0)) goto fail;
3908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3909 if (SWIG_arg_fail(1)) SWIG_fail;
3910 {
3911 PyThreadState* __tstate = wxPyBeginAllowThreads();
3912 result = (int)((wxBrush const *)arg1)->GetStyle();
3913
3914 wxPyEndAllowThreads(__tstate);
3915 if (PyErr_Occurred()) SWIG_fail;
3916 }
3917 {
3918 resultobj = SWIG_From_int((int)(result));
3919 }
3920 return resultobj;
3921 fail:
3922 return NULL;
3923 }
3924
3925
3926 static PyObject *_wrap_Brush_GetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3927 PyObject *resultobj;
3928 wxBrush *arg1 = (wxBrush *) 0 ;
3929 wxBitmap *result;
3930 PyObject * obj0 = 0 ;
3931 char *kwnames[] = {
3932 (char *) "self", NULL
3933 };
3934
3935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStipple",kwnames,&obj0)) goto fail;
3936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3937 if (SWIG_arg_fail(1)) SWIG_fail;
3938 {
3939 PyThreadState* __tstate = wxPyBeginAllowThreads();
3940 result = (wxBitmap *)((wxBrush const *)arg1)->GetStipple();
3941
3942 wxPyEndAllowThreads(__tstate);
3943 if (PyErr_Occurred()) SWIG_fail;
3944 }
3945 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 0);
3946 return resultobj;
3947 fail:
3948 return NULL;
3949 }
3950
3951
3952 static PyObject *_wrap_Brush_IsHatch(PyObject *, PyObject *args, PyObject *kwargs) {
3953 PyObject *resultobj;
3954 wxBrush *arg1 = (wxBrush *) 0 ;
3955 bool result;
3956 PyObject * obj0 = 0 ;
3957 char *kwnames[] = {
3958 (char *) "self", NULL
3959 };
3960
3961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_IsHatch",kwnames,&obj0)) goto fail;
3962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3963 if (SWIG_arg_fail(1)) SWIG_fail;
3964 {
3965 PyThreadState* __tstate = wxPyBeginAllowThreads();
3966 result = (bool)((wxBrush const *)arg1)->IsHatch();
3967
3968 wxPyEndAllowThreads(__tstate);
3969 if (PyErr_Occurred()) SWIG_fail;
3970 }
3971 {
3972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3973 }
3974 return resultobj;
3975 fail:
3976 return NULL;
3977 }
3978
3979
3980 static PyObject *_wrap_Brush_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3981 PyObject *resultobj;
3982 wxBrush *arg1 = (wxBrush *) 0 ;
3983 bool result;
3984 PyObject * obj0 = 0 ;
3985 char *kwnames[] = {
3986 (char *) "self", NULL
3987 };
3988
3989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_Ok",kwnames,&obj0)) goto fail;
3990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3991 if (SWIG_arg_fail(1)) SWIG_fail;
3992 {
3993 PyThreadState* __tstate = wxPyBeginAllowThreads();
3994 result = (bool)(arg1)->Ok();
3995
3996 wxPyEndAllowThreads(__tstate);
3997 if (PyErr_Occurred()) SWIG_fail;
3998 }
3999 {
4000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4001 }
4002 return resultobj;
4003 fail:
4004 return NULL;
4005 }
4006
4007
4008 static PyObject * Brush_swigregister(PyObject *, PyObject *args) {
4009 PyObject *obj;
4010 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4011 SWIG_TypeClientData(SWIGTYPE_p_wxBrush, obj);
4012 Py_INCREF(obj);
4013 return Py_BuildValue((char *)"");
4014 }
4015 static PyObject *_wrap_new_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4016 PyObject *resultobj;
4017 wxString *arg1 = 0 ;
4018 wxBitmapType arg2 = (wxBitmapType) wxBITMAP_TYPE_ANY ;
4019 wxBitmap *result;
4020 bool temp1 = false ;
4021 PyObject * obj0 = 0 ;
4022 PyObject * obj1 = 0 ;
4023 char *kwnames[] = {
4024 (char *) "name",(char *) "type", NULL
4025 };
4026
4027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Bitmap",kwnames,&obj0,&obj1)) goto fail;
4028 {
4029 arg1 = wxString_in_helper(obj0);
4030 if (arg1 == NULL) SWIG_fail;
4031 temp1 = true;
4032 }
4033 if (obj1) {
4034 {
4035 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
4036 if (SWIG_arg_fail(2)) SWIG_fail;
4037 }
4038 }
4039 {
4040 if (!wxPyCheckForApp()) SWIG_fail;
4041 PyThreadState* __tstate = wxPyBeginAllowThreads();
4042 result = (wxBitmap *)new wxBitmap((wxString const &)*arg1,(wxBitmapType )arg2);
4043
4044 wxPyEndAllowThreads(__tstate);
4045 if (PyErr_Occurred()) SWIG_fail;
4046 }
4047 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4048 {
4049 if (temp1)
4050 delete arg1;
4051 }
4052 return resultobj;
4053 fail:
4054 {
4055 if (temp1)
4056 delete arg1;
4057 }
4058 return NULL;
4059 }
4060
4061
4062 static PyObject *_wrap_delete_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4063 PyObject *resultobj;
4064 wxBitmap *arg1 = (wxBitmap *) 0 ;
4065 PyObject * obj0 = 0 ;
4066 char *kwnames[] = {
4067 (char *) "self", NULL
4068 };
4069
4070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Bitmap",kwnames,&obj0)) goto fail;
4071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4072 if (SWIG_arg_fail(1)) SWIG_fail;
4073 {
4074 PyThreadState* __tstate = wxPyBeginAllowThreads();
4075 delete arg1;
4076
4077 wxPyEndAllowThreads(__tstate);
4078 if (PyErr_Occurred()) SWIG_fail;
4079 }
4080 Py_INCREF(Py_None); resultobj = Py_None;
4081 return resultobj;
4082 fail:
4083 return NULL;
4084 }
4085
4086
4087 static PyObject *_wrap_new_EmptyBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4088 PyObject *resultobj;
4089 int arg1 ;
4090 int arg2 ;
4091 int arg3 = (int) -1 ;
4092 wxBitmap *result;
4093 PyObject * obj0 = 0 ;
4094 PyObject * obj1 = 0 ;
4095 PyObject * obj2 = 0 ;
4096 char *kwnames[] = {
4097 (char *) "width",(char *) "height",(char *) "depth", NULL
4098 };
4099
4100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_EmptyBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
4101 {
4102 arg1 = (int)(SWIG_As_int(obj0));
4103 if (SWIG_arg_fail(1)) SWIG_fail;
4104 }
4105 {
4106 arg2 = (int)(SWIG_As_int(obj1));
4107 if (SWIG_arg_fail(2)) SWIG_fail;
4108 }
4109 if (obj2) {
4110 {
4111 arg3 = (int)(SWIG_As_int(obj2));
4112 if (SWIG_arg_fail(3)) SWIG_fail;
4113 }
4114 }
4115 {
4116 if (!wxPyCheckForApp()) SWIG_fail;
4117 PyThreadState* __tstate = wxPyBeginAllowThreads();
4118 result = (wxBitmap *)new wxBitmap(arg1,arg2,arg3);
4119
4120 wxPyEndAllowThreads(__tstate);
4121 if (PyErr_Occurred()) SWIG_fail;
4122 }
4123 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4124 return resultobj;
4125 fail:
4126 return NULL;
4127 }
4128
4129
4130 static PyObject *_wrap_new_BitmapFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4131 PyObject *resultobj;
4132 wxIcon *arg1 = 0 ;
4133 wxBitmap *result;
4134 PyObject * obj0 = 0 ;
4135 char *kwnames[] = {
4136 (char *) "icon", NULL
4137 };
4138
4139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromIcon",kwnames,&obj0)) goto fail;
4140 {
4141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4142 if (SWIG_arg_fail(1)) SWIG_fail;
4143 if (arg1 == NULL) {
4144 SWIG_null_ref("wxIcon");
4145 }
4146 if (SWIG_arg_fail(1)) SWIG_fail;
4147 }
4148 {
4149 if (!wxPyCheckForApp()) SWIG_fail;
4150 PyThreadState* __tstate = wxPyBeginAllowThreads();
4151 result = (wxBitmap *)new wxBitmap((wxIcon const &)*arg1);
4152
4153 wxPyEndAllowThreads(__tstate);
4154 if (PyErr_Occurred()) SWIG_fail;
4155 }
4156 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4157 return resultobj;
4158 fail:
4159 return NULL;
4160 }
4161
4162
4163 static PyObject *_wrap_new_BitmapFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
4164 PyObject *resultobj;
4165 wxImage *arg1 = 0 ;
4166 int arg2 = (int) -1 ;
4167 wxBitmap *result;
4168 PyObject * obj0 = 0 ;
4169 PyObject * obj1 = 0 ;
4170 char *kwnames[] = {
4171 (char *) "image",(char *) "depth", NULL
4172 };
4173
4174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BitmapFromImage",kwnames,&obj0,&obj1)) goto fail;
4175 {
4176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
4177 if (SWIG_arg_fail(1)) SWIG_fail;
4178 if (arg1 == NULL) {
4179 SWIG_null_ref("wxImage");
4180 }
4181 if (SWIG_arg_fail(1)) SWIG_fail;
4182 }
4183 if (obj1) {
4184 {
4185 arg2 = (int)(SWIG_As_int(obj1));
4186 if (SWIG_arg_fail(2)) SWIG_fail;
4187 }
4188 }
4189 {
4190 if (!wxPyCheckForApp()) SWIG_fail;
4191 PyThreadState* __tstate = wxPyBeginAllowThreads();
4192 result = (wxBitmap *)new wxBitmap((wxImage const &)*arg1,arg2);
4193
4194 wxPyEndAllowThreads(__tstate);
4195 if (PyErr_Occurred()) SWIG_fail;
4196 }
4197 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4198 return resultobj;
4199 fail:
4200 return NULL;
4201 }
4202
4203
4204 static PyObject *_wrap_new_BitmapFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
4205 PyObject *resultobj;
4206 PyObject *arg1 = (PyObject *) 0 ;
4207 wxBitmap *result;
4208 PyObject * obj0 = 0 ;
4209 char *kwnames[] = {
4210 (char *) "listOfStrings", NULL
4211 };
4212
4213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromXPMData",kwnames,&obj0)) goto fail;
4214 arg1 = obj0;
4215 {
4216 if (!wxPyCheckForApp()) SWIG_fail;
4217 PyThreadState* __tstate = wxPyBeginAllowThreads();
4218 result = (wxBitmap *)new_wxBitmap(arg1);
4219
4220 wxPyEndAllowThreads(__tstate);
4221 if (PyErr_Occurred()) SWIG_fail;
4222 }
4223 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4224 return resultobj;
4225 fail:
4226 return NULL;
4227 }
4228
4229
4230 static PyObject *_wrap_new_BitmapFromBits(PyObject *, PyObject *args, PyObject *kwargs) {
4231 PyObject *resultobj;
4232 PyObject *arg1 = (PyObject *) 0 ;
4233 int arg2 ;
4234 int arg3 ;
4235 int arg4 = (int) 1 ;
4236 wxBitmap *result;
4237 PyObject * obj0 = 0 ;
4238 PyObject * obj1 = 0 ;
4239 PyObject * obj2 = 0 ;
4240 PyObject * obj3 = 0 ;
4241 char *kwnames[] = {
4242 (char *) "bits",(char *) "width",(char *) "height",(char *) "depth", NULL
4243 };
4244
4245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:new_BitmapFromBits",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4246 arg1 = obj0;
4247 {
4248 arg2 = (int)(SWIG_As_int(obj1));
4249 if (SWIG_arg_fail(2)) SWIG_fail;
4250 }
4251 {
4252 arg3 = (int)(SWIG_As_int(obj2));
4253 if (SWIG_arg_fail(3)) SWIG_fail;
4254 }
4255 if (obj3) {
4256 {
4257 arg4 = (int)(SWIG_As_int(obj3));
4258 if (SWIG_arg_fail(4)) SWIG_fail;
4259 }
4260 }
4261 {
4262 if (!wxPyCheckForApp()) SWIG_fail;
4263 PyThreadState* __tstate = wxPyBeginAllowThreads();
4264 result = (wxBitmap *)new_wxBitmap(arg1,arg2,arg3,arg4);
4265
4266 wxPyEndAllowThreads(__tstate);
4267 if (PyErr_Occurred()) SWIG_fail;
4268 }
4269 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4270 return resultobj;
4271 fail:
4272 return NULL;
4273 }
4274
4275
4276 static PyObject *_wrap_Bitmap_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
4277 PyObject *resultobj;
4278 wxBitmap *arg1 = (wxBitmap *) 0 ;
4279 long result;
4280 PyObject * obj0 = 0 ;
4281 char *kwnames[] = {
4282 (char *) "self", NULL
4283 };
4284
4285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetHandle",kwnames,&obj0)) goto fail;
4286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4287 if (SWIG_arg_fail(1)) SWIG_fail;
4288 {
4289 PyThreadState* __tstate = wxPyBeginAllowThreads();
4290 result = (long)(arg1)->GetHandle();
4291
4292 wxPyEndAllowThreads(__tstate);
4293 if (PyErr_Occurred()) SWIG_fail;
4294 }
4295 {
4296 resultobj = SWIG_From_long((long)(result));
4297 }
4298 return resultobj;
4299 fail:
4300 return NULL;
4301 }
4302
4303
4304 static PyObject *_wrap_Bitmap_SetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
4305 PyObject *resultobj;
4306 wxBitmap *arg1 = (wxBitmap *) 0 ;
4307 long arg2 ;
4308 PyObject * obj0 = 0 ;
4309 PyObject * obj1 = 0 ;
4310 char *kwnames[] = {
4311 (char *) "self",(char *) "handle", NULL
4312 };
4313
4314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetHandle",kwnames,&obj0,&obj1)) goto fail;
4315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4316 if (SWIG_arg_fail(1)) SWIG_fail;
4317 {
4318 arg2 = (long)(SWIG_As_long(obj1));
4319 if (SWIG_arg_fail(2)) SWIG_fail;
4320 }
4321 {
4322 PyThreadState* __tstate = wxPyBeginAllowThreads();
4323 wxBitmap_SetHandle(arg1,arg2);
4324
4325 wxPyEndAllowThreads(__tstate);
4326 if (PyErr_Occurred()) SWIG_fail;
4327 }
4328 Py_INCREF(Py_None); resultobj = Py_None;
4329 return resultobj;
4330 fail:
4331 return NULL;
4332 }
4333
4334
4335 static PyObject *_wrap_Bitmap_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
4336 PyObject *resultobj;
4337 wxBitmap *arg1 = (wxBitmap *) 0 ;
4338 bool result;
4339 PyObject * obj0 = 0 ;
4340 char *kwnames[] = {
4341 (char *) "self", NULL
4342 };
4343
4344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_Ok",kwnames,&obj0)) goto fail;
4345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4346 if (SWIG_arg_fail(1)) SWIG_fail;
4347 {
4348 PyThreadState* __tstate = wxPyBeginAllowThreads();
4349 result = (bool)(arg1)->Ok();
4350
4351 wxPyEndAllowThreads(__tstate);
4352 if (PyErr_Occurred()) SWIG_fail;
4353 }
4354 {
4355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4356 }
4357 return resultobj;
4358 fail:
4359 return NULL;
4360 }
4361
4362
4363 static PyObject *_wrap_Bitmap_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4364 PyObject *resultobj;
4365 wxBitmap *arg1 = (wxBitmap *) 0 ;
4366 int result;
4367 PyObject * obj0 = 0 ;
4368 char *kwnames[] = {
4369 (char *) "self", NULL
4370 };
4371
4372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetWidth",kwnames,&obj0)) goto fail;
4373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4374 if (SWIG_arg_fail(1)) SWIG_fail;
4375 {
4376 PyThreadState* __tstate = wxPyBeginAllowThreads();
4377 result = (int)(arg1)->GetWidth();
4378
4379 wxPyEndAllowThreads(__tstate);
4380 if (PyErr_Occurred()) SWIG_fail;
4381 }
4382 {
4383 resultobj = SWIG_From_int((int)(result));
4384 }
4385 return resultobj;
4386 fail:
4387 return NULL;
4388 }
4389
4390
4391 static PyObject *_wrap_Bitmap_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4392 PyObject *resultobj;
4393 wxBitmap *arg1 = (wxBitmap *) 0 ;
4394 int result;
4395 PyObject * obj0 = 0 ;
4396 char *kwnames[] = {
4397 (char *) "self", NULL
4398 };
4399
4400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetHeight",kwnames,&obj0)) goto fail;
4401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4402 if (SWIG_arg_fail(1)) SWIG_fail;
4403 {
4404 PyThreadState* __tstate = wxPyBeginAllowThreads();
4405 result = (int)(arg1)->GetHeight();
4406
4407 wxPyEndAllowThreads(__tstate);
4408 if (PyErr_Occurred()) SWIG_fail;
4409 }
4410 {
4411 resultobj = SWIG_From_int((int)(result));
4412 }
4413 return resultobj;
4414 fail:
4415 return NULL;
4416 }
4417
4418
4419 static PyObject *_wrap_Bitmap_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4420 PyObject *resultobj;
4421 wxBitmap *arg1 = (wxBitmap *) 0 ;
4422 int result;
4423 PyObject * obj0 = 0 ;
4424 char *kwnames[] = {
4425 (char *) "self", NULL
4426 };
4427
4428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetDepth",kwnames,&obj0)) goto fail;
4429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4430 if (SWIG_arg_fail(1)) SWIG_fail;
4431 {
4432 PyThreadState* __tstate = wxPyBeginAllowThreads();
4433 result = (int)(arg1)->GetDepth();
4434
4435 wxPyEndAllowThreads(__tstate);
4436 if (PyErr_Occurred()) SWIG_fail;
4437 }
4438 {
4439 resultobj = SWIG_From_int((int)(result));
4440 }
4441 return resultobj;
4442 fail:
4443 return NULL;
4444 }
4445
4446
4447 static PyObject *_wrap_Bitmap_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4448 PyObject *resultobj;
4449 wxBitmap *arg1 = (wxBitmap *) 0 ;
4450 wxSize result;
4451 PyObject * obj0 = 0 ;
4452 char *kwnames[] = {
4453 (char *) "self", NULL
4454 };
4455
4456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetSize",kwnames,&obj0)) goto fail;
4457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4458 if (SWIG_arg_fail(1)) SWIG_fail;
4459 {
4460 PyThreadState* __tstate = wxPyBeginAllowThreads();
4461 result = wxBitmap_GetSize(arg1);
4462
4463 wxPyEndAllowThreads(__tstate);
4464 if (PyErr_Occurred()) SWIG_fail;
4465 }
4466 {
4467 wxSize * resultptr;
4468 resultptr = new wxSize((wxSize &)(result));
4469 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
4470 }
4471 return resultobj;
4472 fail:
4473 return NULL;
4474 }
4475
4476
4477 static PyObject *_wrap_Bitmap_ConvertToImage(PyObject *, PyObject *args, PyObject *kwargs) {
4478 PyObject *resultobj;
4479 wxBitmap *arg1 = (wxBitmap *) 0 ;
4480 SwigValueWrapper<wxImage > result;
4481 PyObject * obj0 = 0 ;
4482 char *kwnames[] = {
4483 (char *) "self", NULL
4484 };
4485
4486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_ConvertToImage",kwnames,&obj0)) goto fail;
4487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4488 if (SWIG_arg_fail(1)) SWIG_fail;
4489 {
4490 PyThreadState* __tstate = wxPyBeginAllowThreads();
4491 result = ((wxBitmap const *)arg1)->ConvertToImage();
4492
4493 wxPyEndAllowThreads(__tstate);
4494 if (PyErr_Occurred()) SWIG_fail;
4495 }
4496 {
4497 wxImage * resultptr;
4498 resultptr = new wxImage((wxImage &)(result));
4499 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
4500 }
4501 return resultobj;
4502 fail:
4503 return NULL;
4504 }
4505
4506
4507 static PyObject *_wrap_Bitmap_GetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4508 PyObject *resultobj;
4509 wxBitmap *arg1 = (wxBitmap *) 0 ;
4510 wxMask *result;
4511 PyObject * obj0 = 0 ;
4512 char *kwnames[] = {
4513 (char *) "self", NULL
4514 };
4515
4516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetMask",kwnames,&obj0)) goto fail;
4517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4518 if (SWIG_arg_fail(1)) SWIG_fail;
4519 {
4520 PyThreadState* __tstate = wxPyBeginAllowThreads();
4521 result = (wxMask *)((wxBitmap const *)arg1)->GetMask();
4522
4523 wxPyEndAllowThreads(__tstate);
4524 if (PyErr_Occurred()) SWIG_fail;
4525 }
4526 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 0);
4527 return resultobj;
4528 fail:
4529 return NULL;
4530 }
4531
4532
4533 static PyObject *_wrap_Bitmap_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4534 PyObject *resultobj;
4535 wxBitmap *arg1 = (wxBitmap *) 0 ;
4536 wxMask *arg2 = (wxMask *) 0 ;
4537 PyObject * obj0 = 0 ;
4538 PyObject * obj1 = 0 ;
4539 char *kwnames[] = {
4540 (char *) "self",(char *) "mask", NULL
4541 };
4542
4543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMask",kwnames,&obj0,&obj1)) goto fail;
4544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4545 if (SWIG_arg_fail(1)) SWIG_fail;
4546 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMask, SWIG_POINTER_EXCEPTION | 0);
4547 if (SWIG_arg_fail(2)) SWIG_fail;
4548 {
4549 PyThreadState* __tstate = wxPyBeginAllowThreads();
4550 (arg1)->SetMask(arg2);
4551
4552 wxPyEndAllowThreads(__tstate);
4553 if (PyErr_Occurred()) SWIG_fail;
4554 }
4555 Py_INCREF(Py_None); resultobj = Py_None;
4556 return resultobj;
4557 fail:
4558 return NULL;
4559 }
4560
4561
4562 static PyObject *_wrap_Bitmap_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
4563 PyObject *resultobj;
4564 wxBitmap *arg1 = (wxBitmap *) 0 ;
4565 wxColour *arg2 = 0 ;
4566 wxColour temp2 ;
4567 PyObject * obj0 = 0 ;
4568 PyObject * obj1 = 0 ;
4569 char *kwnames[] = {
4570 (char *) "self",(char *) "colour", NULL
4571 };
4572
4573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMaskColour",kwnames,&obj0,&obj1)) goto fail;
4574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4575 if (SWIG_arg_fail(1)) SWIG_fail;
4576 {
4577 arg2 = &temp2;
4578 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4579 }
4580 {
4581 PyThreadState* __tstate = wxPyBeginAllowThreads();
4582 wxBitmap_SetMaskColour(arg1,(wxColour const &)*arg2);
4583
4584 wxPyEndAllowThreads(__tstate);
4585 if (PyErr_Occurred()) SWIG_fail;
4586 }
4587 Py_INCREF(Py_None); resultobj = Py_None;
4588 return resultobj;
4589 fail:
4590 return NULL;
4591 }
4592
4593
4594 static PyObject *_wrap_Bitmap_GetSubBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4595 PyObject *resultobj;
4596 wxBitmap *arg1 = (wxBitmap *) 0 ;
4597 wxRect *arg2 = 0 ;
4598 SwigValueWrapper<wxBitmap > result;
4599 wxRect temp2 ;
4600 PyObject * obj0 = 0 ;
4601 PyObject * obj1 = 0 ;
4602 char *kwnames[] = {
4603 (char *) "self",(char *) "rect", NULL
4604 };
4605
4606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_GetSubBitmap",kwnames,&obj0,&obj1)) goto fail;
4607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4608 if (SWIG_arg_fail(1)) SWIG_fail;
4609 {
4610 arg2 = &temp2;
4611 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4612 }
4613 {
4614 PyThreadState* __tstate = wxPyBeginAllowThreads();
4615 result = ((wxBitmap const *)arg1)->GetSubBitmap((wxRect const &)*arg2);
4616
4617 wxPyEndAllowThreads(__tstate);
4618 if (PyErr_Occurred()) SWIG_fail;
4619 }
4620 {
4621 wxBitmap * resultptr;
4622 resultptr = new wxBitmap((wxBitmap &)(result));
4623 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
4624 }
4625 return resultobj;
4626 fail:
4627 return NULL;
4628 }
4629
4630
4631 static PyObject *_wrap_Bitmap_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
4632 PyObject *resultobj;
4633 wxBitmap *arg1 = (wxBitmap *) 0 ;
4634 wxString *arg2 = 0 ;
4635 wxBitmapType arg3 ;
4636 wxPalette *arg4 = (wxPalette *) NULL ;
4637 bool result;
4638 bool temp2 = false ;
4639 PyObject * obj0 = 0 ;
4640 PyObject * obj1 = 0 ;
4641 PyObject * obj2 = 0 ;
4642 PyObject * obj3 = 0 ;
4643 char *kwnames[] = {
4644 (char *) "self",(char *) "name",(char *) "type",(char *) "palette", NULL
4645 };
4646
4647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Bitmap_SaveFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4649 if (SWIG_arg_fail(1)) SWIG_fail;
4650 {
4651 arg2 = wxString_in_helper(obj1);
4652 if (arg2 == NULL) SWIG_fail;
4653 temp2 = true;
4654 }
4655 {
4656 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4657 if (SWIG_arg_fail(3)) SWIG_fail;
4658 }
4659 if (obj3) {
4660 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
4661 if (SWIG_arg_fail(4)) SWIG_fail;
4662 }
4663 {
4664 PyThreadState* __tstate = wxPyBeginAllowThreads();
4665 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxBitmapType )arg3,arg4);
4666
4667 wxPyEndAllowThreads(__tstate);
4668 if (PyErr_Occurred()) SWIG_fail;
4669 }
4670 {
4671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4672 }
4673 {
4674 if (temp2)
4675 delete arg2;
4676 }
4677 return resultobj;
4678 fail:
4679 {
4680 if (temp2)
4681 delete arg2;
4682 }
4683 return NULL;
4684 }
4685
4686
4687 static PyObject *_wrap_Bitmap_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
4688 PyObject *resultobj;
4689 wxBitmap *arg1 = (wxBitmap *) 0 ;
4690 wxString *arg2 = 0 ;
4691 wxBitmapType arg3 ;
4692 bool result;
4693 bool temp2 = false ;
4694 PyObject * obj0 = 0 ;
4695 PyObject * obj1 = 0 ;
4696 PyObject * obj2 = 0 ;
4697 char *kwnames[] = {
4698 (char *) "self",(char *) "name",(char *) "type", NULL
4699 };
4700
4701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Bitmap_LoadFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
4702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4703 if (SWIG_arg_fail(1)) SWIG_fail;
4704 {
4705 arg2 = wxString_in_helper(obj1);
4706 if (arg2 == NULL) SWIG_fail;
4707 temp2 = true;
4708 }
4709 {
4710 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4711 if (SWIG_arg_fail(3)) SWIG_fail;
4712 }
4713 {
4714 PyThreadState* __tstate = wxPyBeginAllowThreads();
4715 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxBitmapType )arg3);
4716
4717 wxPyEndAllowThreads(__tstate);
4718 if (PyErr_Occurred()) SWIG_fail;
4719 }
4720 {
4721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4722 }
4723 {
4724 if (temp2)
4725 delete arg2;
4726 }
4727 return resultobj;
4728 fail:
4729 {
4730 if (temp2)
4731 delete arg2;
4732 }
4733 return NULL;
4734 }
4735
4736
4737 static PyObject *_wrap_Bitmap_GetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
4738 PyObject *resultobj;
4739 wxBitmap *arg1 = (wxBitmap *) 0 ;
4740 wxPalette *result;
4741 PyObject * obj0 = 0 ;
4742 char *kwnames[] = {
4743 (char *) "self", NULL
4744 };
4745
4746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetPalette",kwnames,&obj0)) goto fail;
4747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4748 if (SWIG_arg_fail(1)) SWIG_fail;
4749 {
4750 PyThreadState* __tstate = wxPyBeginAllowThreads();
4751 result = (wxPalette *)((wxBitmap const *)arg1)->GetPalette();
4752
4753 wxPyEndAllowThreads(__tstate);
4754 if (PyErr_Occurred()) SWIG_fail;
4755 }
4756 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 0);
4757 return resultobj;
4758 fail:
4759 return NULL;
4760 }
4761
4762
4763 static PyObject *_wrap_Bitmap_SetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
4764 PyObject *resultobj;
4765 wxBitmap *arg1 = (wxBitmap *) 0 ;
4766 wxPalette *arg2 = 0 ;
4767 PyObject * obj0 = 0 ;
4768 PyObject * obj1 = 0 ;
4769 char *kwnames[] = {
4770 (char *) "self",(char *) "palette", NULL
4771 };
4772
4773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetPalette",kwnames,&obj0,&obj1)) goto fail;
4774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4775 if (SWIG_arg_fail(1)) SWIG_fail;
4776 {
4777 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
4778 if (SWIG_arg_fail(2)) SWIG_fail;
4779 if (arg2 == NULL) {
4780 SWIG_null_ref("wxPalette");
4781 }
4782 if (SWIG_arg_fail(2)) SWIG_fail;
4783 }
4784 {
4785 PyThreadState* __tstate = wxPyBeginAllowThreads();
4786 (arg1)->SetPalette((wxPalette const &)*arg2);
4787
4788 wxPyEndAllowThreads(__tstate);
4789 if (PyErr_Occurred()) SWIG_fail;
4790 }
4791 Py_INCREF(Py_None); resultobj = Py_None;
4792 return resultobj;
4793 fail:
4794 return NULL;
4795 }
4796
4797
4798 static PyObject *_wrap_Bitmap_CopyFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4799 PyObject *resultobj;
4800 wxBitmap *arg1 = (wxBitmap *) 0 ;
4801 wxIcon *arg2 = 0 ;
4802 bool result;
4803 PyObject * obj0 = 0 ;
4804 PyObject * obj1 = 0 ;
4805 char *kwnames[] = {
4806 (char *) "self",(char *) "icon", NULL
4807 };
4808
4809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_CopyFromIcon",kwnames,&obj0,&obj1)) goto fail;
4810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4811 if (SWIG_arg_fail(1)) SWIG_fail;
4812 {
4813 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4814 if (SWIG_arg_fail(2)) SWIG_fail;
4815 if (arg2 == NULL) {
4816 SWIG_null_ref("wxIcon");
4817 }
4818 if (SWIG_arg_fail(2)) SWIG_fail;
4819 }
4820 {
4821 PyThreadState* __tstate = wxPyBeginAllowThreads();
4822 result = (bool)(arg1)->CopyFromIcon((wxIcon const &)*arg2);
4823
4824 wxPyEndAllowThreads(__tstate);
4825 if (PyErr_Occurred()) SWIG_fail;
4826 }
4827 {
4828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4829 }
4830 return resultobj;
4831 fail:
4832 return NULL;
4833 }
4834
4835
4836 static PyObject *_wrap_Bitmap_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4837 PyObject *resultobj;
4838 wxBitmap *arg1 = (wxBitmap *) 0 ;
4839 int arg2 ;
4840 PyObject * obj0 = 0 ;
4841 PyObject * obj1 = 0 ;
4842 char *kwnames[] = {
4843 (char *) "self",(char *) "height", NULL
4844 };
4845
4846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetHeight",kwnames,&obj0,&obj1)) goto fail;
4847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4848 if (SWIG_arg_fail(1)) SWIG_fail;
4849 {
4850 arg2 = (int)(SWIG_As_int(obj1));
4851 if (SWIG_arg_fail(2)) SWIG_fail;
4852 }
4853 {
4854 PyThreadState* __tstate = wxPyBeginAllowThreads();
4855 (arg1)->SetHeight(arg2);
4856
4857 wxPyEndAllowThreads(__tstate);
4858 if (PyErr_Occurred()) SWIG_fail;
4859 }
4860 Py_INCREF(Py_None); resultobj = Py_None;
4861 return resultobj;
4862 fail:
4863 return NULL;
4864 }
4865
4866
4867 static PyObject *_wrap_Bitmap_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4868 PyObject *resultobj;
4869 wxBitmap *arg1 = (wxBitmap *) 0 ;
4870 int arg2 ;
4871 PyObject * obj0 = 0 ;
4872 PyObject * obj1 = 0 ;
4873 char *kwnames[] = {
4874 (char *) "self",(char *) "width", NULL
4875 };
4876
4877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetWidth",kwnames,&obj0,&obj1)) goto fail;
4878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4879 if (SWIG_arg_fail(1)) SWIG_fail;
4880 {
4881 arg2 = (int)(SWIG_As_int(obj1));
4882 if (SWIG_arg_fail(2)) SWIG_fail;
4883 }
4884 {
4885 PyThreadState* __tstate = wxPyBeginAllowThreads();
4886 (arg1)->SetWidth(arg2);
4887
4888 wxPyEndAllowThreads(__tstate);
4889 if (PyErr_Occurred()) SWIG_fail;
4890 }
4891 Py_INCREF(Py_None); resultobj = Py_None;
4892 return resultobj;
4893 fail:
4894 return NULL;
4895 }
4896
4897
4898 static PyObject *_wrap_Bitmap_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4899 PyObject *resultobj;
4900 wxBitmap *arg1 = (wxBitmap *) 0 ;
4901 int arg2 ;
4902 PyObject * obj0 = 0 ;
4903 PyObject * obj1 = 0 ;
4904 char *kwnames[] = {
4905 (char *) "self",(char *) "depth", NULL
4906 };
4907
4908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetDepth",kwnames,&obj0,&obj1)) goto fail;
4909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4910 if (SWIG_arg_fail(1)) SWIG_fail;
4911 {
4912 arg2 = (int)(SWIG_As_int(obj1));
4913 if (SWIG_arg_fail(2)) SWIG_fail;
4914 }
4915 {
4916 PyThreadState* __tstate = wxPyBeginAllowThreads();
4917 (arg1)->SetDepth(arg2);
4918
4919 wxPyEndAllowThreads(__tstate);
4920 if (PyErr_Occurred()) SWIG_fail;
4921 }
4922 Py_INCREF(Py_None); resultobj = Py_None;
4923 return resultobj;
4924 fail:
4925 return NULL;
4926 }
4927
4928
4929 static PyObject *_wrap_Bitmap_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4930 PyObject *resultobj;
4931 wxBitmap *arg1 = (wxBitmap *) 0 ;
4932 wxSize *arg2 = 0 ;
4933 wxSize temp2 ;
4934 PyObject * obj0 = 0 ;
4935 PyObject * obj1 = 0 ;
4936 char *kwnames[] = {
4937 (char *) "self",(char *) "size", NULL
4938 };
4939
4940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetSize",kwnames,&obj0,&obj1)) goto fail;
4941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4942 if (SWIG_arg_fail(1)) SWIG_fail;
4943 {
4944 arg2 = &temp2;
4945 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4946 }
4947 {
4948 PyThreadState* __tstate = wxPyBeginAllowThreads();
4949 wxBitmap_SetSize(arg1,(wxSize const &)*arg2);
4950
4951 wxPyEndAllowThreads(__tstate);
4952 if (PyErr_Occurred()) SWIG_fail;
4953 }
4954 Py_INCREF(Py_None); resultobj = Py_None;
4955 return resultobj;
4956 fail:
4957 return NULL;
4958 }
4959
4960
4961 static PyObject *_wrap_Bitmap_CopyFromCursor(PyObject *, PyObject *args, PyObject *kwargs) {
4962 PyObject *resultobj;
4963 wxBitmap *arg1 = (wxBitmap *) 0 ;
4964 wxCursor *arg2 = 0 ;
4965 bool result;
4966 PyObject * obj0 = 0 ;
4967 PyObject * obj1 = 0 ;
4968 char *kwnames[] = {
4969 (char *) "self",(char *) "cursor", NULL
4970 };
4971
4972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_CopyFromCursor",kwnames,&obj0,&obj1)) goto fail;
4973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4974 if (SWIG_arg_fail(1)) SWIG_fail;
4975 {
4976 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
4977 if (SWIG_arg_fail(2)) SWIG_fail;
4978 if (arg2 == NULL) {
4979 SWIG_null_ref("wxCursor");
4980 }
4981 if (SWIG_arg_fail(2)) SWIG_fail;
4982 }
4983 {
4984 PyThreadState* __tstate = wxPyBeginAllowThreads();
4985 result = (bool)(arg1)->CopyFromCursor((wxCursor const &)*arg2);
4986
4987 wxPyEndAllowThreads(__tstate);
4988 if (PyErr_Occurred()) SWIG_fail;
4989 }
4990 {
4991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4992 }
4993 return resultobj;
4994 fail:
4995 return NULL;
4996 }
4997
4998
4999 static PyObject *_wrap_Bitmap_GetQuality(PyObject *, PyObject *args, PyObject *kwargs) {
5000 PyObject *resultobj;
5001 wxBitmap *arg1 = (wxBitmap *) 0 ;
5002 int result;
5003 PyObject * obj0 = 0 ;
5004 char *kwnames[] = {
5005 (char *) "self", NULL
5006 };
5007
5008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetQuality",kwnames,&obj0)) goto fail;
5009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5010 if (SWIG_arg_fail(1)) SWIG_fail;
5011 {
5012 PyThreadState* __tstate = wxPyBeginAllowThreads();
5013 result = (int)(arg1)->GetQuality();
5014
5015 wxPyEndAllowThreads(__tstate);
5016 if (PyErr_Occurred()) SWIG_fail;
5017 }
5018 {
5019 resultobj = SWIG_From_int((int)(result));
5020 }
5021 return resultobj;
5022 fail:
5023 return NULL;
5024 }
5025
5026
5027 static PyObject *_wrap_Bitmap_SetQuality(PyObject *, PyObject *args, PyObject *kwargs) {
5028 PyObject *resultobj;
5029 wxBitmap *arg1 = (wxBitmap *) 0 ;
5030 int arg2 ;
5031 PyObject * obj0 = 0 ;
5032 PyObject * obj1 = 0 ;
5033 char *kwnames[] = {
5034 (char *) "self",(char *) "q", NULL
5035 };
5036
5037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetQuality",kwnames,&obj0,&obj1)) goto fail;
5038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5039 if (SWIG_arg_fail(1)) SWIG_fail;
5040 {
5041 arg2 = (int)(SWIG_As_int(obj1));
5042 if (SWIG_arg_fail(2)) SWIG_fail;
5043 }
5044 {
5045 PyThreadState* __tstate = wxPyBeginAllowThreads();
5046 (arg1)->SetQuality(arg2);
5047
5048 wxPyEndAllowThreads(__tstate);
5049 if (PyErr_Occurred()) SWIG_fail;
5050 }
5051 Py_INCREF(Py_None); resultobj = Py_None;
5052 return resultobj;
5053 fail:
5054 return NULL;
5055 }
5056
5057
5058 static PyObject *_wrap_Bitmap___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
5059 PyObject *resultobj;
5060 wxBitmap *arg1 = (wxBitmap *) 0 ;
5061 wxBitmap *arg2 = (wxBitmap *) 0 ;
5062 bool result;
5063 PyObject * obj0 = 0 ;
5064 PyObject * obj1 = 0 ;
5065 char *kwnames[] = {
5066 (char *) "self",(char *) "other", NULL
5067 };
5068
5069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___eq__",kwnames,&obj0,&obj1)) goto fail;
5070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5071 if (SWIG_arg_fail(1)) SWIG_fail;
5072 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5073 if (SWIG_arg_fail(2)) SWIG_fail;
5074 {
5075 PyThreadState* __tstate = wxPyBeginAllowThreads();
5076 result = (bool)wxBitmap___eq__(arg1,(wxBitmap const *)arg2);
5077
5078 wxPyEndAllowThreads(__tstate);
5079 if (PyErr_Occurred()) SWIG_fail;
5080 }
5081 {
5082 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5083 }
5084 return resultobj;
5085 fail:
5086 return NULL;
5087 }
5088
5089
5090 static PyObject *_wrap_Bitmap___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
5091 PyObject *resultobj;
5092 wxBitmap *arg1 = (wxBitmap *) 0 ;
5093 wxBitmap *arg2 = (wxBitmap *) 0 ;
5094 bool result;
5095 PyObject * obj0 = 0 ;
5096 PyObject * obj1 = 0 ;
5097 char *kwnames[] = {
5098 (char *) "self",(char *) "other", NULL
5099 };
5100
5101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___ne__",kwnames,&obj0,&obj1)) goto fail;
5102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5103 if (SWIG_arg_fail(1)) SWIG_fail;
5104 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5105 if (SWIG_arg_fail(2)) SWIG_fail;
5106 {
5107 PyThreadState* __tstate = wxPyBeginAllowThreads();
5108 result = (bool)wxBitmap___ne__(arg1,(wxBitmap const *)arg2);
5109
5110 wxPyEndAllowThreads(__tstate);
5111 if (PyErr_Occurred()) SWIG_fail;
5112 }
5113 {
5114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5115 }
5116 return resultobj;
5117 fail:
5118 return NULL;
5119 }
5120
5121
5122 static PyObject * Bitmap_swigregister(PyObject *, PyObject *args) {
5123 PyObject *obj;
5124 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5125 SWIG_TypeClientData(SWIGTYPE_p_wxBitmap, obj);
5126 Py_INCREF(obj);
5127 return Py_BuildValue((char *)"");
5128 }
5129 static PyObject *_wrap_new_Mask(PyObject *, PyObject *args, PyObject *kwargs) {
5130 PyObject *resultobj;
5131 wxBitmap *arg1 = 0 ;
5132 wxColour const &arg2_defvalue = wxNullColour ;
5133 wxColour *arg2 = (wxColour *) &arg2_defvalue ;
5134 wxMask *result;
5135 wxColour temp2 ;
5136 PyObject * obj0 = 0 ;
5137 PyObject * obj1 = 0 ;
5138 char *kwnames[] = {
5139 (char *) "bitmap",(char *) "colour", NULL
5140 };
5141
5142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Mask",kwnames,&obj0,&obj1)) goto fail;
5143 {
5144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5145 if (SWIG_arg_fail(1)) SWIG_fail;
5146 if (arg1 == NULL) {
5147 SWIG_null_ref("wxBitmap");
5148 }
5149 if (SWIG_arg_fail(1)) SWIG_fail;
5150 }
5151 if (obj1) {
5152 {
5153 arg2 = &temp2;
5154 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
5155 }
5156 }
5157 {
5158 if (!wxPyCheckForApp()) SWIG_fail;
5159 PyThreadState* __tstate = wxPyBeginAllowThreads();
5160 result = (wxMask *)new_wxMask((wxBitmap const &)*arg1,(wxColour const &)*arg2);
5161
5162 wxPyEndAllowThreads(__tstate);
5163 if (PyErr_Occurred()) SWIG_fail;
5164 }
5165 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 1);
5166 return resultobj;
5167 fail:
5168 return NULL;
5169 }
5170
5171
5172 static PyObject * Mask_swigregister(PyObject *, PyObject *args) {
5173 PyObject *obj;
5174 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5175 SWIG_TypeClientData(SWIGTYPE_p_wxMask, obj);
5176 Py_INCREF(obj);
5177 return Py_BuildValue((char *)"");
5178 }
5179 static PyObject *_wrap_new_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
5180 PyObject *resultobj;
5181 wxString *arg1 = 0 ;
5182 wxBitmapType arg2 ;
5183 int arg3 = (int) -1 ;
5184 int arg4 = (int) -1 ;
5185 wxIcon *result;
5186 bool temp1 = false ;
5187 PyObject * obj0 = 0 ;
5188 PyObject * obj1 = 0 ;
5189 PyObject * obj2 = 0 ;
5190 PyObject * obj3 = 0 ;
5191 char *kwnames[] = {
5192 (char *) "name",(char *) "type",(char *) "desiredWidth",(char *) "desiredHeight", NULL
5193 };
5194
5195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Icon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5196 {
5197 arg1 = wxString_in_helper(obj0);
5198 if (arg1 == NULL) SWIG_fail;
5199 temp1 = true;
5200 }
5201 {
5202 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
5203 if (SWIG_arg_fail(2)) SWIG_fail;
5204 }
5205 if (obj2) {
5206 {
5207 arg3 = (int)(SWIG_As_int(obj2));
5208 if (SWIG_arg_fail(3)) SWIG_fail;
5209 }
5210 }
5211 if (obj3) {
5212 {
5213 arg4 = (int)(SWIG_As_int(obj3));
5214 if (SWIG_arg_fail(4)) SWIG_fail;
5215 }
5216 }
5217 {
5218 if (!wxPyCheckForApp()) SWIG_fail;
5219 PyThreadState* __tstate = wxPyBeginAllowThreads();
5220 result = (wxIcon *)new wxIcon((wxString const &)*arg1,(wxBitmapType )arg2,arg3,arg4);
5221
5222 wxPyEndAllowThreads(__tstate);
5223 if (PyErr_Occurred()) SWIG_fail;
5224 }
5225 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5226 {
5227 if (temp1)
5228 delete arg1;
5229 }
5230 return resultobj;
5231 fail:
5232 {
5233 if (temp1)
5234 delete arg1;
5235 }
5236 return NULL;
5237 }
5238
5239
5240 static PyObject *_wrap_delete_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
5241 PyObject *resultobj;
5242 wxIcon *arg1 = (wxIcon *) 0 ;
5243 PyObject * obj0 = 0 ;
5244 char *kwnames[] = {
5245 (char *) "self", NULL
5246 };
5247
5248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Icon",kwnames,&obj0)) goto fail;
5249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5250 if (SWIG_arg_fail(1)) SWIG_fail;
5251 {
5252 PyThreadState* __tstate = wxPyBeginAllowThreads();
5253 delete arg1;
5254
5255 wxPyEndAllowThreads(__tstate);
5256 if (PyErr_Occurred()) SWIG_fail;
5257 }
5258 Py_INCREF(Py_None); resultobj = Py_None;
5259 return resultobj;
5260 fail:
5261 return NULL;
5262 }
5263
5264
5265 static PyObject *_wrap_new_EmptyIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5266 PyObject *resultobj;
5267 wxIcon *result;
5268 char *kwnames[] = {
5269 NULL
5270 };
5271
5272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EmptyIcon",kwnames)) goto fail;
5273 {
5274 if (!wxPyCheckForApp()) SWIG_fail;
5275 PyThreadState* __tstate = wxPyBeginAllowThreads();
5276 result = (wxIcon *)new wxIcon();
5277
5278 wxPyEndAllowThreads(__tstate);
5279 if (PyErr_Occurred()) SWIG_fail;
5280 }
5281 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5282 return resultobj;
5283 fail:
5284 return NULL;
5285 }
5286
5287
5288 static PyObject *_wrap_new_IconFromLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5289 PyObject *resultobj;
5290 wxIconLocation *arg1 = 0 ;
5291 wxIcon *result;
5292 PyObject * obj0 = 0 ;
5293 char *kwnames[] = {
5294 (char *) "loc", NULL
5295 };
5296
5297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromLocation",kwnames,&obj0)) goto fail;
5298 {
5299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5300 if (SWIG_arg_fail(1)) SWIG_fail;
5301 if (arg1 == NULL) {
5302 SWIG_null_ref("wxIconLocation");
5303 }
5304 if (SWIG_arg_fail(1)) SWIG_fail;
5305 }
5306 {
5307 if (!wxPyCheckForApp()) SWIG_fail;
5308 PyThreadState* __tstate = wxPyBeginAllowThreads();
5309 result = (wxIcon *)new wxIcon((wxIconLocation const &)*arg1);
5310
5311 wxPyEndAllowThreads(__tstate);
5312 if (PyErr_Occurred()) SWIG_fail;
5313 }
5314 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5315 return resultobj;
5316 fail:
5317 return NULL;
5318 }
5319
5320
5321 static PyObject *_wrap_new_IconFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5322 PyObject *resultobj;
5323 wxBitmap *arg1 = 0 ;
5324 wxIcon *result;
5325 PyObject * obj0 = 0 ;
5326 char *kwnames[] = {
5327 (char *) "bmp", NULL
5328 };
5329
5330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromBitmap",kwnames,&obj0)) goto fail;
5331 {
5332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5333 if (SWIG_arg_fail(1)) SWIG_fail;
5334 if (arg1 == NULL) {
5335 SWIG_null_ref("wxBitmap");
5336 }
5337 if (SWIG_arg_fail(1)) SWIG_fail;
5338 }
5339 {
5340 if (!wxPyCheckForApp()) SWIG_fail;
5341 PyThreadState* __tstate = wxPyBeginAllowThreads();
5342 result = (wxIcon *)new_wxIcon((wxBitmap const &)*arg1);
5343
5344 wxPyEndAllowThreads(__tstate);
5345 if (PyErr_Occurred()) SWIG_fail;
5346 }
5347 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5348 return resultobj;
5349 fail:
5350 return NULL;
5351 }
5352
5353
5354 static PyObject *_wrap_new_IconFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
5355 PyObject *resultobj;
5356 PyObject *arg1 = (PyObject *) 0 ;
5357 wxIcon *result;
5358 PyObject * obj0 = 0 ;
5359 char *kwnames[] = {
5360 (char *) "listOfStrings", NULL
5361 };
5362
5363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromXPMData",kwnames,&obj0)) goto fail;
5364 arg1 = obj0;
5365 {
5366 if (!wxPyCheckForApp()) SWIG_fail;
5367 PyThreadState* __tstate = wxPyBeginAllowThreads();
5368 result = (wxIcon *)new_wxIcon(arg1);
5369
5370 wxPyEndAllowThreads(__tstate);
5371 if (PyErr_Occurred()) SWIG_fail;
5372 }
5373 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5374 return resultobj;
5375 fail:
5376 return NULL;
5377 }
5378
5379
5380 static PyObject *_wrap_Icon_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
5381 PyObject *resultobj;
5382 wxIcon *arg1 = (wxIcon *) 0 ;
5383 wxString *arg2 = 0 ;
5384 wxBitmapType arg3 ;
5385 bool result;
5386 bool temp2 = false ;
5387 PyObject * obj0 = 0 ;
5388 PyObject * obj1 = 0 ;
5389 PyObject * obj2 = 0 ;
5390 char *kwnames[] = {
5391 (char *) "self",(char *) "name",(char *) "type", NULL
5392 };
5393
5394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Icon_LoadFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
5395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5396 if (SWIG_arg_fail(1)) SWIG_fail;
5397 {
5398 arg2 = wxString_in_helper(obj1);
5399 if (arg2 == NULL) SWIG_fail;
5400 temp2 = true;
5401 }
5402 {
5403 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
5404 if (SWIG_arg_fail(3)) SWIG_fail;
5405 }
5406 {
5407 PyThreadState* __tstate = wxPyBeginAllowThreads();
5408 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxBitmapType )arg3);
5409
5410 wxPyEndAllowThreads(__tstate);
5411 if (PyErr_Occurred()) SWIG_fail;
5412 }
5413 {
5414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5415 }
5416 {
5417 if (temp2)
5418 delete arg2;
5419 }
5420 return resultobj;
5421 fail:
5422 {
5423 if (temp2)
5424 delete arg2;
5425 }
5426 return NULL;
5427 }
5428
5429
5430 static PyObject *_wrap_Icon_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
5431 PyObject *resultobj;
5432 wxIcon *arg1 = (wxIcon *) 0 ;
5433 long result;
5434 PyObject * obj0 = 0 ;
5435 char *kwnames[] = {
5436 (char *) "self", NULL
5437 };
5438
5439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetHandle",kwnames,&obj0)) goto fail;
5440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5441 if (SWIG_arg_fail(1)) SWIG_fail;
5442 {
5443 PyThreadState* __tstate = wxPyBeginAllowThreads();
5444 result = (long)(arg1)->GetHandle();
5445
5446 wxPyEndAllowThreads(__tstate);
5447 if (PyErr_Occurred()) SWIG_fail;
5448 }
5449 {
5450 resultobj = SWIG_From_long((long)(result));
5451 }
5452 return resultobj;
5453 fail:
5454 return NULL;
5455 }
5456
5457
5458 static PyObject *_wrap_Icon_SetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
5459 PyObject *resultobj;
5460 wxIcon *arg1 = (wxIcon *) 0 ;
5461 long arg2 ;
5462 PyObject * obj0 = 0 ;
5463 PyObject * obj1 = 0 ;
5464 char *kwnames[] = {
5465 (char *) "self",(char *) "handle", NULL
5466 };
5467
5468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetHandle",kwnames,&obj0,&obj1)) goto fail;
5469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5470 if (SWIG_arg_fail(1)) SWIG_fail;
5471 {
5472 arg2 = (long)(SWIG_As_long(obj1));
5473 if (SWIG_arg_fail(2)) SWIG_fail;
5474 }
5475 {
5476 PyThreadState* __tstate = wxPyBeginAllowThreads();
5477 wxIcon_SetHandle(arg1,arg2);
5478
5479 wxPyEndAllowThreads(__tstate);
5480 if (PyErr_Occurred()) SWIG_fail;
5481 }
5482 Py_INCREF(Py_None); resultobj = Py_None;
5483 return resultobj;
5484 fail:
5485 return NULL;
5486 }
5487
5488
5489 static PyObject *_wrap_Icon_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
5490 PyObject *resultobj;
5491 wxIcon *arg1 = (wxIcon *) 0 ;
5492 bool result;
5493 PyObject * obj0 = 0 ;
5494 char *kwnames[] = {
5495 (char *) "self", NULL
5496 };
5497
5498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_Ok",kwnames,&obj0)) goto fail;
5499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5500 if (SWIG_arg_fail(1)) SWIG_fail;
5501 {
5502 PyThreadState* __tstate = wxPyBeginAllowThreads();
5503 result = (bool)(arg1)->Ok();
5504
5505 wxPyEndAllowThreads(__tstate);
5506 if (PyErr_Occurred()) SWIG_fail;
5507 }
5508 {
5509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5510 }
5511 return resultobj;
5512 fail:
5513 return NULL;
5514 }
5515
5516
5517 static PyObject *_wrap_Icon_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5518 PyObject *resultobj;
5519 wxIcon *arg1 = (wxIcon *) 0 ;
5520 int result;
5521 PyObject * obj0 = 0 ;
5522 char *kwnames[] = {
5523 (char *) "self", NULL
5524 };
5525
5526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetWidth",kwnames,&obj0)) goto fail;
5527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5528 if (SWIG_arg_fail(1)) SWIG_fail;
5529 {
5530 PyThreadState* __tstate = wxPyBeginAllowThreads();
5531 result = (int)(arg1)->GetWidth();
5532
5533 wxPyEndAllowThreads(__tstate);
5534 if (PyErr_Occurred()) SWIG_fail;
5535 }
5536 {
5537 resultobj = SWIG_From_int((int)(result));
5538 }
5539 return resultobj;
5540 fail:
5541 return NULL;
5542 }
5543
5544
5545 static PyObject *_wrap_Icon_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5546 PyObject *resultobj;
5547 wxIcon *arg1 = (wxIcon *) 0 ;
5548 int result;
5549 PyObject * obj0 = 0 ;
5550 char *kwnames[] = {
5551 (char *) "self", NULL
5552 };
5553
5554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetHeight",kwnames,&obj0)) goto fail;
5555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5556 if (SWIG_arg_fail(1)) SWIG_fail;
5557 {
5558 PyThreadState* __tstate = wxPyBeginAllowThreads();
5559 result = (int)(arg1)->GetHeight();
5560
5561 wxPyEndAllowThreads(__tstate);
5562 if (PyErr_Occurred()) SWIG_fail;
5563 }
5564 {
5565 resultobj = SWIG_From_int((int)(result));
5566 }
5567 return resultobj;
5568 fail:
5569 return NULL;
5570 }
5571
5572
5573 static PyObject *_wrap_Icon_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5574 PyObject *resultobj;
5575 wxIcon *arg1 = (wxIcon *) 0 ;
5576 int result;
5577 PyObject * obj0 = 0 ;
5578 char *kwnames[] = {
5579 (char *) "self", NULL
5580 };
5581
5582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetDepth",kwnames,&obj0)) goto fail;
5583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5584 if (SWIG_arg_fail(1)) SWIG_fail;
5585 {
5586 PyThreadState* __tstate = wxPyBeginAllowThreads();
5587 result = (int)(arg1)->GetDepth();
5588
5589 wxPyEndAllowThreads(__tstate);
5590 if (PyErr_Occurred()) SWIG_fail;
5591 }
5592 {
5593 resultobj = SWIG_From_int((int)(result));
5594 }
5595 return resultobj;
5596 fail:
5597 return NULL;
5598 }
5599
5600
5601 static PyObject *_wrap_Icon_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5602 PyObject *resultobj;
5603 wxIcon *arg1 = (wxIcon *) 0 ;
5604 int arg2 ;
5605 PyObject * obj0 = 0 ;
5606 PyObject * obj1 = 0 ;
5607 char *kwnames[] = {
5608 (char *) "self",(char *) "w", NULL
5609 };
5610
5611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5613 if (SWIG_arg_fail(1)) SWIG_fail;
5614 {
5615 arg2 = (int)(SWIG_As_int(obj1));
5616 if (SWIG_arg_fail(2)) SWIG_fail;
5617 }
5618 {
5619 PyThreadState* __tstate = wxPyBeginAllowThreads();
5620 (arg1)->SetWidth(arg2);
5621
5622 wxPyEndAllowThreads(__tstate);
5623 if (PyErr_Occurred()) SWIG_fail;
5624 }
5625 Py_INCREF(Py_None); resultobj = Py_None;
5626 return resultobj;
5627 fail:
5628 return NULL;
5629 }
5630
5631
5632 static PyObject *_wrap_Icon_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5633 PyObject *resultobj;
5634 wxIcon *arg1 = (wxIcon *) 0 ;
5635 int arg2 ;
5636 PyObject * obj0 = 0 ;
5637 PyObject * obj1 = 0 ;
5638 char *kwnames[] = {
5639 (char *) "self",(char *) "h", NULL
5640 };
5641
5642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5644 if (SWIG_arg_fail(1)) SWIG_fail;
5645 {
5646 arg2 = (int)(SWIG_As_int(obj1));
5647 if (SWIG_arg_fail(2)) SWIG_fail;
5648 }
5649 {
5650 PyThreadState* __tstate = wxPyBeginAllowThreads();
5651 (arg1)->SetHeight(arg2);
5652
5653 wxPyEndAllowThreads(__tstate);
5654 if (PyErr_Occurred()) SWIG_fail;
5655 }
5656 Py_INCREF(Py_None); resultobj = Py_None;
5657 return resultobj;
5658 fail:
5659 return NULL;
5660 }
5661
5662
5663 static PyObject *_wrap_Icon_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5664 PyObject *resultobj;
5665 wxIcon *arg1 = (wxIcon *) 0 ;
5666 int arg2 ;
5667 PyObject * obj0 = 0 ;
5668 PyObject * obj1 = 0 ;
5669 char *kwnames[] = {
5670 (char *) "self",(char *) "d", NULL
5671 };
5672
5673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetDepth",kwnames,&obj0,&obj1)) goto fail;
5674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5675 if (SWIG_arg_fail(1)) SWIG_fail;
5676 {
5677 arg2 = (int)(SWIG_As_int(obj1));
5678 if (SWIG_arg_fail(2)) SWIG_fail;
5679 }
5680 {
5681 PyThreadState* __tstate = wxPyBeginAllowThreads();
5682 (arg1)->SetDepth(arg2);
5683
5684 wxPyEndAllowThreads(__tstate);
5685 if (PyErr_Occurred()) SWIG_fail;
5686 }
5687 Py_INCREF(Py_None); resultobj = Py_None;
5688 return resultobj;
5689 fail:
5690 return NULL;
5691 }
5692
5693
5694 static PyObject *_wrap_Icon_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5695 PyObject *resultobj;
5696 wxIcon *arg1 = (wxIcon *) 0 ;
5697 wxSize *arg2 = 0 ;
5698 wxSize temp2 ;
5699 PyObject * obj0 = 0 ;
5700 PyObject * obj1 = 0 ;
5701 char *kwnames[] = {
5702 (char *) "self",(char *) "size", NULL
5703 };
5704
5705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetSize",kwnames,&obj0,&obj1)) goto fail;
5706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5707 if (SWIG_arg_fail(1)) SWIG_fail;
5708 {
5709 arg2 = &temp2;
5710 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5711 }
5712 {
5713 PyThreadState* __tstate = wxPyBeginAllowThreads();
5714 (arg1)->SetSize((wxSize const &)*arg2);
5715
5716 wxPyEndAllowThreads(__tstate);
5717 if (PyErr_Occurred()) SWIG_fail;
5718 }
5719 Py_INCREF(Py_None); resultobj = Py_None;
5720 return resultobj;
5721 fail:
5722 return NULL;
5723 }
5724
5725
5726 static PyObject *_wrap_Icon_CopyFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5727 PyObject *resultobj;
5728 wxIcon *arg1 = (wxIcon *) 0 ;
5729 wxBitmap *arg2 = 0 ;
5730 PyObject * obj0 = 0 ;
5731 PyObject * obj1 = 0 ;
5732 char *kwnames[] = {
5733 (char *) "self",(char *) "bmp", NULL
5734 };
5735
5736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_CopyFromBitmap",kwnames,&obj0,&obj1)) goto fail;
5737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5738 if (SWIG_arg_fail(1)) SWIG_fail;
5739 {
5740 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5741 if (SWIG_arg_fail(2)) SWIG_fail;
5742 if (arg2 == NULL) {
5743 SWIG_null_ref("wxBitmap");
5744 }
5745 if (SWIG_arg_fail(2)) SWIG_fail;
5746 }
5747 {
5748 PyThreadState* __tstate = wxPyBeginAllowThreads();
5749 (arg1)->CopyFromBitmap((wxBitmap const &)*arg2);
5750
5751 wxPyEndAllowThreads(__tstate);
5752 if (PyErr_Occurred()) SWIG_fail;
5753 }
5754 Py_INCREF(Py_None); resultobj = Py_None;
5755 return resultobj;
5756 fail:
5757 return NULL;
5758 }
5759
5760
5761 static PyObject * Icon_swigregister(PyObject *, PyObject *args) {
5762 PyObject *obj;
5763 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5764 SWIG_TypeClientData(SWIGTYPE_p_wxIcon, obj);
5765 Py_INCREF(obj);
5766 return Py_BuildValue((char *)"");
5767 }
5768 static PyObject *_wrap_new_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5769 PyObject *resultobj;
5770 wxString *arg1 = (wxString *) &wxPyEmptyString ;
5771 int arg2 = (int) 0 ;
5772 wxIconLocation *result;
5773 bool temp1 = false ;
5774 PyObject * obj0 = 0 ;
5775 PyObject * obj1 = 0 ;
5776 char *kwnames[] = {
5777 (char *) "filename",(char *) "num", NULL
5778 };
5779
5780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconLocation",kwnames,&obj0,&obj1)) goto fail;
5781 if (obj0) {
5782 {
5783 arg1 = wxString_in_helper(obj0);
5784 if (arg1 == NULL) SWIG_fail;
5785 temp1 = true;
5786 }
5787 }
5788 if (obj1) {
5789 {
5790 arg2 = (int)(SWIG_As_int(obj1));
5791 if (SWIG_arg_fail(2)) SWIG_fail;
5792 }
5793 }
5794 {
5795 PyThreadState* __tstate = wxPyBeginAllowThreads();
5796 result = (wxIconLocation *)new_wxIconLocation((wxString const *)arg1,arg2);
5797
5798 wxPyEndAllowThreads(__tstate);
5799 if (PyErr_Occurred()) SWIG_fail;
5800 }
5801 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconLocation, 1);
5802 {
5803 if (temp1)
5804 delete arg1;
5805 }
5806 return resultobj;
5807 fail:
5808 {
5809 if (temp1)
5810 delete arg1;
5811 }
5812 return NULL;
5813 }
5814
5815
5816 static PyObject *_wrap_delete_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5817 PyObject *resultobj;
5818 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5819 PyObject * obj0 = 0 ;
5820 char *kwnames[] = {
5821 (char *) "self", NULL
5822 };
5823
5824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconLocation",kwnames,&obj0)) goto fail;
5825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5826 if (SWIG_arg_fail(1)) SWIG_fail;
5827 {
5828 PyThreadState* __tstate = wxPyBeginAllowThreads();
5829 delete arg1;
5830
5831 wxPyEndAllowThreads(__tstate);
5832 if (PyErr_Occurred()) SWIG_fail;
5833 }
5834 Py_INCREF(Py_None); resultobj = Py_None;
5835 return resultobj;
5836 fail:
5837 return NULL;
5838 }
5839
5840
5841 static PyObject *_wrap_IconLocation_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
5842 PyObject *resultobj;
5843 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5844 bool result;
5845 PyObject * obj0 = 0 ;
5846 char *kwnames[] = {
5847 (char *) "self", NULL
5848 };
5849
5850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_IsOk",kwnames,&obj0)) goto fail;
5851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5852 if (SWIG_arg_fail(1)) SWIG_fail;
5853 {
5854 PyThreadState* __tstate = wxPyBeginAllowThreads();
5855 result = (bool)((wxIconLocation const *)arg1)->IsOk();
5856
5857 wxPyEndAllowThreads(__tstate);
5858 if (PyErr_Occurred()) SWIG_fail;
5859 }
5860 {
5861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5862 }
5863 return resultobj;
5864 fail:
5865 return NULL;
5866 }
5867
5868
5869 static PyObject *_wrap_IconLocation_SetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5870 PyObject *resultobj;
5871 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5872 wxString *arg2 = 0 ;
5873 bool temp2 = false ;
5874 PyObject * obj0 = 0 ;
5875 PyObject * obj1 = 0 ;
5876 char *kwnames[] = {
5877 (char *) "self",(char *) "filename", NULL
5878 };
5879
5880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetFileName",kwnames,&obj0,&obj1)) goto fail;
5881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5882 if (SWIG_arg_fail(1)) SWIG_fail;
5883 {
5884 arg2 = wxString_in_helper(obj1);
5885 if (arg2 == NULL) SWIG_fail;
5886 temp2 = true;
5887 }
5888 {
5889 PyThreadState* __tstate = wxPyBeginAllowThreads();
5890 (arg1)->SetFileName((wxString const &)*arg2);
5891
5892 wxPyEndAllowThreads(__tstate);
5893 if (PyErr_Occurred()) SWIG_fail;
5894 }
5895 Py_INCREF(Py_None); resultobj = Py_None;
5896 {
5897 if (temp2)
5898 delete arg2;
5899 }
5900 return resultobj;
5901 fail:
5902 {
5903 if (temp2)
5904 delete arg2;
5905 }
5906 return NULL;
5907 }
5908
5909
5910 static PyObject *_wrap_IconLocation_GetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5911 PyObject *resultobj;
5912 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5913 wxString *result;
5914 PyObject * obj0 = 0 ;
5915 char *kwnames[] = {
5916 (char *) "self", NULL
5917 };
5918
5919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetFileName",kwnames,&obj0)) goto fail;
5920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5921 if (SWIG_arg_fail(1)) SWIG_fail;
5922 {
5923 PyThreadState* __tstate = wxPyBeginAllowThreads();
5924 {
5925 wxString const &_result_ref = ((wxIconLocation const *)arg1)->GetFileName();
5926 result = (wxString *) &_result_ref;
5927 }
5928
5929 wxPyEndAllowThreads(__tstate);
5930 if (PyErr_Occurred()) SWIG_fail;
5931 }
5932 {
5933 #if wxUSE_UNICODE
5934 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
5935 #else
5936 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
5937 #endif
5938 }
5939 return resultobj;
5940 fail:
5941 return NULL;
5942 }
5943
5944
5945 static PyObject *_wrap_IconLocation_SetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5946 PyObject *resultobj;
5947 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5948 int arg2 ;
5949 PyObject * obj0 = 0 ;
5950 PyObject * obj1 = 0 ;
5951 char *kwnames[] = {
5952 (char *) "self",(char *) "num", NULL
5953 };
5954
5955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetIndex",kwnames,&obj0,&obj1)) goto fail;
5956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5957 if (SWIG_arg_fail(1)) SWIG_fail;
5958 {
5959 arg2 = (int)(SWIG_As_int(obj1));
5960 if (SWIG_arg_fail(2)) SWIG_fail;
5961 }
5962 {
5963 PyThreadState* __tstate = wxPyBeginAllowThreads();
5964 wxIconLocation_SetIndex(arg1,arg2);
5965
5966 wxPyEndAllowThreads(__tstate);
5967 if (PyErr_Occurred()) SWIG_fail;
5968 }
5969 Py_INCREF(Py_None); resultobj = Py_None;
5970 return resultobj;
5971 fail:
5972 return NULL;
5973 }
5974
5975
5976 static PyObject *_wrap_IconLocation_GetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5977 PyObject *resultobj;
5978 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5979 int result;
5980 PyObject * obj0 = 0 ;
5981 char *kwnames[] = {
5982 (char *) "self", NULL
5983 };
5984
5985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetIndex",kwnames,&obj0)) goto fail;
5986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5987 if (SWIG_arg_fail(1)) SWIG_fail;
5988 {
5989 PyThreadState* __tstate = wxPyBeginAllowThreads();
5990 result = (int)wxIconLocation_GetIndex(arg1);
5991
5992 wxPyEndAllowThreads(__tstate);
5993 if (PyErr_Occurred()) SWIG_fail;
5994 }
5995 {
5996 resultobj = SWIG_From_int((int)(result));
5997 }
5998 return resultobj;
5999 fail:
6000 return NULL;
6001 }
6002
6003
6004 static PyObject * IconLocation_swigregister(PyObject *, PyObject *args) {
6005 PyObject *obj;
6006 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6007 SWIG_TypeClientData(SWIGTYPE_p_wxIconLocation, obj);
6008 Py_INCREF(obj);
6009 return Py_BuildValue((char *)"");
6010 }
6011 static PyObject *_wrap_new_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
6012 PyObject *resultobj;
6013 wxIconBundle *result;
6014 char *kwnames[] = {
6015 NULL
6016 };
6017
6018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IconBundle",kwnames)) goto fail;
6019 {
6020 PyThreadState* __tstate = wxPyBeginAllowThreads();
6021 result = (wxIconBundle *)new wxIconBundle();
6022
6023 wxPyEndAllowThreads(__tstate);
6024 if (PyErr_Occurred()) SWIG_fail;
6025 }
6026 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
6027 return resultobj;
6028 fail:
6029 return NULL;
6030 }
6031
6032
6033 static PyObject *_wrap_new_IconBundleFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
6034 PyObject *resultobj;
6035 wxString *arg1 = 0 ;
6036 long arg2 ;
6037 wxIconBundle *result;
6038 bool temp1 = false ;
6039 PyObject * obj0 = 0 ;
6040 PyObject * obj1 = 0 ;
6041 char *kwnames[] = {
6042 (char *) "file",(char *) "type", NULL
6043 };
6044
6045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_IconBundleFromFile",kwnames,&obj0,&obj1)) goto fail;
6046 {
6047 arg1 = wxString_in_helper(obj0);
6048 if (arg1 == NULL) SWIG_fail;
6049 temp1 = true;
6050 }
6051 {
6052 arg2 = (long)(SWIG_As_long(obj1));
6053 if (SWIG_arg_fail(2)) SWIG_fail;
6054 }
6055 {
6056 PyThreadState* __tstate = wxPyBeginAllowThreads();
6057 result = (wxIconBundle *)new wxIconBundle((wxString const &)*arg1,arg2);
6058
6059 wxPyEndAllowThreads(__tstate);
6060 if (PyErr_Occurred()) SWIG_fail;
6061 }
6062 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
6063 {
6064 if (temp1)
6065 delete arg1;
6066 }
6067 return resultobj;
6068 fail:
6069 {
6070 if (temp1)
6071 delete arg1;
6072 }
6073 return NULL;
6074 }
6075
6076
6077 static PyObject *_wrap_new_IconBundleFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
6078 PyObject *resultobj;
6079 wxIcon *arg1 = 0 ;
6080 wxIconBundle *result;
6081 PyObject * obj0 = 0 ;
6082 char *kwnames[] = {
6083 (char *) "icon", NULL
6084 };
6085
6086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconBundleFromIcon",kwnames,&obj0)) goto fail;
6087 {
6088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
6089 if (SWIG_arg_fail(1)) SWIG_fail;
6090 if (arg1 == NULL) {
6091 SWIG_null_ref("wxIcon");
6092 }
6093 if (SWIG_arg_fail(1)) SWIG_fail;
6094 }
6095 {
6096 PyThreadState* __tstate = wxPyBeginAllowThreads();
6097 result = (wxIconBundle *)new wxIconBundle((wxIcon const &)*arg1);
6098
6099 wxPyEndAllowThreads(__tstate);
6100 if (PyErr_Occurred()) SWIG_fail;
6101 }
6102 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
6103 return resultobj;
6104 fail:
6105 return NULL;
6106 }
6107
6108
6109 static PyObject *_wrap_delete_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
6110 PyObject *resultobj;
6111 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
6112 PyObject * obj0 = 0 ;
6113 char *kwnames[] = {
6114 (char *) "self", NULL
6115 };
6116
6117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconBundle",kwnames,&obj0)) goto fail;
6118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
6119 if (SWIG_arg_fail(1)) SWIG_fail;
6120 {
6121 PyThreadState* __tstate = wxPyBeginAllowThreads();
6122 delete arg1;
6123
6124 wxPyEndAllowThreads(__tstate);
6125 if (PyErr_Occurred()) SWIG_fail;
6126 }
6127 Py_INCREF(Py_None); resultobj = Py_None;
6128 return resultobj;
6129 fail:
6130 return NULL;
6131 }
6132
6133
6134 static PyObject *_wrap_IconBundle_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
6135 PyObject *resultobj;
6136 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
6137 wxIcon *arg2 = 0 ;
6138 PyObject * obj0 = 0 ;
6139 PyObject * obj1 = 0 ;
6140 char *kwnames[] = {
6141 (char *) "self",(char *) "icon", NULL
6142 };
6143
6144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_AddIcon",kwnames,&obj0,&obj1)) goto fail;
6145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
6146 if (SWIG_arg_fail(1)) SWIG_fail;
6147 {
6148 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
6149 if (SWIG_arg_fail(2)) SWIG_fail;
6150 if (arg2 == NULL) {
6151 SWIG_null_ref("wxIcon");
6152 }
6153 if (SWIG_arg_fail(2)) SWIG_fail;
6154 }
6155 {
6156 PyThreadState* __tstate = wxPyBeginAllowThreads();
6157 (arg1)->AddIcon((wxIcon const &)*arg2);
6158
6159 wxPyEndAllowThreads(__tstate);
6160 if (PyErr_Occurred()) SWIG_fail;
6161 }
6162 Py_INCREF(Py_None); resultobj = Py_None;
6163 return resultobj;
6164 fail:
6165 return NULL;
6166 }
6167
6168
6169 static PyObject *_wrap_IconBundle_AddIconFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
6170 PyObject *resultobj;
6171 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
6172 wxString *arg2 = 0 ;
6173 long arg3 ;
6174 bool temp2 = false ;
6175 PyObject * obj0 = 0 ;
6176 PyObject * obj1 = 0 ;
6177 PyObject * obj2 = 0 ;
6178 char *kwnames[] = {
6179 (char *) "self",(char *) "file",(char *) "type", NULL
6180 };
6181
6182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IconBundle_AddIconFromFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
6183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
6184 if (SWIG_arg_fail(1)) SWIG_fail;
6185 {
6186 arg2 = wxString_in_helper(obj1);
6187 if (arg2 == NULL) SWIG_fail;
6188 temp2 = true;
6189 }
6190 {
6191 arg3 = (long)(SWIG_As_long(obj2));
6192 if (SWIG_arg_fail(3)) SWIG_fail;
6193 }
6194 {
6195 PyThreadState* __tstate = wxPyBeginAllowThreads();
6196 (arg1)->AddIcon((wxString const &)*arg2,arg3);
6197
6198 wxPyEndAllowThreads(__tstate);
6199 if (PyErr_Occurred()) SWIG_fail;
6200 }
6201 Py_INCREF(Py_None); resultobj = Py_None;
6202 {
6203 if (temp2)
6204 delete arg2;
6205 }
6206 return resultobj;
6207 fail:
6208 {
6209 if (temp2)
6210 delete arg2;
6211 }
6212 return NULL;
6213 }
6214
6215
6216 static PyObject *_wrap_IconBundle_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
6217 PyObject *resultobj;
6218 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
6219 wxSize *arg2 = 0 ;
6220 wxIcon *result;
6221 wxSize temp2 ;
6222 PyObject * obj0 = 0 ;
6223 PyObject * obj1 = 0 ;
6224 char *kwnames[] = {
6225 (char *) "self",(char *) "size", NULL
6226 };
6227
6228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_GetIcon",kwnames,&obj0,&obj1)) goto fail;
6229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
6230 if (SWIG_arg_fail(1)) SWIG_fail;
6231 {
6232 arg2 = &temp2;
6233 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6234 }
6235 {
6236 PyThreadState* __tstate = wxPyBeginAllowThreads();
6237 {
6238 wxIcon const &_result_ref = ((wxIconBundle const *)arg1)->GetIcon((wxSize const &)*arg2);
6239 result = (wxIcon *) &_result_ref;
6240 }
6241
6242 wxPyEndAllowThreads(__tstate);
6243 if (PyErr_Occurred()) SWIG_fail;
6244 }
6245 {
6246 wxIcon* resultptr = new wxIcon(*result);
6247 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxIcon, 1);
6248 }
6249 return resultobj;
6250 fail:
6251 return NULL;
6252 }
6253
6254
6255 static PyObject * IconBundle_swigregister(PyObject *, PyObject *args) {
6256 PyObject *obj;
6257 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6258 SWIG_TypeClientData(SWIGTYPE_p_wxIconBundle, obj);
6259 Py_INCREF(obj);
6260 return Py_BuildValue((char *)"");
6261 }
6262 static PyObject *_wrap_new_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
6263 PyObject *resultobj;
6264 wxString *arg1 = 0 ;
6265 long arg2 ;
6266 int arg3 = (int) 0 ;
6267 int arg4 = (int) 0 ;
6268 wxCursor *result;
6269 bool temp1 = false ;
6270 PyObject * obj0 = 0 ;
6271 PyObject * obj1 = 0 ;
6272 PyObject * obj2 = 0 ;
6273 PyObject * obj3 = 0 ;
6274 char *kwnames[] = {
6275 (char *) "cursorName",(char *) "type",(char *) "hotSpotX",(char *) "hotSpotY", NULL
6276 };
6277
6278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Cursor",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6279 {
6280 arg1 = wxString_in_helper(obj0);
6281 if (arg1 == NULL) SWIG_fail;
6282 temp1 = true;
6283 }
6284 {
6285 arg2 = (long)(SWIG_As_long(obj1));
6286 if (SWIG_arg_fail(2)) SWIG_fail;
6287 }
6288 if (obj2) {
6289 {
6290 arg3 = (int)(SWIG_As_int(obj2));
6291 if (SWIG_arg_fail(3)) SWIG_fail;
6292 }
6293 }
6294 if (obj3) {
6295 {
6296 arg4 = (int)(SWIG_As_int(obj3));
6297 if (SWIG_arg_fail(4)) SWIG_fail;
6298 }
6299 }
6300 {
6301 if (!wxPyCheckForApp()) SWIG_fail;
6302 PyThreadState* __tstate = wxPyBeginAllowThreads();
6303 result = (wxCursor *)new_wxCursor((wxString const &)*arg1,arg2,arg3,arg4);
6304
6305 wxPyEndAllowThreads(__tstate);
6306 if (PyErr_Occurred()) SWIG_fail;
6307 }
6308 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6309 {
6310 if (temp1)
6311 delete arg1;
6312 }
6313 return resultobj;
6314 fail:
6315 {
6316 if (temp1)
6317 delete arg1;
6318 }
6319 return NULL;
6320 }
6321
6322
6323 static PyObject *_wrap_delete_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
6324 PyObject *resultobj;
6325 wxCursor *arg1 = (wxCursor *) 0 ;
6326 PyObject * obj0 = 0 ;
6327 char *kwnames[] = {
6328 (char *) "self", NULL
6329 };
6330
6331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Cursor",kwnames,&obj0)) goto fail;
6332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6333 if (SWIG_arg_fail(1)) SWIG_fail;
6334 {
6335 PyThreadState* __tstate = wxPyBeginAllowThreads();
6336 delete arg1;
6337
6338 wxPyEndAllowThreads(__tstate);
6339 if (PyErr_Occurred()) SWIG_fail;
6340 }
6341 Py_INCREF(Py_None); resultobj = Py_None;
6342 return resultobj;
6343 fail:
6344 return NULL;
6345 }
6346
6347
6348 static PyObject *_wrap_new_StockCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6349 PyObject *resultobj;
6350 int arg1 ;
6351 wxCursor *result;
6352 PyObject * obj0 = 0 ;
6353 char *kwnames[] = {
6354 (char *) "id", NULL
6355 };
6356
6357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_StockCursor",kwnames,&obj0)) goto fail;
6358 {
6359 arg1 = (int)(SWIG_As_int(obj0));
6360 if (SWIG_arg_fail(1)) SWIG_fail;
6361 }
6362 {
6363 if (!wxPyCheckForApp()) SWIG_fail;
6364 PyThreadState* __tstate = wxPyBeginAllowThreads();
6365 result = (wxCursor *)new wxCursor(arg1);
6366
6367 wxPyEndAllowThreads(__tstate);
6368 if (PyErr_Occurred()) SWIG_fail;
6369 }
6370 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6371 return resultobj;
6372 fail:
6373 return NULL;
6374 }
6375
6376
6377 static PyObject *_wrap_new_CursorFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
6378 PyObject *resultobj;
6379 wxImage *arg1 = 0 ;
6380 wxCursor *result;
6381 PyObject * obj0 = 0 ;
6382 char *kwnames[] = {
6383 (char *) "image", NULL
6384 };
6385
6386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CursorFromImage",kwnames,&obj0)) goto fail;
6387 {
6388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
6389 if (SWIG_arg_fail(1)) SWIG_fail;
6390 if (arg1 == NULL) {
6391 SWIG_null_ref("wxImage");
6392 }
6393 if (SWIG_arg_fail(1)) SWIG_fail;
6394 }
6395 {
6396 if (!wxPyCheckForApp()) SWIG_fail;
6397 PyThreadState* __tstate = wxPyBeginAllowThreads();
6398 result = (wxCursor *)new wxCursor((wxImage const &)*arg1);
6399
6400 wxPyEndAllowThreads(__tstate);
6401 if (PyErr_Occurred()) SWIG_fail;
6402 }
6403 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6404 return resultobj;
6405 fail:
6406 return NULL;
6407 }
6408
6409
6410 static PyObject *_wrap_Cursor_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
6411 PyObject *resultobj;
6412 wxCursor *arg1 = (wxCursor *) 0 ;
6413 long result;
6414 PyObject * obj0 = 0 ;
6415 char *kwnames[] = {
6416 (char *) "self", NULL
6417 };
6418
6419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_GetHandle",kwnames,&obj0)) goto fail;
6420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6421 if (SWIG_arg_fail(1)) SWIG_fail;
6422 {
6423 PyThreadState* __tstate = wxPyBeginAllowThreads();
6424 result = (long)(arg1)->GetHandle();
6425
6426 wxPyEndAllowThreads(__tstate);
6427 if (PyErr_Occurred()) SWIG_fail;
6428 }
6429 {
6430 resultobj = SWIG_From_long((long)(result));
6431 }
6432 return resultobj;
6433 fail:
6434 return NULL;
6435 }
6436
6437
6438 static PyObject *_wrap_Cursor_SetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
6439 PyObject *resultobj;
6440 wxCursor *arg1 = (wxCursor *) 0 ;
6441 long arg2 ;
6442 PyObject * obj0 = 0 ;
6443 PyObject * obj1 = 0 ;
6444 char *kwnames[] = {
6445 (char *) "self",(char *) "handle", NULL
6446 };
6447
6448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetHandle",kwnames,&obj0,&obj1)) goto fail;
6449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6450 if (SWIG_arg_fail(1)) SWIG_fail;
6451 {
6452 arg2 = (long)(SWIG_As_long(obj1));
6453 if (SWIG_arg_fail(2)) SWIG_fail;
6454 }
6455 {
6456 PyThreadState* __tstate = wxPyBeginAllowThreads();
6457 wxCursor_SetHandle(arg1,arg2);
6458
6459 wxPyEndAllowThreads(__tstate);
6460 if (PyErr_Occurred()) SWIG_fail;
6461 }
6462 Py_INCREF(Py_None); resultobj = Py_None;
6463 return resultobj;
6464 fail:
6465 return NULL;
6466 }
6467
6468
6469 static PyObject *_wrap_Cursor_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
6470 PyObject *resultobj;
6471 wxCursor *arg1 = (wxCursor *) 0 ;
6472 bool result;
6473 PyObject * obj0 = 0 ;
6474 char *kwnames[] = {
6475 (char *) "self", NULL
6476 };
6477
6478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_Ok",kwnames,&obj0)) goto fail;
6479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6480 if (SWIG_arg_fail(1)) SWIG_fail;
6481 {
6482 PyThreadState* __tstate = wxPyBeginAllowThreads();
6483 result = (bool)(arg1)->Ok();
6484
6485 wxPyEndAllowThreads(__tstate);
6486 if (PyErr_Occurred()) SWIG_fail;
6487 }
6488 {
6489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6490 }
6491 return resultobj;
6492 fail:
6493 return NULL;
6494 }
6495
6496
6497 static PyObject *_wrap_Cursor_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
6498 PyObject *resultobj;
6499 wxCursor *arg1 = (wxCursor *) 0 ;
6500 int result;
6501 PyObject * obj0 = 0 ;
6502 char *kwnames[] = {
6503 (char *) "self", NULL
6504 };
6505
6506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_GetWidth",kwnames,&obj0)) goto fail;
6507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6508 if (SWIG_arg_fail(1)) SWIG_fail;
6509 {
6510 PyThreadState* __tstate = wxPyBeginAllowThreads();
6511 result = (int)(arg1)->GetWidth();
6512
6513 wxPyEndAllowThreads(__tstate);
6514 if (PyErr_Occurred()) SWIG_fail;
6515 }
6516 {
6517 resultobj = SWIG_From_int((int)(result));
6518 }
6519 return resultobj;
6520 fail:
6521 return NULL;
6522 }
6523
6524
6525 static PyObject *_wrap_Cursor_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
6526 PyObject *resultobj;
6527 wxCursor *arg1 = (wxCursor *) 0 ;
6528 int result;
6529 PyObject * obj0 = 0 ;
6530 char *kwnames[] = {
6531 (char *) "self", NULL
6532 };
6533
6534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_GetHeight",kwnames,&obj0)) goto fail;
6535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6536 if (SWIG_arg_fail(1)) SWIG_fail;
6537 {
6538 PyThreadState* __tstate = wxPyBeginAllowThreads();
6539 result = (int)(arg1)->GetHeight();
6540
6541 wxPyEndAllowThreads(__tstate);
6542 if (PyErr_Occurred()) SWIG_fail;
6543 }
6544 {
6545 resultobj = SWIG_From_int((int)(result));
6546 }
6547 return resultobj;
6548 fail:
6549 return NULL;
6550 }
6551
6552
6553 static PyObject *_wrap_Cursor_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
6554 PyObject *resultobj;
6555 wxCursor *arg1 = (wxCursor *) 0 ;
6556 int result;
6557 PyObject * obj0 = 0 ;
6558 char *kwnames[] = {
6559 (char *) "self", NULL
6560 };
6561
6562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_GetDepth",kwnames,&obj0)) goto fail;
6563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6564 if (SWIG_arg_fail(1)) SWIG_fail;
6565 {
6566 PyThreadState* __tstate = wxPyBeginAllowThreads();
6567 result = (int)(arg1)->GetDepth();
6568
6569 wxPyEndAllowThreads(__tstate);
6570 if (PyErr_Occurred()) SWIG_fail;
6571 }
6572 {
6573 resultobj = SWIG_From_int((int)(result));
6574 }
6575 return resultobj;
6576 fail:
6577 return NULL;
6578 }
6579
6580
6581 static PyObject *_wrap_Cursor_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
6582 PyObject *resultobj;
6583 wxCursor *arg1 = (wxCursor *) 0 ;
6584 int arg2 ;
6585 PyObject * obj0 = 0 ;
6586 PyObject * obj1 = 0 ;
6587 char *kwnames[] = {
6588 (char *) "self",(char *) "w", NULL
6589 };
6590
6591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetWidth",kwnames,&obj0,&obj1)) goto fail;
6592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6593 if (SWIG_arg_fail(1)) SWIG_fail;
6594 {
6595 arg2 = (int)(SWIG_As_int(obj1));
6596 if (SWIG_arg_fail(2)) SWIG_fail;
6597 }
6598 {
6599 PyThreadState* __tstate = wxPyBeginAllowThreads();
6600 (arg1)->SetWidth(arg2);
6601
6602 wxPyEndAllowThreads(__tstate);
6603 if (PyErr_Occurred()) SWIG_fail;
6604 }
6605 Py_INCREF(Py_None); resultobj = Py_None;
6606 return resultobj;
6607 fail:
6608 return NULL;
6609 }
6610
6611
6612 static PyObject *_wrap_Cursor_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
6613 PyObject *resultobj;
6614 wxCursor *arg1 = (wxCursor *) 0 ;
6615 int arg2 ;
6616 PyObject * obj0 = 0 ;
6617 PyObject * obj1 = 0 ;
6618 char *kwnames[] = {
6619 (char *) "self",(char *) "h", NULL
6620 };
6621
6622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetHeight",kwnames,&obj0,&obj1)) goto fail;
6623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6624 if (SWIG_arg_fail(1)) SWIG_fail;
6625 {
6626 arg2 = (int)(SWIG_As_int(obj1));
6627 if (SWIG_arg_fail(2)) SWIG_fail;
6628 }
6629 {
6630 PyThreadState* __tstate = wxPyBeginAllowThreads();
6631 (arg1)->SetHeight(arg2);
6632
6633 wxPyEndAllowThreads(__tstate);
6634 if (PyErr_Occurred()) SWIG_fail;
6635 }
6636 Py_INCREF(Py_None); resultobj = Py_None;
6637 return resultobj;
6638 fail:
6639 return NULL;
6640 }
6641
6642
6643 static PyObject *_wrap_Cursor_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
6644 PyObject *resultobj;
6645 wxCursor *arg1 = (wxCursor *) 0 ;
6646 int arg2 ;
6647 PyObject * obj0 = 0 ;
6648 PyObject * obj1 = 0 ;
6649 char *kwnames[] = {
6650 (char *) "self",(char *) "d", NULL
6651 };
6652
6653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetDepth",kwnames,&obj0,&obj1)) goto fail;
6654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6655 if (SWIG_arg_fail(1)) SWIG_fail;
6656 {
6657 arg2 = (int)(SWIG_As_int(obj1));
6658 if (SWIG_arg_fail(2)) SWIG_fail;
6659 }
6660 {
6661 PyThreadState* __tstate = wxPyBeginAllowThreads();
6662 (arg1)->SetDepth(arg2);
6663
6664 wxPyEndAllowThreads(__tstate);
6665 if (PyErr_Occurred()) SWIG_fail;
6666 }
6667 Py_INCREF(Py_None); resultobj = Py_None;
6668 return resultobj;
6669 fail:
6670 return NULL;
6671 }
6672
6673
6674 static PyObject *_wrap_Cursor_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6675 PyObject *resultobj;
6676 wxCursor *arg1 = (wxCursor *) 0 ;
6677 wxSize *arg2 = 0 ;
6678 wxSize temp2 ;
6679 PyObject * obj0 = 0 ;
6680 PyObject * obj1 = 0 ;
6681 char *kwnames[] = {
6682 (char *) "self",(char *) "size", NULL
6683 };
6684
6685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Cursor_SetSize",kwnames,&obj0,&obj1)) goto fail;
6686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6687 if (SWIG_arg_fail(1)) SWIG_fail;
6688 {
6689 arg2 = &temp2;
6690 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6691 }
6692 {
6693 PyThreadState* __tstate = wxPyBeginAllowThreads();
6694 (arg1)->SetSize((wxSize const &)*arg2);
6695
6696 wxPyEndAllowThreads(__tstate);
6697 if (PyErr_Occurred()) SWIG_fail;
6698 }
6699 Py_INCREF(Py_None); resultobj = Py_None;
6700 return resultobj;
6701 fail:
6702 return NULL;
6703 }
6704
6705
6706 static PyObject * Cursor_swigregister(PyObject *, PyObject *args) {
6707 PyObject *obj;
6708 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6709 SWIG_TypeClientData(SWIGTYPE_p_wxCursor, obj);
6710 Py_INCREF(obj);
6711 return Py_BuildValue((char *)"");
6712 }
6713 static PyObject *_wrap_new_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6714 PyObject *resultobj;
6715 int arg1 = (int) 0 ;
6716 int arg2 = (int) 0 ;
6717 int arg3 = (int) 0 ;
6718 int arg4 = (int) 0 ;
6719 wxRegion *result;
6720 PyObject * obj0 = 0 ;
6721 PyObject * obj1 = 0 ;
6722 PyObject * obj2 = 0 ;
6723 PyObject * obj3 = 0 ;
6724 char *kwnames[] = {
6725 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6726 };
6727
6728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Region",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6729 if (obj0) {
6730 {
6731 arg1 = (int)(SWIG_As_int(obj0));
6732 if (SWIG_arg_fail(1)) SWIG_fail;
6733 }
6734 }
6735 if (obj1) {
6736 {
6737 arg2 = (int)(SWIG_As_int(obj1));
6738 if (SWIG_arg_fail(2)) SWIG_fail;
6739 }
6740 }
6741 if (obj2) {
6742 {
6743 arg3 = (int)(SWIG_As_int(obj2));
6744 if (SWIG_arg_fail(3)) SWIG_fail;
6745 }
6746 }
6747 if (obj3) {
6748 {
6749 arg4 = (int)(SWIG_As_int(obj3));
6750 if (SWIG_arg_fail(4)) SWIG_fail;
6751 }
6752 }
6753 {
6754 if (!wxPyCheckForApp()) SWIG_fail;
6755 PyThreadState* __tstate = wxPyBeginAllowThreads();
6756 result = (wxRegion *)new wxRegion(arg1,arg2,arg3,arg4);
6757
6758 wxPyEndAllowThreads(__tstate);
6759 if (PyErr_Occurred()) SWIG_fail;
6760 }
6761 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6762 return resultobj;
6763 fail:
6764 return NULL;
6765 }
6766
6767
6768 static PyObject *_wrap_new_RegionFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
6769 PyObject *resultobj;
6770 wxBitmap *arg1 = 0 ;
6771 wxRegion *result;
6772 PyObject * obj0 = 0 ;
6773 char *kwnames[] = {
6774 (char *) "bmp", NULL
6775 };
6776
6777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionFromBitmap",kwnames,&obj0)) goto fail;
6778 {
6779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6780 if (SWIG_arg_fail(1)) SWIG_fail;
6781 if (arg1 == NULL) {
6782 SWIG_null_ref("wxBitmap");
6783 }
6784 if (SWIG_arg_fail(1)) SWIG_fail;
6785 }
6786 {
6787 if (!wxPyCheckForApp()) SWIG_fail;
6788 PyThreadState* __tstate = wxPyBeginAllowThreads();
6789 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1);
6790
6791 wxPyEndAllowThreads(__tstate);
6792 if (PyErr_Occurred()) SWIG_fail;
6793 }
6794 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6795 return resultobj;
6796 fail:
6797 return NULL;
6798 }
6799
6800
6801 static PyObject *_wrap_new_RegionFromBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
6802 PyObject *resultobj;
6803 wxBitmap *arg1 = 0 ;
6804 wxColour *arg2 = 0 ;
6805 int arg3 = (int) 0 ;
6806 wxRegion *result;
6807 wxColour temp2 ;
6808 PyObject * obj0 = 0 ;
6809 PyObject * obj1 = 0 ;
6810 PyObject * obj2 = 0 ;
6811 char *kwnames[] = {
6812 (char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
6813 };
6814
6815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_RegionFromBitmapColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
6816 {
6817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6818 if (SWIG_arg_fail(1)) SWIG_fail;
6819 if (arg1 == NULL) {
6820 SWIG_null_ref("wxBitmap");
6821 }
6822 if (SWIG_arg_fail(1)) SWIG_fail;
6823 }
6824 {
6825 arg2 = &temp2;
6826 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6827 }
6828 if (obj2) {
6829 {
6830 arg3 = (int)(SWIG_As_int(obj2));
6831 if (SWIG_arg_fail(3)) SWIG_fail;
6832 }
6833 }
6834 {
6835 if (!wxPyCheckForApp()) SWIG_fail;
6836 PyThreadState* __tstate = wxPyBeginAllowThreads();
6837 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1,(wxColour const &)*arg2,arg3);
6838
6839 wxPyEndAllowThreads(__tstate);
6840 if (PyErr_Occurred()) SWIG_fail;
6841 }
6842 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6843 return resultobj;
6844 fail:
6845 return NULL;
6846 }
6847
6848
6849 static PyObject *_wrap_new_RegionFromPoints(PyObject *, PyObject *args, PyObject *kwargs) {
6850 PyObject *resultobj;
6851 int arg1 ;
6852 wxPoint *arg2 = (wxPoint *) 0 ;
6853 int arg3 = (int) wxWINDING_RULE ;
6854 wxRegion *result;
6855 PyObject * obj0 = 0 ;
6856 PyObject * obj1 = 0 ;
6857 char *kwnames[] = {
6858 (char *) "points",(char *) "fillStyle", NULL
6859 };
6860
6861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_RegionFromPoints",kwnames,&obj0,&obj1)) goto fail;
6862 {
6863 arg2 = wxPoint_LIST_helper(obj0, &arg1);
6864 if (arg2 == NULL) SWIG_fail;
6865 }
6866 if (obj1) {
6867 {
6868 arg3 = (int)(SWIG_As_int(obj1));
6869 if (SWIG_arg_fail(3)) SWIG_fail;
6870 }
6871 }
6872 {
6873 if (!wxPyCheckForApp()) SWIG_fail;
6874 PyThreadState* __tstate = wxPyBeginAllowThreads();
6875 result = (wxRegion *)new wxRegion(arg1,arg2,arg3);
6876
6877 wxPyEndAllowThreads(__tstate);
6878 if (PyErr_Occurred()) SWIG_fail;
6879 }
6880 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6881 {
6882 if (arg2) delete [] arg2;
6883 }
6884 return resultobj;
6885 fail:
6886 {
6887 if (arg2) delete [] arg2;
6888 }
6889 return NULL;
6890 }
6891
6892
6893 static PyObject *_wrap_delete_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6894 PyObject *resultobj;
6895 wxRegion *arg1 = (wxRegion *) 0 ;
6896 PyObject * obj0 = 0 ;
6897 char *kwnames[] = {
6898 (char *) "self", NULL
6899 };
6900
6901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Region",kwnames,&obj0)) goto fail;
6902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6903 if (SWIG_arg_fail(1)) SWIG_fail;
6904 {
6905 PyThreadState* __tstate = wxPyBeginAllowThreads();
6906 delete arg1;
6907
6908 wxPyEndAllowThreads(__tstate);
6909 if (PyErr_Occurred()) SWIG_fail;
6910 }
6911 Py_INCREF(Py_None); resultobj = Py_None;
6912 return resultobj;
6913 fail:
6914 return NULL;
6915 }
6916
6917
6918 static PyObject *_wrap_Region_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
6919 PyObject *resultobj;
6920 wxRegion *arg1 = (wxRegion *) 0 ;
6921 PyObject * obj0 = 0 ;
6922 char *kwnames[] = {
6923 (char *) "self", NULL
6924 };
6925
6926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_Clear",kwnames,&obj0)) goto fail;
6927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6928 if (SWIG_arg_fail(1)) SWIG_fail;
6929 {
6930 PyThreadState* __tstate = wxPyBeginAllowThreads();
6931 (arg1)->Clear();
6932
6933 wxPyEndAllowThreads(__tstate);
6934 if (PyErr_Occurred()) SWIG_fail;
6935 }
6936 Py_INCREF(Py_None); resultobj = Py_None;
6937 return resultobj;
6938 fail:
6939 return NULL;
6940 }
6941
6942
6943 static PyObject *_wrap_Region_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
6944 PyObject *resultobj;
6945 wxRegion *arg1 = (wxRegion *) 0 ;
6946 int arg2 ;
6947 int arg3 ;
6948 bool result;
6949 PyObject * obj0 = 0 ;
6950 PyObject * obj1 = 0 ;
6951 PyObject * obj2 = 0 ;
6952 char *kwnames[] = {
6953 (char *) "self",(char *) "x",(char *) "y", NULL
6954 };
6955
6956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Offset",kwnames,&obj0,&obj1,&obj2)) goto fail;
6957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6958 if (SWIG_arg_fail(1)) SWIG_fail;
6959 {
6960 arg2 = (int)(SWIG_As_int(obj1));
6961 if (SWIG_arg_fail(2)) SWIG_fail;
6962 }
6963 {
6964 arg3 = (int)(SWIG_As_int(obj2));
6965 if (SWIG_arg_fail(3)) SWIG_fail;
6966 }
6967 {
6968 PyThreadState* __tstate = wxPyBeginAllowThreads();
6969 result = (bool)(arg1)->Offset(arg2,arg3);
6970
6971 wxPyEndAllowThreads(__tstate);
6972 if (PyErr_Occurred()) SWIG_fail;
6973 }
6974 {
6975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6976 }
6977 return resultobj;
6978 fail:
6979 return NULL;
6980 }
6981
6982
6983 static PyObject *_wrap_Region_Contains(PyObject *, PyObject *args, PyObject *kwargs) {
6984 PyObject *resultobj;
6985 wxRegion *arg1 = (wxRegion *) 0 ;
6986 int arg2 ;
6987 int arg3 ;
6988 wxRegionContain result;
6989 PyObject * obj0 = 0 ;
6990 PyObject * obj1 = 0 ;
6991 PyObject * obj2 = 0 ;
6992 char *kwnames[] = {
6993 (char *) "self",(char *) "x",(char *) "y", NULL
6994 };
6995
6996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Contains",kwnames,&obj0,&obj1,&obj2)) goto fail;
6997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6998 if (SWIG_arg_fail(1)) SWIG_fail;
6999 {
7000 arg2 = (int)(SWIG_As_int(obj1));
7001 if (SWIG_arg_fail(2)) SWIG_fail;
7002 }
7003 {
7004 arg3 = (int)(SWIG_As_int(obj2));
7005 if (SWIG_arg_fail(3)) SWIG_fail;
7006 }
7007 {
7008 PyThreadState* __tstate = wxPyBeginAllowThreads();
7009 result = (wxRegionContain)(arg1)->Contains(arg2,arg3);
7010
7011 wxPyEndAllowThreads(__tstate);
7012 if (PyErr_Occurred()) SWIG_fail;
7013 }
7014 resultobj = SWIG_From_int((result));
7015 return resultobj;
7016 fail:
7017 return NULL;
7018 }
7019
7020
7021 static PyObject *_wrap_Region_ContainsPoint(PyObject *, PyObject *args, PyObject *kwargs) {
7022 PyObject *resultobj;
7023 wxRegion *arg1 = (wxRegion *) 0 ;
7024 wxPoint *arg2 = 0 ;
7025 wxRegionContain result;
7026 wxPoint temp2 ;
7027 PyObject * obj0 = 0 ;
7028 PyObject * obj1 = 0 ;
7029 char *kwnames[] = {
7030 (char *) "self",(char *) "pt", NULL
7031 };
7032
7033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsPoint",kwnames,&obj0,&obj1)) goto fail;
7034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7035 if (SWIG_arg_fail(1)) SWIG_fail;
7036 {
7037 arg2 = &temp2;
7038 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7039 }
7040 {
7041 PyThreadState* __tstate = wxPyBeginAllowThreads();
7042 result = (wxRegionContain)(arg1)->Contains((wxPoint const &)*arg2);
7043
7044 wxPyEndAllowThreads(__tstate);
7045 if (PyErr_Occurred()) SWIG_fail;
7046 }
7047 resultobj = SWIG_From_int((result));
7048 return resultobj;
7049 fail:
7050 return NULL;
7051 }
7052
7053
7054 static PyObject *_wrap_Region_ContainsRect(PyObject *, PyObject *args, PyObject *kwargs) {
7055 PyObject *resultobj;
7056 wxRegion *arg1 = (wxRegion *) 0 ;
7057 wxRect *arg2 = 0 ;
7058 wxRegionContain result;
7059 wxRect temp2 ;
7060 PyObject * obj0 = 0 ;
7061 PyObject * obj1 = 0 ;
7062 char *kwnames[] = {
7063 (char *) "self",(char *) "rect", NULL
7064 };
7065
7066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsRect",kwnames,&obj0,&obj1)) goto fail;
7067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7068 if (SWIG_arg_fail(1)) SWIG_fail;
7069 {
7070 arg2 = &temp2;
7071 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7072 }
7073 {
7074 PyThreadState* __tstate = wxPyBeginAllowThreads();
7075 result = (wxRegionContain)(arg1)->Contains((wxRect const &)*arg2);
7076
7077 wxPyEndAllowThreads(__tstate);
7078 if (PyErr_Occurred()) SWIG_fail;
7079 }
7080 resultobj = SWIG_From_int((result));
7081 return resultobj;
7082 fail:
7083 return NULL;
7084 }
7085
7086
7087 static PyObject *_wrap_Region_ContainsRectDim(PyObject *, PyObject *args, PyObject *kwargs) {
7088 PyObject *resultobj;
7089 wxRegion *arg1 = (wxRegion *) 0 ;
7090 int arg2 ;
7091 int arg3 ;
7092 int arg4 ;
7093 int arg5 ;
7094 wxRegionContain result;
7095 PyObject * obj0 = 0 ;
7096 PyObject * obj1 = 0 ;
7097 PyObject * obj2 = 0 ;
7098 PyObject * obj3 = 0 ;
7099 PyObject * obj4 = 0 ;
7100 char *kwnames[] = {
7101 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
7102 };
7103
7104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_ContainsRectDim",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7106 if (SWIG_arg_fail(1)) SWIG_fail;
7107 {
7108 arg2 = (int)(SWIG_As_int(obj1));
7109 if (SWIG_arg_fail(2)) SWIG_fail;
7110 }
7111 {
7112 arg3 = (int)(SWIG_As_int(obj2));
7113 if (SWIG_arg_fail(3)) SWIG_fail;
7114 }
7115 {
7116 arg4 = (int)(SWIG_As_int(obj3));
7117 if (SWIG_arg_fail(4)) SWIG_fail;
7118 }
7119 {
7120 arg5 = (int)(SWIG_As_int(obj4));
7121 if (SWIG_arg_fail(5)) SWIG_fail;
7122 }
7123 {
7124 PyThreadState* __tstate = wxPyBeginAllowThreads();
7125 result = (wxRegionContain)(arg1)->Contains(arg2,arg3,arg4,arg5);
7126
7127 wxPyEndAllowThreads(__tstate);
7128 if (PyErr_Occurred()) SWIG_fail;
7129 }
7130 resultobj = SWIG_From_int((result));
7131 return resultobj;
7132 fail:
7133 return NULL;
7134 }
7135
7136
7137 static PyObject *_wrap_Region_GetBox(PyObject *, PyObject *args, PyObject *kwargs) {
7138 PyObject *resultobj;
7139 wxRegion *arg1 = (wxRegion *) 0 ;
7140 wxRect result;
7141 PyObject * obj0 = 0 ;
7142 char *kwnames[] = {
7143 (char *) "self", NULL
7144 };
7145
7146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_GetBox",kwnames,&obj0)) goto fail;
7147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7148 if (SWIG_arg_fail(1)) SWIG_fail;
7149 {
7150 PyThreadState* __tstate = wxPyBeginAllowThreads();
7151 result = (arg1)->GetBox();
7152
7153 wxPyEndAllowThreads(__tstate);
7154 if (PyErr_Occurred()) SWIG_fail;
7155 }
7156 {
7157 wxRect * resultptr;
7158 resultptr = new wxRect((wxRect &)(result));
7159 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
7160 }
7161 return resultobj;
7162 fail:
7163 return NULL;
7164 }
7165
7166
7167 static PyObject *_wrap_Region_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
7168 PyObject *resultobj;
7169 wxRegion *arg1 = (wxRegion *) 0 ;
7170 int arg2 ;
7171 int arg3 ;
7172 int arg4 ;
7173 int arg5 ;
7174 bool result;
7175 PyObject * obj0 = 0 ;
7176 PyObject * obj1 = 0 ;
7177 PyObject * obj2 = 0 ;
7178 PyObject * obj3 = 0 ;
7179 PyObject * obj4 = 0 ;
7180 char *kwnames[] = {
7181 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7182 };
7183
7184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Intersect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7186 if (SWIG_arg_fail(1)) SWIG_fail;
7187 {
7188 arg2 = (int)(SWIG_As_int(obj1));
7189 if (SWIG_arg_fail(2)) SWIG_fail;
7190 }
7191 {
7192 arg3 = (int)(SWIG_As_int(obj2));
7193 if (SWIG_arg_fail(3)) SWIG_fail;
7194 }
7195 {
7196 arg4 = (int)(SWIG_As_int(obj3));
7197 if (SWIG_arg_fail(4)) SWIG_fail;
7198 }
7199 {
7200 arg5 = (int)(SWIG_As_int(obj4));
7201 if (SWIG_arg_fail(5)) SWIG_fail;
7202 }
7203 {
7204 PyThreadState* __tstate = wxPyBeginAllowThreads();
7205 result = (bool)(arg1)->Intersect(arg2,arg3,arg4,arg5);
7206
7207 wxPyEndAllowThreads(__tstate);
7208 if (PyErr_Occurred()) SWIG_fail;
7209 }
7210 {
7211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7212 }
7213 return resultobj;
7214 fail:
7215 return NULL;
7216 }
7217
7218
7219 static PyObject *_wrap_Region_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
7220 PyObject *resultobj;
7221 wxRegion *arg1 = (wxRegion *) 0 ;
7222 wxRect *arg2 = 0 ;
7223 bool result;
7224 wxRect temp2 ;
7225 PyObject * obj0 = 0 ;
7226 PyObject * obj1 = 0 ;
7227 char *kwnames[] = {
7228 (char *) "self",(char *) "rect", NULL
7229 };
7230
7231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRect",kwnames,&obj0,&obj1)) goto fail;
7232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7233 if (SWIG_arg_fail(1)) SWIG_fail;
7234 {
7235 arg2 = &temp2;
7236 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7237 }
7238 {
7239 PyThreadState* __tstate = wxPyBeginAllowThreads();
7240 result = (bool)(arg1)->Intersect((wxRect const &)*arg2);
7241
7242 wxPyEndAllowThreads(__tstate);
7243 if (PyErr_Occurred()) SWIG_fail;
7244 }
7245 {
7246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7247 }
7248 return resultobj;
7249 fail:
7250 return NULL;
7251 }
7252
7253
7254 static PyObject *_wrap_Region_IntersectRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7255 PyObject *resultobj;
7256 wxRegion *arg1 = (wxRegion *) 0 ;
7257 wxRegion *arg2 = 0 ;
7258 bool result;
7259 PyObject * obj0 = 0 ;
7260 PyObject * obj1 = 0 ;
7261 char *kwnames[] = {
7262 (char *) "self",(char *) "region", NULL
7263 };
7264
7265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRegion",kwnames,&obj0,&obj1)) goto fail;
7266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7267 if (SWIG_arg_fail(1)) SWIG_fail;
7268 {
7269 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7270 if (SWIG_arg_fail(2)) SWIG_fail;
7271 if (arg2 == NULL) {
7272 SWIG_null_ref("wxRegion");
7273 }
7274 if (SWIG_arg_fail(2)) SWIG_fail;
7275 }
7276 {
7277 PyThreadState* __tstate = wxPyBeginAllowThreads();
7278 result = (bool)(arg1)->Intersect((wxRegion const &)*arg2);
7279
7280 wxPyEndAllowThreads(__tstate);
7281 if (PyErr_Occurred()) SWIG_fail;
7282 }
7283 {
7284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7285 }
7286 return resultobj;
7287 fail:
7288 return NULL;
7289 }
7290
7291
7292 static PyObject *_wrap_Region_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
7293 PyObject *resultobj;
7294 wxRegion *arg1 = (wxRegion *) 0 ;
7295 bool result;
7296 PyObject * obj0 = 0 ;
7297 char *kwnames[] = {
7298 (char *) "self", NULL
7299 };
7300
7301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_IsEmpty",kwnames,&obj0)) goto fail;
7302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7303 if (SWIG_arg_fail(1)) SWIG_fail;
7304 {
7305 PyThreadState* __tstate = wxPyBeginAllowThreads();
7306 result = (bool)(arg1)->IsEmpty();
7307
7308 wxPyEndAllowThreads(__tstate);
7309 if (PyErr_Occurred()) SWIG_fail;
7310 }
7311 {
7312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7313 }
7314 return resultobj;
7315 fail:
7316 return NULL;
7317 }
7318
7319
7320 static PyObject *_wrap_Region_Union(PyObject *, PyObject *args, PyObject *kwargs) {
7321 PyObject *resultobj;
7322 wxRegion *arg1 = (wxRegion *) 0 ;
7323 int arg2 ;
7324 int arg3 ;
7325 int arg4 ;
7326 int arg5 ;
7327 bool result;
7328 PyObject * obj0 = 0 ;
7329 PyObject * obj1 = 0 ;
7330 PyObject * obj2 = 0 ;
7331 PyObject * obj3 = 0 ;
7332 PyObject * obj4 = 0 ;
7333 char *kwnames[] = {
7334 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7335 };
7336
7337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Union",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7339 if (SWIG_arg_fail(1)) SWIG_fail;
7340 {
7341 arg2 = (int)(SWIG_As_int(obj1));
7342 if (SWIG_arg_fail(2)) SWIG_fail;
7343 }
7344 {
7345 arg3 = (int)(SWIG_As_int(obj2));
7346 if (SWIG_arg_fail(3)) SWIG_fail;
7347 }
7348 {
7349 arg4 = (int)(SWIG_As_int(obj3));
7350 if (SWIG_arg_fail(4)) SWIG_fail;
7351 }
7352 {
7353 arg5 = (int)(SWIG_As_int(obj4));
7354 if (SWIG_arg_fail(5)) SWIG_fail;
7355 }
7356 {
7357 PyThreadState* __tstate = wxPyBeginAllowThreads();
7358 result = (bool)(arg1)->Union(arg2,arg3,arg4,arg5);
7359
7360 wxPyEndAllowThreads(__tstate);
7361 if (PyErr_Occurred()) SWIG_fail;
7362 }
7363 {
7364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7365 }
7366 return resultobj;
7367 fail:
7368 return NULL;
7369 }
7370
7371
7372 static PyObject *_wrap_Region_UnionRect(PyObject *, PyObject *args, PyObject *kwargs) {
7373 PyObject *resultobj;
7374 wxRegion *arg1 = (wxRegion *) 0 ;
7375 wxRect *arg2 = 0 ;
7376 bool result;
7377 wxRect temp2 ;
7378 PyObject * obj0 = 0 ;
7379 PyObject * obj1 = 0 ;
7380 char *kwnames[] = {
7381 (char *) "self",(char *) "rect", NULL
7382 };
7383
7384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRect",kwnames,&obj0,&obj1)) goto fail;
7385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7386 if (SWIG_arg_fail(1)) SWIG_fail;
7387 {
7388 arg2 = &temp2;
7389 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7390 }
7391 {
7392 PyThreadState* __tstate = wxPyBeginAllowThreads();
7393 result = (bool)(arg1)->Union((wxRect const &)*arg2);
7394
7395 wxPyEndAllowThreads(__tstate);
7396 if (PyErr_Occurred()) SWIG_fail;
7397 }
7398 {
7399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7400 }
7401 return resultobj;
7402 fail:
7403 return NULL;
7404 }
7405
7406
7407 static PyObject *_wrap_Region_UnionRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7408 PyObject *resultobj;
7409 wxRegion *arg1 = (wxRegion *) 0 ;
7410 wxRegion *arg2 = 0 ;
7411 bool result;
7412 PyObject * obj0 = 0 ;
7413 PyObject * obj1 = 0 ;
7414 char *kwnames[] = {
7415 (char *) "self",(char *) "region", NULL
7416 };
7417
7418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRegion",kwnames,&obj0,&obj1)) goto fail;
7419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7420 if (SWIG_arg_fail(1)) SWIG_fail;
7421 {
7422 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7423 if (SWIG_arg_fail(2)) SWIG_fail;
7424 if (arg2 == NULL) {
7425 SWIG_null_ref("wxRegion");
7426 }
7427 if (SWIG_arg_fail(2)) SWIG_fail;
7428 }
7429 {
7430 PyThreadState* __tstate = wxPyBeginAllowThreads();
7431 result = (bool)(arg1)->Union((wxRegion const &)*arg2);
7432
7433 wxPyEndAllowThreads(__tstate);
7434 if (PyErr_Occurred()) SWIG_fail;
7435 }
7436 {
7437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7438 }
7439 return resultobj;
7440 fail:
7441 return NULL;
7442 }
7443
7444
7445 static PyObject *_wrap_Region_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
7446 PyObject *resultobj;
7447 wxRegion *arg1 = (wxRegion *) 0 ;
7448 int arg2 ;
7449 int arg3 ;
7450 int arg4 ;
7451 int arg5 ;
7452 bool result;
7453 PyObject * obj0 = 0 ;
7454 PyObject * obj1 = 0 ;
7455 PyObject * obj2 = 0 ;
7456 PyObject * obj3 = 0 ;
7457 PyObject * obj4 = 0 ;
7458 char *kwnames[] = {
7459 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7460 };
7461
7462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Subtract",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7464 if (SWIG_arg_fail(1)) SWIG_fail;
7465 {
7466 arg2 = (int)(SWIG_As_int(obj1));
7467 if (SWIG_arg_fail(2)) SWIG_fail;
7468 }
7469 {
7470 arg3 = (int)(SWIG_As_int(obj2));
7471 if (SWIG_arg_fail(3)) SWIG_fail;
7472 }
7473 {
7474 arg4 = (int)(SWIG_As_int(obj3));
7475 if (SWIG_arg_fail(4)) SWIG_fail;
7476 }
7477 {
7478 arg5 = (int)(SWIG_As_int(obj4));
7479 if (SWIG_arg_fail(5)) SWIG_fail;
7480 }
7481 {
7482 PyThreadState* __tstate = wxPyBeginAllowThreads();
7483 result = (bool)(arg1)->Subtract(arg2,arg3,arg4,arg5);
7484
7485 wxPyEndAllowThreads(__tstate);
7486 if (PyErr_Occurred()) SWIG_fail;
7487 }
7488 {
7489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7490 }
7491 return resultobj;
7492 fail:
7493 return NULL;
7494 }
7495
7496
7497 static PyObject *_wrap_Region_SubtractRect(PyObject *, PyObject *args, PyObject *kwargs) {
7498 PyObject *resultobj;
7499 wxRegion *arg1 = (wxRegion *) 0 ;
7500 wxRect *arg2 = 0 ;
7501 bool result;
7502 wxRect temp2 ;
7503 PyObject * obj0 = 0 ;
7504 PyObject * obj1 = 0 ;
7505 char *kwnames[] = {
7506 (char *) "self",(char *) "rect", NULL
7507 };
7508
7509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRect",kwnames,&obj0,&obj1)) goto fail;
7510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7511 if (SWIG_arg_fail(1)) SWIG_fail;
7512 {
7513 arg2 = &temp2;
7514 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7515 }
7516 {
7517 PyThreadState* __tstate = wxPyBeginAllowThreads();
7518 result = (bool)(arg1)->Subtract((wxRect const &)*arg2);
7519
7520 wxPyEndAllowThreads(__tstate);
7521 if (PyErr_Occurred()) SWIG_fail;
7522 }
7523 {
7524 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7525 }
7526 return resultobj;
7527 fail:
7528 return NULL;
7529 }
7530
7531
7532 static PyObject *_wrap_Region_SubtractRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7533 PyObject *resultobj;
7534 wxRegion *arg1 = (wxRegion *) 0 ;
7535 wxRegion *arg2 = 0 ;
7536 bool result;
7537 PyObject * obj0 = 0 ;
7538 PyObject * obj1 = 0 ;
7539 char *kwnames[] = {
7540 (char *) "self",(char *) "region", NULL
7541 };
7542
7543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRegion",kwnames,&obj0,&obj1)) goto fail;
7544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7545 if (SWIG_arg_fail(1)) SWIG_fail;
7546 {
7547 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7548 if (SWIG_arg_fail(2)) SWIG_fail;
7549 if (arg2 == NULL) {
7550 SWIG_null_ref("wxRegion");
7551 }
7552 if (SWIG_arg_fail(2)) SWIG_fail;
7553 }
7554 {
7555 PyThreadState* __tstate = wxPyBeginAllowThreads();
7556 result = (bool)(arg1)->Subtract((wxRegion const &)*arg2);
7557
7558 wxPyEndAllowThreads(__tstate);
7559 if (PyErr_Occurred()) SWIG_fail;
7560 }
7561 {
7562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7563 }
7564 return resultobj;
7565 fail:
7566 return NULL;
7567 }
7568
7569
7570 static PyObject *_wrap_Region_Xor(PyObject *, PyObject *args, PyObject *kwargs) {
7571 PyObject *resultobj;
7572 wxRegion *arg1 = (wxRegion *) 0 ;
7573 int arg2 ;
7574 int arg3 ;
7575 int arg4 ;
7576 int arg5 ;
7577 bool result;
7578 PyObject * obj0 = 0 ;
7579 PyObject * obj1 = 0 ;
7580 PyObject * obj2 = 0 ;
7581 PyObject * obj3 = 0 ;
7582 PyObject * obj4 = 0 ;
7583 char *kwnames[] = {
7584 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7585 };
7586
7587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Xor",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7589 if (SWIG_arg_fail(1)) SWIG_fail;
7590 {
7591 arg2 = (int)(SWIG_As_int(obj1));
7592 if (SWIG_arg_fail(2)) SWIG_fail;
7593 }
7594 {
7595 arg3 = (int)(SWIG_As_int(obj2));
7596 if (SWIG_arg_fail(3)) SWIG_fail;
7597 }
7598 {
7599 arg4 = (int)(SWIG_As_int(obj3));
7600 if (SWIG_arg_fail(4)) SWIG_fail;
7601 }
7602 {
7603 arg5 = (int)(SWIG_As_int(obj4));
7604 if (SWIG_arg_fail(5)) SWIG_fail;
7605 }
7606 {
7607 PyThreadState* __tstate = wxPyBeginAllowThreads();
7608 result = (bool)(arg1)->Xor(arg2,arg3,arg4,arg5);
7609
7610 wxPyEndAllowThreads(__tstate);
7611 if (PyErr_Occurred()) SWIG_fail;
7612 }
7613 {
7614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7615 }
7616 return resultobj;
7617 fail:
7618 return NULL;
7619 }
7620
7621
7622 static PyObject *_wrap_Region_XorRect(PyObject *, PyObject *args, PyObject *kwargs) {
7623 PyObject *resultobj;
7624 wxRegion *arg1 = (wxRegion *) 0 ;
7625 wxRect *arg2 = 0 ;
7626 bool result;
7627 wxRect temp2 ;
7628 PyObject * obj0 = 0 ;
7629 PyObject * obj1 = 0 ;
7630 char *kwnames[] = {
7631 (char *) "self",(char *) "rect", NULL
7632 };
7633
7634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRect",kwnames,&obj0,&obj1)) goto fail;
7635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7636 if (SWIG_arg_fail(1)) SWIG_fail;
7637 {
7638 arg2 = &temp2;
7639 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7640 }
7641 {
7642 PyThreadState* __tstate = wxPyBeginAllowThreads();
7643 result = (bool)(arg1)->Xor((wxRect const &)*arg2);
7644
7645 wxPyEndAllowThreads(__tstate);
7646 if (PyErr_Occurred()) SWIG_fail;
7647 }
7648 {
7649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7650 }
7651 return resultobj;
7652 fail:
7653 return NULL;
7654 }
7655
7656
7657 static PyObject *_wrap_Region_XorRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7658 PyObject *resultobj;
7659 wxRegion *arg1 = (wxRegion *) 0 ;
7660 wxRegion *arg2 = 0 ;
7661 bool result;
7662 PyObject * obj0 = 0 ;
7663 PyObject * obj1 = 0 ;
7664 char *kwnames[] = {
7665 (char *) "self",(char *) "region", NULL
7666 };
7667
7668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRegion",kwnames,&obj0,&obj1)) goto fail;
7669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7670 if (SWIG_arg_fail(1)) SWIG_fail;
7671 {
7672 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7673 if (SWIG_arg_fail(2)) SWIG_fail;
7674 if (arg2 == NULL) {
7675 SWIG_null_ref("wxRegion");
7676 }
7677 if (SWIG_arg_fail(2)) SWIG_fail;
7678 }
7679 {
7680 PyThreadState* __tstate = wxPyBeginAllowThreads();
7681 result = (bool)(arg1)->Xor((wxRegion const &)*arg2);
7682
7683 wxPyEndAllowThreads(__tstate);
7684 if (PyErr_Occurred()) SWIG_fail;
7685 }
7686 {
7687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7688 }
7689 return resultobj;
7690 fail:
7691 return NULL;
7692 }
7693
7694
7695 static PyObject *_wrap_Region_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7696 PyObject *resultobj;
7697 wxRegion *arg1 = (wxRegion *) 0 ;
7698 SwigValueWrapper<wxBitmap > result;
7699 PyObject * obj0 = 0 ;
7700 char *kwnames[] = {
7701 (char *) "self", NULL
7702 };
7703
7704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_ConvertToBitmap",kwnames,&obj0)) goto fail;
7705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7706 if (SWIG_arg_fail(1)) SWIG_fail;
7707 {
7708 PyThreadState* __tstate = wxPyBeginAllowThreads();
7709 result = (arg1)->ConvertToBitmap();
7710
7711 wxPyEndAllowThreads(__tstate);
7712 if (PyErr_Occurred()) SWIG_fail;
7713 }
7714 {
7715 wxBitmap * resultptr;
7716 resultptr = new wxBitmap((wxBitmap &)(result));
7717 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
7718 }
7719 return resultobj;
7720 fail:
7721 return NULL;
7722 }
7723
7724
7725 static PyObject *_wrap_Region_UnionBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7726 PyObject *resultobj;
7727 wxRegion *arg1 = (wxRegion *) 0 ;
7728 wxBitmap *arg2 = 0 ;
7729 bool result;
7730 PyObject * obj0 = 0 ;
7731 PyObject * obj1 = 0 ;
7732 char *kwnames[] = {
7733 (char *) "self",(char *) "bmp", NULL
7734 };
7735
7736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionBitmap",kwnames,&obj0,&obj1)) goto fail;
7737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7738 if (SWIG_arg_fail(1)) SWIG_fail;
7739 {
7740 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7741 if (SWIG_arg_fail(2)) SWIG_fail;
7742 if (arg2 == NULL) {
7743 SWIG_null_ref("wxBitmap");
7744 }
7745 if (SWIG_arg_fail(2)) SWIG_fail;
7746 }
7747 {
7748 PyThreadState* __tstate = wxPyBeginAllowThreads();
7749 result = (bool)(arg1)->Union((wxBitmap const &)*arg2);
7750
7751 wxPyEndAllowThreads(__tstate);
7752 if (PyErr_Occurred()) SWIG_fail;
7753 }
7754 {
7755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7756 }
7757 return resultobj;
7758 fail:
7759 return NULL;
7760 }
7761
7762
7763 static PyObject *_wrap_Region_UnionBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
7764 PyObject *resultobj;
7765 wxRegion *arg1 = (wxRegion *) 0 ;
7766 wxBitmap *arg2 = 0 ;
7767 wxColour *arg3 = 0 ;
7768 int arg4 = (int) 0 ;
7769 bool result;
7770 wxColour temp3 ;
7771 PyObject * obj0 = 0 ;
7772 PyObject * obj1 = 0 ;
7773 PyObject * obj2 = 0 ;
7774 PyObject * obj3 = 0 ;
7775 char *kwnames[] = {
7776 (char *) "self",(char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
7777 };
7778
7779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Region_UnionBitmapColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7781 if (SWIG_arg_fail(1)) SWIG_fail;
7782 {
7783 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7784 if (SWIG_arg_fail(2)) SWIG_fail;
7785 if (arg2 == NULL) {
7786 SWIG_null_ref("wxBitmap");
7787 }
7788 if (SWIG_arg_fail(2)) SWIG_fail;
7789 }
7790 {
7791 arg3 = &temp3;
7792 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
7793 }
7794 if (obj3) {
7795 {
7796 arg4 = (int)(SWIG_As_int(obj3));
7797 if (SWIG_arg_fail(4)) SWIG_fail;
7798 }
7799 }
7800 {
7801 PyThreadState* __tstate = wxPyBeginAllowThreads();
7802 result = (bool)(arg1)->Union((wxBitmap const &)*arg2,(wxColour const &)*arg3,arg4);
7803
7804 wxPyEndAllowThreads(__tstate);
7805 if (PyErr_Occurred()) SWIG_fail;
7806 }
7807 {
7808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7809 }
7810 return resultobj;
7811 fail:
7812 return NULL;
7813 }
7814
7815
7816 static PyObject * Region_swigregister(PyObject *, PyObject *args) {
7817 PyObject *obj;
7818 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7819 SWIG_TypeClientData(SWIGTYPE_p_wxRegion, obj);
7820 Py_INCREF(obj);
7821 return Py_BuildValue((char *)"");
7822 }
7823 static PyObject *_wrap_new_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7824 PyObject *resultobj;
7825 wxRegion *arg1 = 0 ;
7826 wxRegionIterator *result;
7827 PyObject * obj0 = 0 ;
7828 char *kwnames[] = {
7829 (char *) "region", NULL
7830 };
7831
7832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionIterator",kwnames,&obj0)) goto fail;
7833 {
7834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7835 if (SWIG_arg_fail(1)) SWIG_fail;
7836 if (arg1 == NULL) {
7837 SWIG_null_ref("wxRegion");
7838 }
7839 if (SWIG_arg_fail(1)) SWIG_fail;
7840 }
7841 {
7842 if (!wxPyCheckForApp()) SWIG_fail;
7843 PyThreadState* __tstate = wxPyBeginAllowThreads();
7844 result = (wxRegionIterator *)new wxRegionIterator((wxRegion const &)*arg1);
7845
7846 wxPyEndAllowThreads(__tstate);
7847 if (PyErr_Occurred()) SWIG_fail;
7848 }
7849 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegionIterator, 1);
7850 return resultobj;
7851 fail:
7852 return NULL;
7853 }
7854
7855
7856 static PyObject *_wrap_delete_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7857 PyObject *resultobj;
7858 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7859 PyObject * obj0 = 0 ;
7860 char *kwnames[] = {
7861 (char *) "self", NULL
7862 };
7863
7864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RegionIterator",kwnames,&obj0)) goto fail;
7865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7866 if (SWIG_arg_fail(1)) SWIG_fail;
7867 {
7868 PyThreadState* __tstate = wxPyBeginAllowThreads();
7869 delete arg1;
7870
7871 wxPyEndAllowThreads(__tstate);
7872 if (PyErr_Occurred()) SWIG_fail;
7873 }
7874 Py_INCREF(Py_None); resultobj = Py_None;
7875 return resultobj;
7876 fail:
7877 return NULL;
7878 }
7879
7880
7881 static PyObject *_wrap_RegionIterator_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
7882 PyObject *resultobj;
7883 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7884 int result;
7885 PyObject * obj0 = 0 ;
7886 char *kwnames[] = {
7887 (char *) "self", NULL
7888 };
7889
7890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetX",kwnames,&obj0)) goto fail;
7891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7892 if (SWIG_arg_fail(1)) SWIG_fail;
7893 {
7894 PyThreadState* __tstate = wxPyBeginAllowThreads();
7895 result = (int)(arg1)->GetX();
7896
7897 wxPyEndAllowThreads(__tstate);
7898 if (PyErr_Occurred()) SWIG_fail;
7899 }
7900 {
7901 resultobj = SWIG_From_int((int)(result));
7902 }
7903 return resultobj;
7904 fail:
7905 return NULL;
7906 }
7907
7908
7909 static PyObject *_wrap_RegionIterator_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
7910 PyObject *resultobj;
7911 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7912 int result;
7913 PyObject * obj0 = 0 ;
7914 char *kwnames[] = {
7915 (char *) "self", NULL
7916 };
7917
7918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetY",kwnames,&obj0)) goto fail;
7919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7920 if (SWIG_arg_fail(1)) SWIG_fail;
7921 {
7922 PyThreadState* __tstate = wxPyBeginAllowThreads();
7923 result = (int)(arg1)->GetY();
7924
7925 wxPyEndAllowThreads(__tstate);
7926 if (PyErr_Occurred()) SWIG_fail;
7927 }
7928 {
7929 resultobj = SWIG_From_int((int)(result));
7930 }
7931 return resultobj;
7932 fail:
7933 return NULL;
7934 }
7935
7936
7937 static PyObject *_wrap_RegionIterator_GetW(PyObject *, PyObject *args, PyObject *kwargs) {
7938 PyObject *resultobj;
7939 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7940 int result;
7941 PyObject * obj0 = 0 ;
7942 char *kwnames[] = {
7943 (char *) "self", NULL
7944 };
7945
7946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetW",kwnames,&obj0)) goto fail;
7947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7948 if (SWIG_arg_fail(1)) SWIG_fail;
7949 {
7950 PyThreadState* __tstate = wxPyBeginAllowThreads();
7951 result = (int)(arg1)->GetW();
7952
7953 wxPyEndAllowThreads(__tstate);
7954 if (PyErr_Occurred()) SWIG_fail;
7955 }
7956 {
7957 resultobj = SWIG_From_int((int)(result));
7958 }
7959 return resultobj;
7960 fail:
7961 return NULL;
7962 }
7963
7964
7965 static PyObject *_wrap_RegionIterator_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
7966 PyObject *resultobj;
7967 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7968 int result;
7969 PyObject * obj0 = 0 ;
7970 char *kwnames[] = {
7971 (char *) "self", NULL
7972 };
7973
7974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetWidth",kwnames,&obj0)) goto fail;
7975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7976 if (SWIG_arg_fail(1)) SWIG_fail;
7977 {
7978 PyThreadState* __tstate = wxPyBeginAllowThreads();
7979 result = (int)(arg1)->GetWidth();
7980
7981 wxPyEndAllowThreads(__tstate);
7982 if (PyErr_Occurred()) SWIG_fail;
7983 }
7984 {
7985 resultobj = SWIG_From_int((int)(result));
7986 }
7987 return resultobj;
7988 fail:
7989 return NULL;
7990 }
7991
7992
7993 static PyObject *_wrap_RegionIterator_GetH(PyObject *, PyObject *args, PyObject *kwargs) {
7994 PyObject *resultobj;
7995 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7996 int result;
7997 PyObject * obj0 = 0 ;
7998 char *kwnames[] = {
7999 (char *) "self", NULL
8000 };
8001
8002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetH",kwnames,&obj0)) goto fail;
8003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8004 if (SWIG_arg_fail(1)) SWIG_fail;
8005 {
8006 PyThreadState* __tstate = wxPyBeginAllowThreads();
8007 result = (int)(arg1)->GetH();
8008
8009 wxPyEndAllowThreads(__tstate);
8010 if (PyErr_Occurred()) SWIG_fail;
8011 }
8012 {
8013 resultobj = SWIG_From_int((int)(result));
8014 }
8015 return resultobj;
8016 fail:
8017 return NULL;
8018 }
8019
8020
8021 static PyObject *_wrap_RegionIterator_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
8022 PyObject *resultobj;
8023 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8024 int result;
8025 PyObject * obj0 = 0 ;
8026 char *kwnames[] = {
8027 (char *) "self", NULL
8028 };
8029
8030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetHeight",kwnames,&obj0)) goto fail;
8031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8032 if (SWIG_arg_fail(1)) SWIG_fail;
8033 {
8034 PyThreadState* __tstate = wxPyBeginAllowThreads();
8035 result = (int)(arg1)->GetHeight();
8036
8037 wxPyEndAllowThreads(__tstate);
8038 if (PyErr_Occurred()) SWIG_fail;
8039 }
8040 {
8041 resultobj = SWIG_From_int((int)(result));
8042 }
8043 return resultobj;
8044 fail:
8045 return NULL;
8046 }
8047
8048
8049 static PyObject *_wrap_RegionIterator_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
8050 PyObject *resultobj;
8051 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8052 wxRect result;
8053 PyObject * obj0 = 0 ;
8054 char *kwnames[] = {
8055 (char *) "self", NULL
8056 };
8057
8058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetRect",kwnames,&obj0)) goto fail;
8059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8060 if (SWIG_arg_fail(1)) SWIG_fail;
8061 {
8062 PyThreadState* __tstate = wxPyBeginAllowThreads();
8063 result = (arg1)->GetRect();
8064
8065 wxPyEndAllowThreads(__tstate);
8066 if (PyErr_Occurred()) SWIG_fail;
8067 }
8068 {
8069 wxRect * resultptr;
8070 resultptr = new wxRect((wxRect &)(result));
8071 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
8072 }
8073 return resultobj;
8074 fail:
8075 return NULL;
8076 }
8077
8078
8079 static PyObject *_wrap_RegionIterator_HaveRects(PyObject *, PyObject *args, PyObject *kwargs) {
8080 PyObject *resultobj;
8081 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8082 bool result;
8083 PyObject * obj0 = 0 ;
8084 char *kwnames[] = {
8085 (char *) "self", NULL
8086 };
8087
8088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_HaveRects",kwnames,&obj0)) goto fail;
8089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8090 if (SWIG_arg_fail(1)) SWIG_fail;
8091 {
8092 PyThreadState* __tstate = wxPyBeginAllowThreads();
8093 result = (bool)(arg1)->HaveRects();
8094
8095 wxPyEndAllowThreads(__tstate);
8096 if (PyErr_Occurred()) SWIG_fail;
8097 }
8098 {
8099 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8100 }
8101 return resultobj;
8102 fail:
8103 return NULL;
8104 }
8105
8106
8107 static PyObject *_wrap_RegionIterator_Reset(PyObject *, PyObject *args, PyObject *kwargs) {
8108 PyObject *resultobj;
8109 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8110 PyObject * obj0 = 0 ;
8111 char *kwnames[] = {
8112 (char *) "self", NULL
8113 };
8114
8115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Reset",kwnames,&obj0)) goto fail;
8116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8117 if (SWIG_arg_fail(1)) SWIG_fail;
8118 {
8119 PyThreadState* __tstate = wxPyBeginAllowThreads();
8120 (arg1)->Reset();
8121
8122 wxPyEndAllowThreads(__tstate);
8123 if (PyErr_Occurred()) SWIG_fail;
8124 }
8125 Py_INCREF(Py_None); resultobj = Py_None;
8126 return resultobj;
8127 fail:
8128 return NULL;
8129 }
8130
8131
8132 static PyObject *_wrap_RegionIterator_Next(PyObject *, PyObject *args, PyObject *kwargs) {
8133 PyObject *resultobj;
8134 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8135 PyObject * obj0 = 0 ;
8136 char *kwnames[] = {
8137 (char *) "self", NULL
8138 };
8139
8140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Next",kwnames,&obj0)) goto fail;
8141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8142 if (SWIG_arg_fail(1)) SWIG_fail;
8143 {
8144 PyThreadState* __tstate = wxPyBeginAllowThreads();
8145 wxRegionIterator_Next(arg1);
8146
8147 wxPyEndAllowThreads(__tstate);
8148 if (PyErr_Occurred()) SWIG_fail;
8149 }
8150 Py_INCREF(Py_None); resultobj = Py_None;
8151 return resultobj;
8152 fail:
8153 return NULL;
8154 }
8155
8156
8157 static PyObject *_wrap_RegionIterator___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
8158 PyObject *resultobj;
8159 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
8160 bool result;
8161 PyObject * obj0 = 0 ;
8162 char *kwnames[] = {
8163 (char *) "self", NULL
8164 };
8165
8166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator___nonzero__",kwnames,&obj0)) goto fail;
8167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
8168 if (SWIG_arg_fail(1)) SWIG_fail;
8169 {
8170 PyThreadState* __tstate = wxPyBeginAllowThreads();
8171 result = (bool)wxRegionIterator___nonzero__(arg1);
8172
8173 wxPyEndAllowThreads(__tstate);
8174 if (PyErr_Occurred()) SWIG_fail;
8175 }
8176 {
8177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8178 }
8179 return resultobj;
8180 fail:
8181 return NULL;
8182 }
8183
8184
8185 static PyObject * RegionIterator_swigregister(PyObject *, PyObject *args) {
8186 PyObject *obj;
8187 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8188 SWIG_TypeClientData(SWIGTYPE_p_wxRegionIterator, obj);
8189 Py_INCREF(obj);
8190 return Py_BuildValue((char *)"");
8191 }
8192 static PyObject *_wrap_new_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8193 PyObject *resultobj;
8194 wxNativeFontInfo *result;
8195 char *kwnames[] = {
8196 NULL
8197 };
8198
8199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeFontInfo",kwnames)) goto fail;
8200 {
8201 PyThreadState* __tstate = wxPyBeginAllowThreads();
8202 result = (wxNativeFontInfo *)new wxNativeFontInfo();
8203
8204 wxPyEndAllowThreads(__tstate);
8205 if (PyErr_Occurred()) SWIG_fail;
8206 }
8207 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 1);
8208 return resultobj;
8209 fail:
8210 return NULL;
8211 }
8212
8213
8214 static PyObject *_wrap_delete_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8215 PyObject *resultobj;
8216 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8217 PyObject * obj0 = 0 ;
8218 char *kwnames[] = {
8219 (char *) "self", NULL
8220 };
8221
8222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeFontInfo",kwnames,&obj0)) goto fail;
8223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8224 if (SWIG_arg_fail(1)) SWIG_fail;
8225 {
8226 PyThreadState* __tstate = wxPyBeginAllowThreads();
8227 delete arg1;
8228
8229 wxPyEndAllowThreads(__tstate);
8230 if (PyErr_Occurred()) SWIG_fail;
8231 }
8232 Py_INCREF(Py_None); resultobj = Py_None;
8233 return resultobj;
8234 fail:
8235 return NULL;
8236 }
8237
8238
8239 static PyObject *_wrap_NativeFontInfo_Init(PyObject *, PyObject *args, PyObject *kwargs) {
8240 PyObject *resultobj;
8241 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8242 PyObject * obj0 = 0 ;
8243 char *kwnames[] = {
8244 (char *) "self", NULL
8245 };
8246
8247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_Init",kwnames,&obj0)) goto fail;
8248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8249 if (SWIG_arg_fail(1)) SWIG_fail;
8250 {
8251 PyThreadState* __tstate = wxPyBeginAllowThreads();
8252 (arg1)->Init();
8253
8254 wxPyEndAllowThreads(__tstate);
8255 if (PyErr_Occurred()) SWIG_fail;
8256 }
8257 Py_INCREF(Py_None); resultobj = Py_None;
8258 return resultobj;
8259 fail:
8260 return NULL;
8261 }
8262
8263
8264 static PyObject *_wrap_NativeFontInfo_InitFromFont(PyObject *, PyObject *args, PyObject *kwargs) {
8265 PyObject *resultobj;
8266 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8267 wxFont *arg2 = 0 ;
8268 PyObject * obj0 = 0 ;
8269 PyObject * obj1 = 0 ;
8270 char *kwnames[] = {
8271 (char *) "self",(char *) "font", NULL
8272 };
8273
8274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_InitFromFont",kwnames,&obj0,&obj1)) goto fail;
8275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8276 if (SWIG_arg_fail(1)) SWIG_fail;
8277 {
8278 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
8279 if (SWIG_arg_fail(2)) SWIG_fail;
8280 if (arg2 == NULL) {
8281 SWIG_null_ref("wxFont");
8282 }
8283 if (SWIG_arg_fail(2)) SWIG_fail;
8284 }
8285 {
8286 PyThreadState* __tstate = wxPyBeginAllowThreads();
8287 (arg1)->InitFromFont((wxFont const &)*arg2);
8288
8289 wxPyEndAllowThreads(__tstate);
8290 if (PyErr_Occurred()) SWIG_fail;
8291 }
8292 Py_INCREF(Py_None); resultobj = Py_None;
8293 return resultobj;
8294 fail:
8295 return NULL;
8296 }
8297
8298
8299 static PyObject *_wrap_NativeFontInfo_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
8300 PyObject *resultobj;
8301 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8302 int result;
8303 PyObject * obj0 = 0 ;
8304 char *kwnames[] = {
8305 (char *) "self", NULL
8306 };
8307
8308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetPointSize",kwnames,&obj0)) goto fail;
8309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8310 if (SWIG_arg_fail(1)) SWIG_fail;
8311 {
8312 PyThreadState* __tstate = wxPyBeginAllowThreads();
8313 result = (int)((wxNativeFontInfo const *)arg1)->GetPointSize();
8314
8315 wxPyEndAllowThreads(__tstate);
8316 if (PyErr_Occurred()) SWIG_fail;
8317 }
8318 {
8319 resultobj = SWIG_From_int((int)(result));
8320 }
8321 return resultobj;
8322 fail:
8323 return NULL;
8324 }
8325
8326
8327 static PyObject *_wrap_NativeFontInfo_GetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
8328 PyObject *resultobj;
8329 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8330 wxSize result;
8331 PyObject * obj0 = 0 ;
8332 char *kwnames[] = {
8333 (char *) "self", NULL
8334 };
8335
8336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetPixelSize",kwnames,&obj0)) goto fail;
8337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8338 if (SWIG_arg_fail(1)) SWIG_fail;
8339 {
8340 PyThreadState* __tstate = wxPyBeginAllowThreads();
8341 result = ((wxNativeFontInfo const *)arg1)->GetPixelSize();
8342
8343 wxPyEndAllowThreads(__tstate);
8344 if (PyErr_Occurred()) SWIG_fail;
8345 }
8346 {
8347 wxSize * resultptr;
8348 resultptr = new wxSize((wxSize &)(result));
8349 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
8350 }
8351 return resultobj;
8352 fail:
8353 return NULL;
8354 }
8355
8356
8357 static PyObject *_wrap_NativeFontInfo_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
8358 PyObject *resultobj;
8359 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8360 wxFontStyle result;
8361 PyObject * obj0 = 0 ;
8362 char *kwnames[] = {
8363 (char *) "self", NULL
8364 };
8365
8366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetStyle",kwnames,&obj0)) goto fail;
8367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8368 if (SWIG_arg_fail(1)) SWIG_fail;
8369 {
8370 PyThreadState* __tstate = wxPyBeginAllowThreads();
8371 result = (wxFontStyle)((wxNativeFontInfo const *)arg1)->GetStyle();
8372
8373 wxPyEndAllowThreads(__tstate);
8374 if (PyErr_Occurred()) SWIG_fail;
8375 }
8376 resultobj = SWIG_From_int((result));
8377 return resultobj;
8378 fail:
8379 return NULL;
8380 }
8381
8382
8383 static PyObject *_wrap_NativeFontInfo_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
8384 PyObject *resultobj;
8385 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8386 wxFontWeight result;
8387 PyObject * obj0 = 0 ;
8388 char *kwnames[] = {
8389 (char *) "self", NULL
8390 };
8391
8392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetWeight",kwnames,&obj0)) goto fail;
8393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8394 if (SWIG_arg_fail(1)) SWIG_fail;
8395 {
8396 PyThreadState* __tstate = wxPyBeginAllowThreads();
8397 result = (wxFontWeight)((wxNativeFontInfo const *)arg1)->GetWeight();
8398
8399 wxPyEndAllowThreads(__tstate);
8400 if (PyErr_Occurred()) SWIG_fail;
8401 }
8402 resultobj = SWIG_From_int((result));
8403 return resultobj;
8404 fail:
8405 return NULL;
8406 }
8407
8408
8409 static PyObject *_wrap_NativeFontInfo_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
8410 PyObject *resultobj;
8411 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8412 bool result;
8413 PyObject * obj0 = 0 ;
8414 char *kwnames[] = {
8415 (char *) "self", NULL
8416 };
8417
8418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetUnderlined",kwnames,&obj0)) goto fail;
8419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8420 if (SWIG_arg_fail(1)) SWIG_fail;
8421 {
8422 PyThreadState* __tstate = wxPyBeginAllowThreads();
8423 result = (bool)((wxNativeFontInfo const *)arg1)->GetUnderlined();
8424
8425 wxPyEndAllowThreads(__tstate);
8426 if (PyErr_Occurred()) SWIG_fail;
8427 }
8428 {
8429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8430 }
8431 return resultobj;
8432 fail:
8433 return NULL;
8434 }
8435
8436
8437 static PyObject *_wrap_NativeFontInfo_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
8438 PyObject *resultobj;
8439 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8440 wxString result;
8441 PyObject * obj0 = 0 ;
8442 char *kwnames[] = {
8443 (char *) "self", NULL
8444 };
8445
8446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFaceName",kwnames,&obj0)) goto fail;
8447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8448 if (SWIG_arg_fail(1)) SWIG_fail;
8449 {
8450 PyThreadState* __tstate = wxPyBeginAllowThreads();
8451 result = ((wxNativeFontInfo const *)arg1)->GetFaceName();
8452
8453 wxPyEndAllowThreads(__tstate);
8454 if (PyErr_Occurred()) SWIG_fail;
8455 }
8456 {
8457 #if wxUSE_UNICODE
8458 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8459 #else
8460 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8461 #endif
8462 }
8463 return resultobj;
8464 fail:
8465 return NULL;
8466 }
8467
8468
8469 static PyObject *_wrap_NativeFontInfo_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
8470 PyObject *resultobj;
8471 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8472 wxFontFamily result;
8473 PyObject * obj0 = 0 ;
8474 char *kwnames[] = {
8475 (char *) "self", NULL
8476 };
8477
8478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFamily",kwnames,&obj0)) goto fail;
8479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8480 if (SWIG_arg_fail(1)) SWIG_fail;
8481 {
8482 PyThreadState* __tstate = wxPyBeginAllowThreads();
8483 result = (wxFontFamily)((wxNativeFontInfo const *)arg1)->GetFamily();
8484
8485 wxPyEndAllowThreads(__tstate);
8486 if (PyErr_Occurred()) SWIG_fail;
8487 }
8488 resultobj = SWIG_From_int((result));
8489 return resultobj;
8490 fail:
8491 return NULL;
8492 }
8493
8494
8495 static PyObject *_wrap_NativeFontInfo_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8496 PyObject *resultobj;
8497 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8498 wxFontEncoding result;
8499 PyObject * obj0 = 0 ;
8500 char *kwnames[] = {
8501 (char *) "self", NULL
8502 };
8503
8504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetEncoding",kwnames,&obj0)) goto fail;
8505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8506 if (SWIG_arg_fail(1)) SWIG_fail;
8507 {
8508 PyThreadState* __tstate = wxPyBeginAllowThreads();
8509 result = (wxFontEncoding)((wxNativeFontInfo const *)arg1)->GetEncoding();
8510
8511 wxPyEndAllowThreads(__tstate);
8512 if (PyErr_Occurred()) SWIG_fail;
8513 }
8514 resultobj = SWIG_From_int((result));
8515 return resultobj;
8516 fail:
8517 return NULL;
8518 }
8519
8520
8521 static PyObject *_wrap_NativeFontInfo_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
8522 PyObject *resultobj;
8523 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8524 int arg2 ;
8525 PyObject * obj0 = 0 ;
8526 PyObject * obj1 = 0 ;
8527 char *kwnames[] = {
8528 (char *) "self",(char *) "pointsize", NULL
8529 };
8530
8531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
8532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8533 if (SWIG_arg_fail(1)) SWIG_fail;
8534 {
8535 arg2 = (int)(SWIG_As_int(obj1));
8536 if (SWIG_arg_fail(2)) SWIG_fail;
8537 }
8538 {
8539 PyThreadState* __tstate = wxPyBeginAllowThreads();
8540 (arg1)->SetPointSize(arg2);
8541
8542 wxPyEndAllowThreads(__tstate);
8543 if (PyErr_Occurred()) SWIG_fail;
8544 }
8545 Py_INCREF(Py_None); resultobj = Py_None;
8546 return resultobj;
8547 fail:
8548 return NULL;
8549 }
8550
8551
8552 static PyObject *_wrap_NativeFontInfo_SetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
8553 PyObject *resultobj;
8554 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8555 wxSize *arg2 = 0 ;
8556 wxSize temp2 ;
8557 PyObject * obj0 = 0 ;
8558 PyObject * obj1 = 0 ;
8559 char *kwnames[] = {
8560 (char *) "self",(char *) "pixelSize", NULL
8561 };
8562
8563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetPixelSize",kwnames,&obj0,&obj1)) goto fail;
8564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8565 if (SWIG_arg_fail(1)) SWIG_fail;
8566 {
8567 arg2 = &temp2;
8568 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8569 }
8570 {
8571 PyThreadState* __tstate = wxPyBeginAllowThreads();
8572 (arg1)->SetPixelSize((wxSize const &)*arg2);
8573
8574 wxPyEndAllowThreads(__tstate);
8575 if (PyErr_Occurred()) SWIG_fail;
8576 }
8577 Py_INCREF(Py_None); resultobj = Py_None;
8578 return resultobj;
8579 fail:
8580 return NULL;
8581 }
8582
8583
8584 static PyObject *_wrap_NativeFontInfo_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
8585 PyObject *resultobj;
8586 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8587 wxFontStyle arg2 ;
8588 PyObject * obj0 = 0 ;
8589 PyObject * obj1 = 0 ;
8590 char *kwnames[] = {
8591 (char *) "self",(char *) "style", NULL
8592 };
8593
8594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetStyle",kwnames,&obj0,&obj1)) goto fail;
8595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8596 if (SWIG_arg_fail(1)) SWIG_fail;
8597 {
8598 arg2 = (wxFontStyle)(SWIG_As_int(obj1));
8599 if (SWIG_arg_fail(2)) SWIG_fail;
8600 }
8601 {
8602 PyThreadState* __tstate = wxPyBeginAllowThreads();
8603 (arg1)->SetStyle((wxFontStyle )arg2);
8604
8605 wxPyEndAllowThreads(__tstate);
8606 if (PyErr_Occurred()) SWIG_fail;
8607 }
8608 Py_INCREF(Py_None); resultobj = Py_None;
8609 return resultobj;
8610 fail:
8611 return NULL;
8612 }
8613
8614
8615 static PyObject *_wrap_NativeFontInfo_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
8616 PyObject *resultobj;
8617 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8618 wxFontWeight arg2 ;
8619 PyObject * obj0 = 0 ;
8620 PyObject * obj1 = 0 ;
8621 char *kwnames[] = {
8622 (char *) "self",(char *) "weight", NULL
8623 };
8624
8625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetWeight",kwnames,&obj0,&obj1)) goto fail;
8626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8627 if (SWIG_arg_fail(1)) SWIG_fail;
8628 {
8629 arg2 = (wxFontWeight)(SWIG_As_int(obj1));
8630 if (SWIG_arg_fail(2)) SWIG_fail;
8631 }
8632 {
8633 PyThreadState* __tstate = wxPyBeginAllowThreads();
8634 (arg1)->SetWeight((wxFontWeight )arg2);
8635
8636 wxPyEndAllowThreads(__tstate);
8637 if (PyErr_Occurred()) SWIG_fail;
8638 }
8639 Py_INCREF(Py_None); resultobj = Py_None;
8640 return resultobj;
8641 fail:
8642 return NULL;
8643 }
8644
8645
8646 static PyObject *_wrap_NativeFontInfo_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
8647 PyObject *resultobj;
8648 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8649 bool arg2 ;
8650 PyObject * obj0 = 0 ;
8651 PyObject * obj1 = 0 ;
8652 char *kwnames[] = {
8653 (char *) "self",(char *) "underlined", NULL
8654 };
8655
8656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
8657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8658 if (SWIG_arg_fail(1)) SWIG_fail;
8659 {
8660 arg2 = (bool)(SWIG_As_bool(obj1));
8661 if (SWIG_arg_fail(2)) SWIG_fail;
8662 }
8663 {
8664 PyThreadState* __tstate = wxPyBeginAllowThreads();
8665 (arg1)->SetUnderlined(arg2);
8666
8667 wxPyEndAllowThreads(__tstate);
8668 if (PyErr_Occurred()) SWIG_fail;
8669 }
8670 Py_INCREF(Py_None); resultobj = Py_None;
8671 return resultobj;
8672 fail:
8673 return NULL;
8674 }
8675
8676
8677 static PyObject *_wrap_NativeFontInfo_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
8678 PyObject *resultobj;
8679 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8680 wxString arg2 ;
8681 PyObject * obj0 = 0 ;
8682 PyObject * obj1 = 0 ;
8683 char *kwnames[] = {
8684 (char *) "self",(char *) "facename", NULL
8685 };
8686
8687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
8688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8689 if (SWIG_arg_fail(1)) SWIG_fail;
8690 {
8691 wxString* sptr = wxString_in_helper(obj1);
8692 if (sptr == NULL) SWIG_fail;
8693 arg2 = *sptr;
8694 delete sptr;
8695 }
8696 {
8697 PyThreadState* __tstate = wxPyBeginAllowThreads();
8698 (arg1)->SetFaceName(arg2);
8699
8700 wxPyEndAllowThreads(__tstate);
8701 if (PyErr_Occurred()) SWIG_fail;
8702 }
8703 Py_INCREF(Py_None); resultobj = Py_None;
8704 return resultobj;
8705 fail:
8706 return NULL;
8707 }
8708
8709
8710 static PyObject *_wrap_NativeFontInfo_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
8711 PyObject *resultobj;
8712 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8713 wxFontFamily arg2 ;
8714 PyObject * obj0 = 0 ;
8715 PyObject * obj1 = 0 ;
8716 char *kwnames[] = {
8717 (char *) "self",(char *) "family", NULL
8718 };
8719
8720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFamily",kwnames,&obj0,&obj1)) goto fail;
8721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8722 if (SWIG_arg_fail(1)) SWIG_fail;
8723 {
8724 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
8725 if (SWIG_arg_fail(2)) SWIG_fail;
8726 }
8727 {
8728 PyThreadState* __tstate = wxPyBeginAllowThreads();
8729 (arg1)->SetFamily((wxFontFamily )arg2);
8730
8731 wxPyEndAllowThreads(__tstate);
8732 if (PyErr_Occurred()) SWIG_fail;
8733 }
8734 Py_INCREF(Py_None); resultobj = Py_None;
8735 return resultobj;
8736 fail:
8737 return NULL;
8738 }
8739
8740
8741 static PyObject *_wrap_NativeFontInfo_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8742 PyObject *resultobj;
8743 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8744 wxFontEncoding arg2 ;
8745 PyObject * obj0 = 0 ;
8746 PyObject * obj1 = 0 ;
8747 char *kwnames[] = {
8748 (char *) "self",(char *) "encoding", NULL
8749 };
8750
8751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
8752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8753 if (SWIG_arg_fail(1)) SWIG_fail;
8754 {
8755 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8756 if (SWIG_arg_fail(2)) SWIG_fail;
8757 }
8758 {
8759 PyThreadState* __tstate = wxPyBeginAllowThreads();
8760 (arg1)->SetEncoding((wxFontEncoding )arg2);
8761
8762 wxPyEndAllowThreads(__tstate);
8763 if (PyErr_Occurred()) SWIG_fail;
8764 }
8765 Py_INCREF(Py_None); resultobj = Py_None;
8766 return resultobj;
8767 fail:
8768 return NULL;
8769 }
8770
8771
8772 static PyObject *_wrap_NativeFontInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
8773 PyObject *resultobj;
8774 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8775 wxString *arg2 = 0 ;
8776 bool result;
8777 bool temp2 = false ;
8778 PyObject * obj0 = 0 ;
8779 PyObject * obj1 = 0 ;
8780 char *kwnames[] = {
8781 (char *) "self",(char *) "s", NULL
8782 };
8783
8784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
8785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8786 if (SWIG_arg_fail(1)) SWIG_fail;
8787 {
8788 arg2 = wxString_in_helper(obj1);
8789 if (arg2 == NULL) SWIG_fail;
8790 temp2 = true;
8791 }
8792 {
8793 PyThreadState* __tstate = wxPyBeginAllowThreads();
8794 result = (bool)(arg1)->FromString((wxString const &)*arg2);
8795
8796 wxPyEndAllowThreads(__tstate);
8797 if (PyErr_Occurred()) SWIG_fail;
8798 }
8799 {
8800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8801 }
8802 {
8803 if (temp2)
8804 delete arg2;
8805 }
8806 return resultobj;
8807 fail:
8808 {
8809 if (temp2)
8810 delete arg2;
8811 }
8812 return NULL;
8813 }
8814
8815
8816 static PyObject *_wrap_NativeFontInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
8817 PyObject *resultobj;
8818 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8819 wxString result;
8820 PyObject * obj0 = 0 ;
8821 char *kwnames[] = {
8822 (char *) "self", NULL
8823 };
8824
8825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToString",kwnames,&obj0)) goto fail;
8826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8827 if (SWIG_arg_fail(1)) SWIG_fail;
8828 {
8829 PyThreadState* __tstate = wxPyBeginAllowThreads();
8830 result = ((wxNativeFontInfo const *)arg1)->ToString();
8831
8832 wxPyEndAllowThreads(__tstate);
8833 if (PyErr_Occurred()) SWIG_fail;
8834 }
8835 {
8836 #if wxUSE_UNICODE
8837 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8838 #else
8839 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8840 #endif
8841 }
8842 return resultobj;
8843 fail:
8844 return NULL;
8845 }
8846
8847
8848 static PyObject *_wrap_NativeFontInfo___str__(PyObject *, PyObject *args, PyObject *kwargs) {
8849 PyObject *resultobj;
8850 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8851 wxString result;
8852 PyObject * obj0 = 0 ;
8853 char *kwnames[] = {
8854 (char *) "self", NULL
8855 };
8856
8857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo___str__",kwnames,&obj0)) goto fail;
8858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8859 if (SWIG_arg_fail(1)) SWIG_fail;
8860 {
8861 PyThreadState* __tstate = wxPyBeginAllowThreads();
8862 result = wxNativeFontInfo___str__(arg1);
8863
8864 wxPyEndAllowThreads(__tstate);
8865 if (PyErr_Occurred()) SWIG_fail;
8866 }
8867 {
8868 #if wxUSE_UNICODE
8869 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8870 #else
8871 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8872 #endif
8873 }
8874 return resultobj;
8875 fail:
8876 return NULL;
8877 }
8878
8879
8880 static PyObject *_wrap_NativeFontInfo_FromUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8881 PyObject *resultobj;
8882 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8883 wxString *arg2 = 0 ;
8884 bool result;
8885 bool temp2 = false ;
8886 PyObject * obj0 = 0 ;
8887 PyObject * obj1 = 0 ;
8888 char *kwnames[] = {
8889 (char *) "self",(char *) "s", NULL
8890 };
8891
8892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromUserString",kwnames,&obj0,&obj1)) goto fail;
8893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8894 if (SWIG_arg_fail(1)) SWIG_fail;
8895 {
8896 arg2 = wxString_in_helper(obj1);
8897 if (arg2 == NULL) SWIG_fail;
8898 temp2 = true;
8899 }
8900 {
8901 PyThreadState* __tstate = wxPyBeginAllowThreads();
8902 result = (bool)(arg1)->FromUserString((wxString const &)*arg2);
8903
8904 wxPyEndAllowThreads(__tstate);
8905 if (PyErr_Occurred()) SWIG_fail;
8906 }
8907 {
8908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8909 }
8910 {
8911 if (temp2)
8912 delete arg2;
8913 }
8914 return resultobj;
8915 fail:
8916 {
8917 if (temp2)
8918 delete arg2;
8919 }
8920 return NULL;
8921 }
8922
8923
8924 static PyObject *_wrap_NativeFontInfo_ToUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8925 PyObject *resultobj;
8926 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8927 wxString result;
8928 PyObject * obj0 = 0 ;
8929 char *kwnames[] = {
8930 (char *) "self", NULL
8931 };
8932
8933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToUserString",kwnames,&obj0)) goto fail;
8934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8935 if (SWIG_arg_fail(1)) SWIG_fail;
8936 {
8937 PyThreadState* __tstate = wxPyBeginAllowThreads();
8938 result = ((wxNativeFontInfo const *)arg1)->ToUserString();
8939
8940 wxPyEndAllowThreads(__tstate);
8941 if (PyErr_Occurred()) SWIG_fail;
8942 }
8943 {
8944 #if wxUSE_UNICODE
8945 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8946 #else
8947 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8948 #endif
8949 }
8950 return resultobj;
8951 fail:
8952 return NULL;
8953 }
8954
8955
8956 static PyObject * NativeFontInfo_swigregister(PyObject *, PyObject *args) {
8957 PyObject *obj;
8958 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8959 SWIG_TypeClientData(SWIGTYPE_p_wxNativeFontInfo, obj);
8960 Py_INCREF(obj);
8961 return Py_BuildValue((char *)"");
8962 }
8963 static PyObject *_wrap_NativeEncodingInfo_facename_set(PyObject *, PyObject *args, PyObject *kwargs) {
8964 PyObject *resultobj;
8965 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8966 wxString *arg2 = (wxString *) 0 ;
8967 bool temp2 = false ;
8968 PyObject * obj0 = 0 ;
8969 PyObject * obj1 = 0 ;
8970 char *kwnames[] = {
8971 (char *) "self",(char *) "facename", NULL
8972 };
8973
8974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_facename_set",kwnames,&obj0,&obj1)) goto fail;
8975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8976 if (SWIG_arg_fail(1)) SWIG_fail;
8977 {
8978 arg2 = wxString_in_helper(obj1);
8979 if (arg2 == NULL) SWIG_fail;
8980 temp2 = true;
8981 }
8982 if (arg1) (arg1)->facename = *arg2;
8983
8984 Py_INCREF(Py_None); resultobj = Py_None;
8985 {
8986 if (temp2)
8987 delete arg2;
8988 }
8989 return resultobj;
8990 fail:
8991 {
8992 if (temp2)
8993 delete arg2;
8994 }
8995 return NULL;
8996 }
8997
8998
8999 static PyObject *_wrap_NativeEncodingInfo_facename_get(PyObject *, PyObject *args, PyObject *kwargs) {
9000 PyObject *resultobj;
9001 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
9002 wxString *result;
9003 PyObject * obj0 = 0 ;
9004 char *kwnames[] = {
9005 (char *) "self", NULL
9006 };
9007
9008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_facename_get",kwnames,&obj0)) goto fail;
9009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9010 if (SWIG_arg_fail(1)) SWIG_fail;
9011 result = (wxString *)& ((arg1)->facename);
9012
9013 {
9014 #if wxUSE_UNICODE
9015 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9016 #else
9017 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9018 #endif
9019 }
9020 return resultobj;
9021 fail:
9022 return NULL;
9023 }
9024
9025
9026 static PyObject *_wrap_NativeEncodingInfo_encoding_set(PyObject *, PyObject *args, PyObject *kwargs) {
9027 PyObject *resultobj;
9028 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
9029 wxFontEncoding arg2 ;
9030 PyObject * obj0 = 0 ;
9031 PyObject * obj1 = 0 ;
9032 char *kwnames[] = {
9033 (char *) "self",(char *) "encoding", NULL
9034 };
9035
9036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_encoding_set",kwnames,&obj0,&obj1)) goto fail;
9037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9038 if (SWIG_arg_fail(1)) SWIG_fail;
9039 {
9040 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9041 if (SWIG_arg_fail(2)) SWIG_fail;
9042 }
9043 if (arg1) (arg1)->encoding = (wxFontEncoding )arg2;
9044
9045 Py_INCREF(Py_None); resultobj = Py_None;
9046 return resultobj;
9047 fail:
9048 return NULL;
9049 }
9050
9051
9052 static PyObject *_wrap_NativeEncodingInfo_encoding_get(PyObject *, PyObject *args, PyObject *kwargs) {
9053 PyObject *resultobj;
9054 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
9055 wxFontEncoding result;
9056 PyObject * obj0 = 0 ;
9057 char *kwnames[] = {
9058 (char *) "self", NULL
9059 };
9060
9061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_encoding_get",kwnames,&obj0)) goto fail;
9062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9063 if (SWIG_arg_fail(1)) SWIG_fail;
9064 result = (wxFontEncoding) ((arg1)->encoding);
9065
9066 resultobj = SWIG_From_int((result));
9067 return resultobj;
9068 fail:
9069 return NULL;
9070 }
9071
9072
9073 static PyObject *_wrap_new_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9074 PyObject *resultobj;
9075 wxNativeEncodingInfo *result;
9076 char *kwnames[] = {
9077 NULL
9078 };
9079
9080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeEncodingInfo",kwnames)) goto fail;
9081 {
9082 PyThreadState* __tstate = wxPyBeginAllowThreads();
9083 result = (wxNativeEncodingInfo *)new wxNativeEncodingInfo();
9084
9085 wxPyEndAllowThreads(__tstate);
9086 if (PyErr_Occurred()) SWIG_fail;
9087 }
9088 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 1);
9089 return resultobj;
9090 fail:
9091 return NULL;
9092 }
9093
9094
9095 static PyObject *_wrap_delete_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9096 PyObject *resultobj;
9097 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
9098 PyObject * obj0 = 0 ;
9099 char *kwnames[] = {
9100 (char *) "self", NULL
9101 };
9102
9103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeEncodingInfo",kwnames,&obj0)) goto fail;
9104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9105 if (SWIG_arg_fail(1)) SWIG_fail;
9106 {
9107 PyThreadState* __tstate = wxPyBeginAllowThreads();
9108 delete arg1;
9109
9110 wxPyEndAllowThreads(__tstate);
9111 if (PyErr_Occurred()) SWIG_fail;
9112 }
9113 Py_INCREF(Py_None); resultobj = Py_None;
9114 return resultobj;
9115 fail:
9116 return NULL;
9117 }
9118
9119
9120 static PyObject *_wrap_NativeEncodingInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
9121 PyObject *resultobj;
9122 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
9123 wxString *arg2 = 0 ;
9124 bool result;
9125 bool temp2 = false ;
9126 PyObject * obj0 = 0 ;
9127 PyObject * obj1 = 0 ;
9128 char *kwnames[] = {
9129 (char *) "self",(char *) "s", NULL
9130 };
9131
9132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
9133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9134 if (SWIG_arg_fail(1)) SWIG_fail;
9135 {
9136 arg2 = wxString_in_helper(obj1);
9137 if (arg2 == NULL) SWIG_fail;
9138 temp2 = true;
9139 }
9140 {
9141 PyThreadState* __tstate = wxPyBeginAllowThreads();
9142 result = (bool)(arg1)->FromString((wxString const &)*arg2);
9143
9144 wxPyEndAllowThreads(__tstate);
9145 if (PyErr_Occurred()) SWIG_fail;
9146 }
9147 {
9148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9149 }
9150 {
9151 if (temp2)
9152 delete arg2;
9153 }
9154 return resultobj;
9155 fail:
9156 {
9157 if (temp2)
9158 delete arg2;
9159 }
9160 return NULL;
9161 }
9162
9163
9164 static PyObject *_wrap_NativeEncodingInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
9165 PyObject *resultobj;
9166 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
9167 wxString result;
9168 PyObject * obj0 = 0 ;
9169 char *kwnames[] = {
9170 (char *) "self", NULL
9171 };
9172
9173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_ToString",kwnames,&obj0)) goto fail;
9174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9175 if (SWIG_arg_fail(1)) SWIG_fail;
9176 {
9177 PyThreadState* __tstate = wxPyBeginAllowThreads();
9178 result = ((wxNativeEncodingInfo const *)arg1)->ToString();
9179
9180 wxPyEndAllowThreads(__tstate);
9181 if (PyErr_Occurred()) SWIG_fail;
9182 }
9183 {
9184 #if wxUSE_UNICODE
9185 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9186 #else
9187 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9188 #endif
9189 }
9190 return resultobj;
9191 fail:
9192 return NULL;
9193 }
9194
9195
9196 static PyObject * NativeEncodingInfo_swigregister(PyObject *, PyObject *args) {
9197 PyObject *obj;
9198 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9199 SWIG_TypeClientData(SWIGTYPE_p_wxNativeEncodingInfo, obj);
9200 Py_INCREF(obj);
9201 return Py_BuildValue((char *)"");
9202 }
9203 static PyObject *_wrap_GetNativeFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9204 PyObject *resultobj;
9205 wxFontEncoding arg1 ;
9206 wxNativeEncodingInfo *result;
9207 PyObject * obj0 = 0 ;
9208 char *kwnames[] = {
9209 (char *) "encoding", NULL
9210 };
9211
9212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetNativeFontEncoding",kwnames,&obj0)) goto fail;
9213 {
9214 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
9215 if (SWIG_arg_fail(1)) SWIG_fail;
9216 }
9217 {
9218 PyThreadState* __tstate = wxPyBeginAllowThreads();
9219 result = (wxNativeEncodingInfo *)wxGetNativeFontEncoding((wxFontEncoding )arg1);
9220
9221 wxPyEndAllowThreads(__tstate);
9222 if (PyErr_Occurred()) SWIG_fail;
9223 }
9224 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 0);
9225 return resultobj;
9226 fail:
9227 return NULL;
9228 }
9229
9230
9231 static PyObject *_wrap_TestFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9232 PyObject *resultobj;
9233 wxNativeEncodingInfo *arg1 = 0 ;
9234 bool result;
9235 PyObject * obj0 = 0 ;
9236 char *kwnames[] = {
9237 (char *) "info", NULL
9238 };
9239
9240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TestFontEncoding",kwnames,&obj0)) goto fail;
9241 {
9242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
9243 if (SWIG_arg_fail(1)) SWIG_fail;
9244 if (arg1 == NULL) {
9245 SWIG_null_ref("wxNativeEncodingInfo");
9246 }
9247 if (SWIG_arg_fail(1)) SWIG_fail;
9248 }
9249 {
9250 PyThreadState* __tstate = wxPyBeginAllowThreads();
9251 result = (bool)wxTestFontEncoding((wxNativeEncodingInfo const &)*arg1);
9252
9253 wxPyEndAllowThreads(__tstate);
9254 if (PyErr_Occurred()) SWIG_fail;
9255 }
9256 {
9257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9258 }
9259 return resultobj;
9260 fail:
9261 return NULL;
9262 }
9263
9264
9265 static PyObject *_wrap_new_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
9266 PyObject *resultobj;
9267 wxFontMapper *result;
9268 char *kwnames[] = {
9269 NULL
9270 };
9271
9272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontMapper",kwnames)) goto fail;
9273 {
9274 PyThreadState* __tstate = wxPyBeginAllowThreads();
9275 result = (wxFontMapper *)new wxFontMapper();
9276
9277 wxPyEndAllowThreads(__tstate);
9278 if (PyErr_Occurred()) SWIG_fail;
9279 }
9280 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 1);
9281 return resultobj;
9282 fail:
9283 return NULL;
9284 }
9285
9286
9287 static PyObject *_wrap_delete_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
9288 PyObject *resultobj;
9289 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9290 PyObject * obj0 = 0 ;
9291 char *kwnames[] = {
9292 (char *) "self", NULL
9293 };
9294
9295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontMapper",kwnames,&obj0)) goto fail;
9296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9297 if (SWIG_arg_fail(1)) SWIG_fail;
9298 {
9299 PyThreadState* __tstate = wxPyBeginAllowThreads();
9300 delete arg1;
9301
9302 wxPyEndAllowThreads(__tstate);
9303 if (PyErr_Occurred()) SWIG_fail;
9304 }
9305 Py_INCREF(Py_None); resultobj = Py_None;
9306 return resultobj;
9307 fail:
9308 return NULL;
9309 }
9310
9311
9312 static PyObject *_wrap_FontMapper_Get(PyObject *, PyObject *args, PyObject *kwargs) {
9313 PyObject *resultobj;
9314 wxFontMapper *result;
9315 char *kwnames[] = {
9316 NULL
9317 };
9318
9319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_Get",kwnames)) goto fail;
9320 {
9321 PyThreadState* __tstate = wxPyBeginAllowThreads();
9322 result = (wxFontMapper *)wxFontMapper::Get();
9323
9324 wxPyEndAllowThreads(__tstate);
9325 if (PyErr_Occurred()) SWIG_fail;
9326 }
9327 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
9328 return resultobj;
9329 fail:
9330 return NULL;
9331 }
9332
9333
9334 static PyObject *_wrap_FontMapper_Set(PyObject *, PyObject *args, PyObject *kwargs) {
9335 PyObject *resultobj;
9336 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9337 wxFontMapper *result;
9338 PyObject * obj0 = 0 ;
9339 char *kwnames[] = {
9340 (char *) "mapper", NULL
9341 };
9342
9343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_Set",kwnames,&obj0)) goto fail;
9344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9345 if (SWIG_arg_fail(1)) SWIG_fail;
9346 {
9347 PyThreadState* __tstate = wxPyBeginAllowThreads();
9348 result = (wxFontMapper *)wxFontMapper::Set(arg1);
9349
9350 wxPyEndAllowThreads(__tstate);
9351 if (PyErr_Occurred()) SWIG_fail;
9352 }
9353 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
9354 return resultobj;
9355 fail:
9356 return NULL;
9357 }
9358
9359
9360 static PyObject *_wrap_FontMapper_CharsetToEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9361 PyObject *resultobj;
9362 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9363 wxString *arg2 = 0 ;
9364 bool arg3 = (bool) true ;
9365 wxFontEncoding result;
9366 bool temp2 = false ;
9367 PyObject * obj0 = 0 ;
9368 PyObject * obj1 = 0 ;
9369 PyObject * obj2 = 0 ;
9370 char *kwnames[] = {
9371 (char *) "self",(char *) "charset",(char *) "interactive", NULL
9372 };
9373
9374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_CharsetToEncoding",kwnames,&obj0,&obj1,&obj2)) goto fail;
9375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9376 if (SWIG_arg_fail(1)) SWIG_fail;
9377 {
9378 arg2 = wxString_in_helper(obj1);
9379 if (arg2 == NULL) SWIG_fail;
9380 temp2 = true;
9381 }
9382 if (obj2) {
9383 {
9384 arg3 = (bool)(SWIG_As_bool(obj2));
9385 if (SWIG_arg_fail(3)) SWIG_fail;
9386 }
9387 }
9388 {
9389 PyThreadState* __tstate = wxPyBeginAllowThreads();
9390 result = (wxFontEncoding)(arg1)->CharsetToEncoding((wxString const &)*arg2,arg3);
9391
9392 wxPyEndAllowThreads(__tstate);
9393 if (PyErr_Occurred()) SWIG_fail;
9394 }
9395 resultobj = SWIG_From_int((result));
9396 {
9397 if (temp2)
9398 delete arg2;
9399 }
9400 return resultobj;
9401 fail:
9402 {
9403 if (temp2)
9404 delete arg2;
9405 }
9406 return NULL;
9407 }
9408
9409
9410 static PyObject *_wrap_FontMapper_GetSupportedEncodingsCount(PyObject *, PyObject *args, PyObject *kwargs) {
9411 PyObject *resultobj;
9412 size_t result;
9413 char *kwnames[] = {
9414 NULL
9415 };
9416
9417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetSupportedEncodingsCount",kwnames)) goto fail;
9418 {
9419 PyThreadState* __tstate = wxPyBeginAllowThreads();
9420 result = (size_t)wxFontMapper::GetSupportedEncodingsCount();
9421
9422 wxPyEndAllowThreads(__tstate);
9423 if (PyErr_Occurred()) SWIG_fail;
9424 }
9425 {
9426 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9427 }
9428 return resultobj;
9429 fail:
9430 return NULL;
9431 }
9432
9433
9434 static PyObject *_wrap_FontMapper_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9435 PyObject *resultobj;
9436 size_t arg1 ;
9437 wxFontEncoding result;
9438 PyObject * obj0 = 0 ;
9439 char *kwnames[] = {
9440 (char *) "n", NULL
9441 };
9442
9443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncoding",kwnames,&obj0)) goto fail;
9444 {
9445 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
9446 if (SWIG_arg_fail(1)) SWIG_fail;
9447 }
9448 {
9449 PyThreadState* __tstate = wxPyBeginAllowThreads();
9450 result = (wxFontEncoding)wxFontMapper::GetEncoding(arg1);
9451
9452 wxPyEndAllowThreads(__tstate);
9453 if (PyErr_Occurred()) SWIG_fail;
9454 }
9455 resultobj = SWIG_From_int((result));
9456 return resultobj;
9457 fail:
9458 return NULL;
9459 }
9460
9461
9462 static PyObject *_wrap_FontMapper_GetEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
9463 PyObject *resultobj;
9464 wxFontEncoding arg1 ;
9465 wxString result;
9466 PyObject * obj0 = 0 ;
9467 char *kwnames[] = {
9468 (char *) "encoding", NULL
9469 };
9470
9471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingName",kwnames,&obj0)) goto fail;
9472 {
9473 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
9474 if (SWIG_arg_fail(1)) SWIG_fail;
9475 }
9476 {
9477 PyThreadState* __tstate = wxPyBeginAllowThreads();
9478 result = wxFontMapper::GetEncodingName((wxFontEncoding )arg1);
9479
9480 wxPyEndAllowThreads(__tstate);
9481 if (PyErr_Occurred()) SWIG_fail;
9482 }
9483 {
9484 #if wxUSE_UNICODE
9485 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9486 #else
9487 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9488 #endif
9489 }
9490 return resultobj;
9491 fail:
9492 return NULL;
9493 }
9494
9495
9496 static PyObject *_wrap_FontMapper_GetEncodingDescription(PyObject *, PyObject *args, PyObject *kwargs) {
9497 PyObject *resultobj;
9498 wxFontEncoding arg1 ;
9499 wxString result;
9500 PyObject * obj0 = 0 ;
9501 char *kwnames[] = {
9502 (char *) "encoding", NULL
9503 };
9504
9505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingDescription",kwnames,&obj0)) goto fail;
9506 {
9507 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
9508 if (SWIG_arg_fail(1)) SWIG_fail;
9509 }
9510 {
9511 PyThreadState* __tstate = wxPyBeginAllowThreads();
9512 result = wxFontMapper::GetEncodingDescription((wxFontEncoding )arg1);
9513
9514 wxPyEndAllowThreads(__tstate);
9515 if (PyErr_Occurred()) SWIG_fail;
9516 }
9517 {
9518 #if wxUSE_UNICODE
9519 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9520 #else
9521 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9522 #endif
9523 }
9524 return resultobj;
9525 fail:
9526 return NULL;
9527 }
9528
9529
9530 static PyObject *_wrap_FontMapper_GetEncodingFromName(PyObject *, PyObject *args, PyObject *kwargs) {
9531 PyObject *resultobj;
9532 wxString *arg1 = 0 ;
9533 wxFontEncoding result;
9534 bool temp1 = false ;
9535 PyObject * obj0 = 0 ;
9536 char *kwnames[] = {
9537 (char *) "name", NULL
9538 };
9539
9540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingFromName",kwnames,&obj0)) goto fail;
9541 {
9542 arg1 = wxString_in_helper(obj0);
9543 if (arg1 == NULL) SWIG_fail;
9544 temp1 = true;
9545 }
9546 {
9547 PyThreadState* __tstate = wxPyBeginAllowThreads();
9548 result = (wxFontEncoding)wxFontMapper::GetEncodingFromName((wxString const &)*arg1);
9549
9550 wxPyEndAllowThreads(__tstate);
9551 if (PyErr_Occurred()) SWIG_fail;
9552 }
9553 resultobj = SWIG_From_int((result));
9554 {
9555 if (temp1)
9556 delete arg1;
9557 }
9558 return resultobj;
9559 fail:
9560 {
9561 if (temp1)
9562 delete arg1;
9563 }
9564 return NULL;
9565 }
9566
9567
9568 static PyObject *_wrap_FontMapper_SetConfig(PyObject *, PyObject *args, PyObject *kwargs) {
9569 PyObject *resultobj;
9570 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9571 wxConfigBase *arg2 = (wxConfigBase *) 0 ;
9572 PyObject * obj0 = 0 ;
9573 PyObject * obj1 = 0 ;
9574 char *kwnames[] = {
9575 (char *) "self",(char *) "config", NULL
9576 };
9577
9578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfig",kwnames,&obj0,&obj1)) goto fail;
9579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9580 if (SWIG_arg_fail(1)) SWIG_fail;
9581 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
9582 if (SWIG_arg_fail(2)) SWIG_fail;
9583 {
9584 PyThreadState* __tstate = wxPyBeginAllowThreads();
9585 (arg1)->SetConfig(arg2);
9586
9587 wxPyEndAllowThreads(__tstate);
9588 if (PyErr_Occurred()) SWIG_fail;
9589 }
9590 Py_INCREF(Py_None); resultobj = Py_None;
9591 return resultobj;
9592 fail:
9593 return NULL;
9594 }
9595
9596
9597 static PyObject *_wrap_FontMapper_SetConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
9598 PyObject *resultobj;
9599 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9600 wxString *arg2 = 0 ;
9601 bool temp2 = false ;
9602 PyObject * obj0 = 0 ;
9603 PyObject * obj1 = 0 ;
9604 char *kwnames[] = {
9605 (char *) "self",(char *) "prefix", NULL
9606 };
9607
9608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfigPath",kwnames,&obj0,&obj1)) goto fail;
9609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9610 if (SWIG_arg_fail(1)) SWIG_fail;
9611 {
9612 arg2 = wxString_in_helper(obj1);
9613 if (arg2 == NULL) SWIG_fail;
9614 temp2 = true;
9615 }
9616 {
9617 PyThreadState* __tstate = wxPyBeginAllowThreads();
9618 (arg1)->SetConfigPath((wxString const &)*arg2);
9619
9620 wxPyEndAllowThreads(__tstate);
9621 if (PyErr_Occurred()) SWIG_fail;
9622 }
9623 Py_INCREF(Py_None); resultobj = Py_None;
9624 {
9625 if (temp2)
9626 delete arg2;
9627 }
9628 return resultobj;
9629 fail:
9630 {
9631 if (temp2)
9632 delete arg2;
9633 }
9634 return NULL;
9635 }
9636
9637
9638 static PyObject *_wrap_FontMapper_GetDefaultConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
9639 PyObject *resultobj;
9640 wxString result;
9641 char *kwnames[] = {
9642 NULL
9643 };
9644
9645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetDefaultConfigPath",kwnames)) goto fail;
9646 {
9647 PyThreadState* __tstate = wxPyBeginAllowThreads();
9648 result = wxFontMapper::GetDefaultConfigPath();
9649
9650 wxPyEndAllowThreads(__tstate);
9651 if (PyErr_Occurred()) SWIG_fail;
9652 }
9653 {
9654 #if wxUSE_UNICODE
9655 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9656 #else
9657 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9658 #endif
9659 }
9660 return resultobj;
9661 fail:
9662 return NULL;
9663 }
9664
9665
9666 static PyObject *_wrap_FontMapper_GetAltForEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9667 PyObject *resultobj;
9668 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9669 wxFontEncoding arg2 ;
9670 wxString const &arg3_defvalue = wxPyEmptyString ;
9671 wxString *arg3 = (wxString *) &arg3_defvalue ;
9672 bool arg4 = (bool) true ;
9673 PyObject *result;
9674 bool temp3 = false ;
9675 PyObject * obj0 = 0 ;
9676 PyObject * obj1 = 0 ;
9677 PyObject * obj2 = 0 ;
9678 PyObject * obj3 = 0 ;
9679 char *kwnames[] = {
9680 (char *) "self",(char *) "encoding",(char *) "facename",(char *) "interactive", NULL
9681 };
9682
9683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:FontMapper_GetAltForEncoding",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9685 if (SWIG_arg_fail(1)) SWIG_fail;
9686 {
9687 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9688 if (SWIG_arg_fail(2)) SWIG_fail;
9689 }
9690 if (obj2) {
9691 {
9692 arg3 = wxString_in_helper(obj2);
9693 if (arg3 == NULL) SWIG_fail;
9694 temp3 = true;
9695 }
9696 }
9697 if (obj3) {
9698 {
9699 arg4 = (bool)(SWIG_As_bool(obj3));
9700 if (SWIG_arg_fail(4)) SWIG_fail;
9701 }
9702 }
9703 {
9704 PyThreadState* __tstate = wxPyBeginAllowThreads();
9705 result = (PyObject *)wxFontMapper_GetAltForEncoding(arg1,(wxFontEncoding )arg2,(wxString const &)*arg3,arg4);
9706
9707 wxPyEndAllowThreads(__tstate);
9708 if (PyErr_Occurred()) SWIG_fail;
9709 }
9710 resultobj = result;
9711 {
9712 if (temp3)
9713 delete arg3;
9714 }
9715 return resultobj;
9716 fail:
9717 {
9718 if (temp3)
9719 delete arg3;
9720 }
9721 return NULL;
9722 }
9723
9724
9725 static PyObject *_wrap_FontMapper_IsEncodingAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
9726 PyObject *resultobj;
9727 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9728 wxFontEncoding arg2 ;
9729 wxString const &arg3_defvalue = wxPyEmptyString ;
9730 wxString *arg3 = (wxString *) &arg3_defvalue ;
9731 bool result;
9732 bool temp3 = false ;
9733 PyObject * obj0 = 0 ;
9734 PyObject * obj1 = 0 ;
9735 PyObject * obj2 = 0 ;
9736 char *kwnames[] = {
9737 (char *) "self",(char *) "encoding",(char *) "facename", NULL
9738 };
9739
9740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_IsEncodingAvailable",kwnames,&obj0,&obj1,&obj2)) goto fail;
9741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9742 if (SWIG_arg_fail(1)) SWIG_fail;
9743 {
9744 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9745 if (SWIG_arg_fail(2)) SWIG_fail;
9746 }
9747 if (obj2) {
9748 {
9749 arg3 = wxString_in_helper(obj2);
9750 if (arg3 == NULL) SWIG_fail;
9751 temp3 = true;
9752 }
9753 }
9754 {
9755 PyThreadState* __tstate = wxPyBeginAllowThreads();
9756 result = (bool)(arg1)->IsEncodingAvailable((wxFontEncoding )arg2,(wxString const &)*arg3);
9757
9758 wxPyEndAllowThreads(__tstate);
9759 if (PyErr_Occurred()) SWIG_fail;
9760 }
9761 {
9762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9763 }
9764 {
9765 if (temp3)
9766 delete arg3;
9767 }
9768 return resultobj;
9769 fail:
9770 {
9771 if (temp3)
9772 delete arg3;
9773 }
9774 return NULL;
9775 }
9776
9777
9778 static PyObject *_wrap_FontMapper_SetDialogParent(PyObject *, PyObject *args, PyObject *kwargs) {
9779 PyObject *resultobj;
9780 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9781 wxWindow *arg2 = (wxWindow *) 0 ;
9782 PyObject * obj0 = 0 ;
9783 PyObject * obj1 = 0 ;
9784 char *kwnames[] = {
9785 (char *) "self",(char *) "parent", NULL
9786 };
9787
9788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogParent",kwnames,&obj0,&obj1)) goto fail;
9789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9790 if (SWIG_arg_fail(1)) SWIG_fail;
9791 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
9792 if (SWIG_arg_fail(2)) SWIG_fail;
9793 {
9794 PyThreadState* __tstate = wxPyBeginAllowThreads();
9795 (arg1)->SetDialogParent(arg2);
9796
9797 wxPyEndAllowThreads(__tstate);
9798 if (PyErr_Occurred()) SWIG_fail;
9799 }
9800 Py_INCREF(Py_None); resultobj = Py_None;
9801 return resultobj;
9802 fail:
9803 return NULL;
9804 }
9805
9806
9807 static PyObject *_wrap_FontMapper_SetDialogTitle(PyObject *, PyObject *args, PyObject *kwargs) {
9808 PyObject *resultobj;
9809 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9810 wxString *arg2 = 0 ;
9811 bool temp2 = false ;
9812 PyObject * obj0 = 0 ;
9813 PyObject * obj1 = 0 ;
9814 char *kwnames[] = {
9815 (char *) "self",(char *) "title", NULL
9816 };
9817
9818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogTitle",kwnames,&obj0,&obj1)) goto fail;
9819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9820 if (SWIG_arg_fail(1)) SWIG_fail;
9821 {
9822 arg2 = wxString_in_helper(obj1);
9823 if (arg2 == NULL) SWIG_fail;
9824 temp2 = true;
9825 }
9826 {
9827 PyThreadState* __tstate = wxPyBeginAllowThreads();
9828 (arg1)->SetDialogTitle((wxString const &)*arg2);
9829
9830 wxPyEndAllowThreads(__tstate);
9831 if (PyErr_Occurred()) SWIG_fail;
9832 }
9833 Py_INCREF(Py_None); resultobj = Py_None;
9834 {
9835 if (temp2)
9836 delete arg2;
9837 }
9838 return resultobj;
9839 fail:
9840 {
9841 if (temp2)
9842 delete arg2;
9843 }
9844 return NULL;
9845 }
9846
9847
9848 static PyObject * FontMapper_swigregister(PyObject *, PyObject *args) {
9849 PyObject *obj;
9850 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9851 SWIG_TypeClientData(SWIGTYPE_p_wxFontMapper, obj);
9852 Py_INCREF(obj);
9853 return Py_BuildValue((char *)"");
9854 }
9855 static PyObject *_wrap_new_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9856 PyObject *resultobj;
9857 int arg1 ;
9858 int arg2 ;
9859 int arg3 ;
9860 int arg4 ;
9861 bool arg5 = (bool) false ;
9862 wxString const &arg6_defvalue = wxPyEmptyString ;
9863 wxString *arg6 = (wxString *) &arg6_defvalue ;
9864 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9865 wxFont *result;
9866 bool temp6 = false ;
9867 PyObject * obj0 = 0 ;
9868 PyObject * obj1 = 0 ;
9869 PyObject * obj2 = 0 ;
9870 PyObject * obj3 = 0 ;
9871 PyObject * obj4 = 0 ;
9872 PyObject * obj5 = 0 ;
9873 PyObject * obj6 = 0 ;
9874 char *kwnames[] = {
9875 (char *) "pointSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "face",(char *) "encoding", NULL
9876 };
9877
9878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_Font",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9879 {
9880 arg1 = (int)(SWIG_As_int(obj0));
9881 if (SWIG_arg_fail(1)) SWIG_fail;
9882 }
9883 {
9884 arg2 = (int)(SWIG_As_int(obj1));
9885 if (SWIG_arg_fail(2)) SWIG_fail;
9886 }
9887 {
9888 arg3 = (int)(SWIG_As_int(obj2));
9889 if (SWIG_arg_fail(3)) SWIG_fail;
9890 }
9891 {
9892 arg4 = (int)(SWIG_As_int(obj3));
9893 if (SWIG_arg_fail(4)) SWIG_fail;
9894 }
9895 if (obj4) {
9896 {
9897 arg5 = (bool)(SWIG_As_bool(obj4));
9898 if (SWIG_arg_fail(5)) SWIG_fail;
9899 }
9900 }
9901 if (obj5) {
9902 {
9903 arg6 = wxString_in_helper(obj5);
9904 if (arg6 == NULL) SWIG_fail;
9905 temp6 = true;
9906 }
9907 }
9908 if (obj6) {
9909 {
9910 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
9911 if (SWIG_arg_fail(7)) SWIG_fail;
9912 }
9913 }
9914 {
9915 if (!wxPyCheckForApp()) SWIG_fail;
9916 PyThreadState* __tstate = wxPyBeginAllowThreads();
9917 result = (wxFont *)new wxFont(arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
9918
9919 wxPyEndAllowThreads(__tstate);
9920 if (PyErr_Occurred()) SWIG_fail;
9921 }
9922 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9923 {
9924 if (temp6)
9925 delete arg6;
9926 }
9927 return resultobj;
9928 fail:
9929 {
9930 if (temp6)
9931 delete arg6;
9932 }
9933 return NULL;
9934 }
9935
9936
9937 static PyObject *_wrap_delete_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9938 PyObject *resultobj;
9939 wxFont *arg1 = (wxFont *) 0 ;
9940 PyObject * obj0 = 0 ;
9941 char *kwnames[] = {
9942 (char *) "self", NULL
9943 };
9944
9945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Font",kwnames,&obj0)) goto fail;
9946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9947 if (SWIG_arg_fail(1)) SWIG_fail;
9948 {
9949 PyThreadState* __tstate = wxPyBeginAllowThreads();
9950 delete arg1;
9951
9952 wxPyEndAllowThreads(__tstate);
9953 if (PyErr_Occurred()) SWIG_fail;
9954 }
9955 Py_INCREF(Py_None); resultobj = Py_None;
9956 return resultobj;
9957 fail:
9958 return NULL;
9959 }
9960
9961
9962 static PyObject *_wrap_new_FontFromNativeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9963 PyObject *resultobj;
9964 wxNativeFontInfo *arg1 = 0 ;
9965 wxFont *result;
9966 PyObject * obj0 = 0 ;
9967 char *kwnames[] = {
9968 (char *) "info", NULL
9969 };
9970
9971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfo",kwnames,&obj0)) goto fail;
9972 {
9973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
9974 if (SWIG_arg_fail(1)) SWIG_fail;
9975 if (arg1 == NULL) {
9976 SWIG_null_ref("wxNativeFontInfo");
9977 }
9978 if (SWIG_arg_fail(1)) SWIG_fail;
9979 }
9980 {
9981 if (!wxPyCheckForApp()) SWIG_fail;
9982 PyThreadState* __tstate = wxPyBeginAllowThreads();
9983 result = (wxFont *)new wxFont((wxNativeFontInfo const &)*arg1);
9984
9985 wxPyEndAllowThreads(__tstate);
9986 if (PyErr_Occurred()) SWIG_fail;
9987 }
9988 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9989 return resultobj;
9990 fail:
9991 return NULL;
9992 }
9993
9994
9995 static PyObject *_wrap_new_FontFromNativeInfoString(PyObject *, PyObject *args, PyObject *kwargs) {
9996 PyObject *resultobj;
9997 wxString *arg1 = 0 ;
9998 wxFont *result;
9999 bool temp1 = false ;
10000 PyObject * obj0 = 0 ;
10001 char *kwnames[] = {
10002 (char *) "info", NULL
10003 };
10004
10005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfoString",kwnames,&obj0)) goto fail;
10006 {
10007 arg1 = wxString_in_helper(obj0);
10008 if (arg1 == NULL) SWIG_fail;
10009 temp1 = true;
10010 }
10011 {
10012 if (!wxPyCheckForApp()) SWIG_fail;
10013 PyThreadState* __tstate = wxPyBeginAllowThreads();
10014 result = (wxFont *)new_wxFont((wxString const &)*arg1);
10015
10016 wxPyEndAllowThreads(__tstate);
10017 if (PyErr_Occurred()) SWIG_fail;
10018 }
10019 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
10020 {
10021 if (temp1)
10022 delete arg1;
10023 }
10024 return resultobj;
10025 fail:
10026 {
10027 if (temp1)
10028 delete arg1;
10029 }
10030 return NULL;
10031 }
10032
10033
10034 static PyObject *_wrap_new_FFont(PyObject *, PyObject *args, PyObject *kwargs) {
10035 PyObject *resultobj;
10036 int arg1 ;
10037 wxFontFamily arg2 ;
10038 int arg3 = (int) wxFONTFLAG_DEFAULT ;
10039 wxString const &arg4_defvalue = wxPyEmptyString ;
10040 wxString *arg4 = (wxString *) &arg4_defvalue ;
10041 wxFontEncoding arg5 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
10042 wxFont *result;
10043 bool temp4 = false ;
10044 PyObject * obj0 = 0 ;
10045 PyObject * obj1 = 0 ;
10046 PyObject * obj2 = 0 ;
10047 PyObject * obj3 = 0 ;
10048 PyObject * obj4 = 0 ;
10049 char *kwnames[] = {
10050 (char *) "pointSize",(char *) "family",(char *) "flags",(char *) "face",(char *) "encoding", NULL
10051 };
10052
10053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_FFont",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
10054 {
10055 arg1 = (int)(SWIG_As_int(obj0));
10056 if (SWIG_arg_fail(1)) SWIG_fail;
10057 }
10058 {
10059 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
10060 if (SWIG_arg_fail(2)) SWIG_fail;
10061 }
10062 if (obj2) {
10063 {
10064 arg3 = (int)(SWIG_As_int(obj2));
10065 if (SWIG_arg_fail(3)) SWIG_fail;
10066 }
10067 }
10068 if (obj3) {
10069 {
10070 arg4 = wxString_in_helper(obj3);
10071 if (arg4 == NULL) SWIG_fail;
10072 temp4 = true;
10073 }
10074 }
10075 if (obj4) {
10076 {
10077 arg5 = (wxFontEncoding)(SWIG_As_int(obj4));
10078 if (SWIG_arg_fail(5)) SWIG_fail;
10079 }
10080 }
10081 {
10082 if (!wxPyCheckForApp()) SWIG_fail;
10083 PyThreadState* __tstate = wxPyBeginAllowThreads();
10084 result = (wxFont *)new_wxFont(arg1,(wxFontFamily )arg2,arg3,(wxString const &)*arg4,(wxFontEncoding )arg5);
10085
10086 wxPyEndAllowThreads(__tstate);
10087 if (PyErr_Occurred()) SWIG_fail;
10088 }
10089 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
10090 {
10091 if (temp4)
10092 delete arg4;
10093 }
10094 return resultobj;
10095 fail:
10096 {
10097 if (temp4)
10098 delete arg4;
10099 }
10100 return NULL;
10101 }
10102
10103
10104 static PyObject *_wrap_new_FontFromPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
10105 PyObject *resultobj;
10106 wxSize *arg1 = 0 ;
10107 int arg2 ;
10108 int arg3 ;
10109 int arg4 ;
10110 bool arg5 = (bool) false ;
10111 wxString const &arg6_defvalue = wxEmptyString ;
10112 wxString *arg6 = (wxString *) &arg6_defvalue ;
10113 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
10114 wxFont *result;
10115 wxSize temp1 ;
10116 bool temp6 = false ;
10117 PyObject * obj0 = 0 ;
10118 PyObject * obj1 = 0 ;
10119 PyObject * obj2 = 0 ;
10120 PyObject * obj3 = 0 ;
10121 PyObject * obj4 = 0 ;
10122 PyObject * obj5 = 0 ;
10123 PyObject * obj6 = 0 ;
10124 char *kwnames[] = {
10125 (char *) "pixelSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underlined",(char *) "face",(char *) "encoding", NULL
10126 };
10127
10128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_FontFromPixelSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
10129 {
10130 arg1 = &temp1;
10131 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
10132 }
10133 {
10134 arg2 = (int)(SWIG_As_int(obj1));
10135 if (SWIG_arg_fail(2)) SWIG_fail;
10136 }
10137 {
10138 arg3 = (int)(SWIG_As_int(obj2));
10139 if (SWIG_arg_fail(3)) SWIG_fail;
10140 }
10141 {
10142 arg4 = (int)(SWIG_As_int(obj3));
10143 if (SWIG_arg_fail(4)) SWIG_fail;
10144 }
10145 if (obj4) {
10146 {
10147 arg5 = (bool)(SWIG_As_bool(obj4));
10148 if (SWIG_arg_fail(5)) SWIG_fail;
10149 }
10150 }
10151 if (obj5) {
10152 {
10153 arg6 = wxString_in_helper(obj5);
10154 if (arg6 == NULL) SWIG_fail;
10155 temp6 = true;
10156 }
10157 }
10158 if (obj6) {
10159 {
10160 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
10161 if (SWIG_arg_fail(7)) SWIG_fail;
10162 }
10163 }
10164 {
10165 if (!wxPyCheckForApp()) SWIG_fail;
10166 PyThreadState* __tstate = wxPyBeginAllowThreads();
10167 result = (wxFont *)new_wxFont((wxSize const &)*arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
10168
10169 wxPyEndAllowThreads(__tstate);
10170 if (PyErr_Occurred()) SWIG_fail;
10171 }
10172 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
10173 {
10174 if (temp6)
10175 delete arg6;
10176 }
10177 return resultobj;
10178 fail:
10179 {
10180 if (temp6)
10181 delete arg6;
10182 }
10183 return NULL;
10184 }
10185
10186
10187 static PyObject *_wrap_new_FFontFromPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
10188 PyObject *resultobj;
10189 wxSize *arg1 = 0 ;
10190 wxFontFamily arg2 ;
10191 int arg3 = (int) wxFONTFLAG_DEFAULT ;
10192 wxString const &arg4_defvalue = wxEmptyString ;
10193 wxString *arg4 = (wxString *) &arg4_defvalue ;
10194 wxFontEncoding arg5 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
10195 wxFont *result;
10196 wxSize temp1 ;
10197 bool temp4 = false ;
10198 PyObject * obj0 = 0 ;
10199 PyObject * obj1 = 0 ;
10200 PyObject * obj2 = 0 ;
10201 PyObject * obj3 = 0 ;
10202 PyObject * obj4 = 0 ;
10203 char *kwnames[] = {
10204 (char *) "pixelSize",(char *) "family",(char *) "flags",(char *) "face",(char *) "encoding", NULL
10205 };
10206
10207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_FFontFromPixelSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
10208 {
10209 arg1 = &temp1;
10210 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
10211 }
10212 {
10213 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
10214 if (SWIG_arg_fail(2)) SWIG_fail;
10215 }
10216 if (obj2) {
10217 {
10218 arg3 = (int)(SWIG_As_int(obj2));
10219 if (SWIG_arg_fail(3)) SWIG_fail;
10220 }
10221 }
10222 if (obj3) {
10223 {
10224 arg4 = wxString_in_helper(obj3);
10225 if (arg4 == NULL) SWIG_fail;
10226 temp4 = true;
10227 }
10228 }
10229 if (obj4) {
10230 {
10231 arg5 = (wxFontEncoding)(SWIG_As_int(obj4));
10232 if (SWIG_arg_fail(5)) SWIG_fail;
10233 }
10234 }
10235 {
10236 if (!wxPyCheckForApp()) SWIG_fail;
10237 PyThreadState* __tstate = wxPyBeginAllowThreads();
10238 result = (wxFont *)new_wxFont((wxSize const &)*arg1,(wxFontFamily )arg2,arg3,(wxString const &)*arg4,(wxFontEncoding )arg5);
10239
10240 wxPyEndAllowThreads(__tstate);
10241 if (PyErr_Occurred()) SWIG_fail;
10242 }
10243 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
10244 {
10245 if (temp4)
10246 delete arg4;
10247 }
10248 return resultobj;
10249 fail:
10250 {
10251 if (temp4)
10252 delete arg4;
10253 }
10254 return NULL;
10255 }
10256
10257
10258 static PyObject *_wrap_Font_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
10259 PyObject *resultobj;
10260 wxFont *arg1 = (wxFont *) 0 ;
10261 bool result;
10262 PyObject * obj0 = 0 ;
10263 char *kwnames[] = {
10264 (char *) "self", NULL
10265 };
10266
10267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_Ok",kwnames,&obj0)) goto fail;
10268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10269 if (SWIG_arg_fail(1)) SWIG_fail;
10270 {
10271 PyThreadState* __tstate = wxPyBeginAllowThreads();
10272 result = (bool)((wxFont const *)arg1)->Ok();
10273
10274 wxPyEndAllowThreads(__tstate);
10275 if (PyErr_Occurred()) SWIG_fail;
10276 }
10277 {
10278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10279 }
10280 return resultobj;
10281 fail:
10282 return NULL;
10283 }
10284
10285
10286 static PyObject *_wrap_Font___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
10287 PyObject *resultobj;
10288 wxFont *arg1 = (wxFont *) 0 ;
10289 wxFont *arg2 = (wxFont *) 0 ;
10290 bool result;
10291 PyObject * obj0 = 0 ;
10292 PyObject * obj1 = 0 ;
10293 char *kwnames[] = {
10294 (char *) "self",(char *) "other", NULL
10295 };
10296
10297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___eq__",kwnames,&obj0,&obj1)) goto fail;
10298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10299 if (SWIG_arg_fail(1)) SWIG_fail;
10300 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10301 if (SWIG_arg_fail(2)) SWIG_fail;
10302 {
10303 PyThreadState* __tstate = wxPyBeginAllowThreads();
10304 result = (bool)wxFont___eq__(arg1,(wxFont const *)arg2);
10305
10306 wxPyEndAllowThreads(__tstate);
10307 if (PyErr_Occurred()) SWIG_fail;
10308 }
10309 {
10310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10311 }
10312 return resultobj;
10313 fail:
10314 return NULL;
10315 }
10316
10317
10318 static PyObject *_wrap_Font___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
10319 PyObject *resultobj;
10320 wxFont *arg1 = (wxFont *) 0 ;
10321 wxFont *arg2 = (wxFont *) 0 ;
10322 bool result;
10323 PyObject * obj0 = 0 ;
10324 PyObject * obj1 = 0 ;
10325 char *kwnames[] = {
10326 (char *) "self",(char *) "other", NULL
10327 };
10328
10329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___ne__",kwnames,&obj0,&obj1)) goto fail;
10330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10331 if (SWIG_arg_fail(1)) SWIG_fail;
10332 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10333 if (SWIG_arg_fail(2)) SWIG_fail;
10334 {
10335 PyThreadState* __tstate = wxPyBeginAllowThreads();
10336 result = (bool)wxFont___ne__(arg1,(wxFont const *)arg2);
10337
10338 wxPyEndAllowThreads(__tstate);
10339 if (PyErr_Occurred()) SWIG_fail;
10340 }
10341 {
10342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10343 }
10344 return resultobj;
10345 fail:
10346 return NULL;
10347 }
10348
10349
10350 static PyObject *_wrap_Font_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
10351 PyObject *resultobj;
10352 wxFont *arg1 = (wxFont *) 0 ;
10353 int result;
10354 PyObject * obj0 = 0 ;
10355 char *kwnames[] = {
10356 (char *) "self", NULL
10357 };
10358
10359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPointSize",kwnames,&obj0)) goto fail;
10360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10361 if (SWIG_arg_fail(1)) SWIG_fail;
10362 {
10363 PyThreadState* __tstate = wxPyBeginAllowThreads();
10364 result = (int)((wxFont const *)arg1)->GetPointSize();
10365
10366 wxPyEndAllowThreads(__tstate);
10367 if (PyErr_Occurred()) SWIG_fail;
10368 }
10369 {
10370 resultobj = SWIG_From_int((int)(result));
10371 }
10372 return resultobj;
10373 fail:
10374 return NULL;
10375 }
10376
10377
10378 static PyObject *_wrap_Font_GetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
10379 PyObject *resultobj;
10380 wxFont *arg1 = (wxFont *) 0 ;
10381 wxSize result;
10382 PyObject * obj0 = 0 ;
10383 char *kwnames[] = {
10384 (char *) "self", NULL
10385 };
10386
10387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPixelSize",kwnames,&obj0)) goto fail;
10388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10389 if (SWIG_arg_fail(1)) SWIG_fail;
10390 {
10391 PyThreadState* __tstate = wxPyBeginAllowThreads();
10392 result = ((wxFont const *)arg1)->GetPixelSize();
10393
10394 wxPyEndAllowThreads(__tstate);
10395 if (PyErr_Occurred()) SWIG_fail;
10396 }
10397 {
10398 wxSize * resultptr;
10399 resultptr = new wxSize((wxSize &)(result));
10400 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
10401 }
10402 return resultobj;
10403 fail:
10404 return NULL;
10405 }
10406
10407
10408 static PyObject *_wrap_Font_IsUsingSizeInPixels(PyObject *, PyObject *args, PyObject *kwargs) {
10409 PyObject *resultobj;
10410 wxFont *arg1 = (wxFont *) 0 ;
10411 bool result;
10412 PyObject * obj0 = 0 ;
10413 char *kwnames[] = {
10414 (char *) "self", NULL
10415 };
10416
10417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsUsingSizeInPixels",kwnames,&obj0)) goto fail;
10418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10419 if (SWIG_arg_fail(1)) SWIG_fail;
10420 {
10421 PyThreadState* __tstate = wxPyBeginAllowThreads();
10422 result = (bool)((wxFont const *)arg1)->IsUsingSizeInPixels();
10423
10424 wxPyEndAllowThreads(__tstate);
10425 if (PyErr_Occurred()) SWIG_fail;
10426 }
10427 {
10428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10429 }
10430 return resultobj;
10431 fail:
10432 return NULL;
10433 }
10434
10435
10436 static PyObject *_wrap_Font_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
10437 PyObject *resultobj;
10438 wxFont *arg1 = (wxFont *) 0 ;
10439 int result;
10440 PyObject * obj0 = 0 ;
10441 char *kwnames[] = {
10442 (char *) "self", NULL
10443 };
10444
10445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamily",kwnames,&obj0)) goto fail;
10446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10447 if (SWIG_arg_fail(1)) SWIG_fail;
10448 {
10449 PyThreadState* __tstate = wxPyBeginAllowThreads();
10450 result = (int)((wxFont const *)arg1)->GetFamily();
10451
10452 wxPyEndAllowThreads(__tstate);
10453 if (PyErr_Occurred()) SWIG_fail;
10454 }
10455 {
10456 resultobj = SWIG_From_int((int)(result));
10457 }
10458 return resultobj;
10459 fail:
10460 return NULL;
10461 }
10462
10463
10464 static PyObject *_wrap_Font_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
10465 PyObject *resultobj;
10466 wxFont *arg1 = (wxFont *) 0 ;
10467 int result;
10468 PyObject * obj0 = 0 ;
10469 char *kwnames[] = {
10470 (char *) "self", NULL
10471 };
10472
10473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyle",kwnames,&obj0)) goto fail;
10474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10475 if (SWIG_arg_fail(1)) SWIG_fail;
10476 {
10477 PyThreadState* __tstate = wxPyBeginAllowThreads();
10478 result = (int)((wxFont const *)arg1)->GetStyle();
10479
10480 wxPyEndAllowThreads(__tstate);
10481 if (PyErr_Occurred()) SWIG_fail;
10482 }
10483 {
10484 resultobj = SWIG_From_int((int)(result));
10485 }
10486 return resultobj;
10487 fail:
10488 return NULL;
10489 }
10490
10491
10492 static PyObject *_wrap_Font_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
10493 PyObject *resultobj;
10494 wxFont *arg1 = (wxFont *) 0 ;
10495 int result;
10496 PyObject * obj0 = 0 ;
10497 char *kwnames[] = {
10498 (char *) "self", NULL
10499 };
10500
10501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeight",kwnames,&obj0)) goto fail;
10502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10503 if (SWIG_arg_fail(1)) SWIG_fail;
10504 {
10505 PyThreadState* __tstate = wxPyBeginAllowThreads();
10506 result = (int)((wxFont const *)arg1)->GetWeight();
10507
10508 wxPyEndAllowThreads(__tstate);
10509 if (PyErr_Occurred()) SWIG_fail;
10510 }
10511 {
10512 resultobj = SWIG_From_int((int)(result));
10513 }
10514 return resultobj;
10515 fail:
10516 return NULL;
10517 }
10518
10519
10520 static PyObject *_wrap_Font_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
10521 PyObject *resultobj;
10522 wxFont *arg1 = (wxFont *) 0 ;
10523 bool result;
10524 PyObject * obj0 = 0 ;
10525 char *kwnames[] = {
10526 (char *) "self", NULL
10527 };
10528
10529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetUnderlined",kwnames,&obj0)) goto fail;
10530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10531 if (SWIG_arg_fail(1)) SWIG_fail;
10532 {
10533 PyThreadState* __tstate = wxPyBeginAllowThreads();
10534 result = (bool)((wxFont const *)arg1)->GetUnderlined();
10535
10536 wxPyEndAllowThreads(__tstate);
10537 if (PyErr_Occurred()) SWIG_fail;
10538 }
10539 {
10540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10541 }
10542 return resultobj;
10543 fail:
10544 return NULL;
10545 }
10546
10547
10548 static PyObject *_wrap_Font_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
10549 PyObject *resultobj;
10550 wxFont *arg1 = (wxFont *) 0 ;
10551 wxString result;
10552 PyObject * obj0 = 0 ;
10553 char *kwnames[] = {
10554 (char *) "self", NULL
10555 };
10556
10557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFaceName",kwnames,&obj0)) goto fail;
10558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10559 if (SWIG_arg_fail(1)) SWIG_fail;
10560 {
10561 PyThreadState* __tstate = wxPyBeginAllowThreads();
10562 result = ((wxFont const *)arg1)->GetFaceName();
10563
10564 wxPyEndAllowThreads(__tstate);
10565 if (PyErr_Occurred()) SWIG_fail;
10566 }
10567 {
10568 #if wxUSE_UNICODE
10569 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10570 #else
10571 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10572 #endif
10573 }
10574 return resultobj;
10575 fail:
10576 return NULL;
10577 }
10578
10579
10580 static PyObject *_wrap_Font_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10581 PyObject *resultobj;
10582 wxFont *arg1 = (wxFont *) 0 ;
10583 wxFontEncoding result;
10584 PyObject * obj0 = 0 ;
10585 char *kwnames[] = {
10586 (char *) "self", NULL
10587 };
10588
10589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetEncoding",kwnames,&obj0)) goto fail;
10590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10591 if (SWIG_arg_fail(1)) SWIG_fail;
10592 {
10593 PyThreadState* __tstate = wxPyBeginAllowThreads();
10594 result = (wxFontEncoding)((wxFont const *)arg1)->GetEncoding();
10595
10596 wxPyEndAllowThreads(__tstate);
10597 if (PyErr_Occurred()) SWIG_fail;
10598 }
10599 resultobj = SWIG_From_int((result));
10600 return resultobj;
10601 fail:
10602 return NULL;
10603 }
10604
10605
10606 static PyObject *_wrap_Font_GetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10607 PyObject *resultobj;
10608 wxFont *arg1 = (wxFont *) 0 ;
10609 wxNativeFontInfo *result;
10610 PyObject * obj0 = 0 ;
10611 char *kwnames[] = {
10612 (char *) "self", NULL
10613 };
10614
10615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfo",kwnames,&obj0)) goto fail;
10616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10617 if (SWIG_arg_fail(1)) SWIG_fail;
10618 {
10619 PyThreadState* __tstate = wxPyBeginAllowThreads();
10620 result = (wxNativeFontInfo *)((wxFont const *)arg1)->GetNativeFontInfo();
10621
10622 wxPyEndAllowThreads(__tstate);
10623 if (PyErr_Occurred()) SWIG_fail;
10624 }
10625 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 0);
10626 return resultobj;
10627 fail:
10628 return NULL;
10629 }
10630
10631
10632 static PyObject *_wrap_Font_IsFixedWidth(PyObject *, PyObject *args, PyObject *kwargs) {
10633 PyObject *resultobj;
10634 wxFont *arg1 = (wxFont *) 0 ;
10635 bool result;
10636 PyObject * obj0 = 0 ;
10637 char *kwnames[] = {
10638 (char *) "self", NULL
10639 };
10640
10641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsFixedWidth",kwnames,&obj0)) goto fail;
10642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10643 if (SWIG_arg_fail(1)) SWIG_fail;
10644 {
10645 PyThreadState* __tstate = wxPyBeginAllowThreads();
10646 result = (bool)((wxFont const *)arg1)->IsFixedWidth();
10647
10648 wxPyEndAllowThreads(__tstate);
10649 if (PyErr_Occurred()) SWIG_fail;
10650 }
10651 {
10652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10653 }
10654 return resultobj;
10655 fail:
10656 return NULL;
10657 }
10658
10659
10660 static PyObject *_wrap_Font_GetNativeFontInfoDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10661 PyObject *resultobj;
10662 wxFont *arg1 = (wxFont *) 0 ;
10663 wxString result;
10664 PyObject * obj0 = 0 ;
10665 char *kwnames[] = {
10666 (char *) "self", NULL
10667 };
10668
10669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoDesc",kwnames,&obj0)) goto fail;
10670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10671 if (SWIG_arg_fail(1)) SWIG_fail;
10672 {
10673 PyThreadState* __tstate = wxPyBeginAllowThreads();
10674 result = ((wxFont const *)arg1)->GetNativeFontInfoDesc();
10675
10676 wxPyEndAllowThreads(__tstate);
10677 if (PyErr_Occurred()) SWIG_fail;
10678 }
10679 {
10680 #if wxUSE_UNICODE
10681 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10682 #else
10683 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10684 #endif
10685 }
10686 return resultobj;
10687 fail:
10688 return NULL;
10689 }
10690
10691
10692 static PyObject *_wrap_Font_GetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10693 PyObject *resultobj;
10694 wxFont *arg1 = (wxFont *) 0 ;
10695 wxString result;
10696 PyObject * obj0 = 0 ;
10697 char *kwnames[] = {
10698 (char *) "self", NULL
10699 };
10700
10701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoUserDesc",kwnames,&obj0)) goto fail;
10702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10703 if (SWIG_arg_fail(1)) SWIG_fail;
10704 {
10705 PyThreadState* __tstate = wxPyBeginAllowThreads();
10706 result = ((wxFont const *)arg1)->GetNativeFontInfoUserDesc();
10707
10708 wxPyEndAllowThreads(__tstate);
10709 if (PyErr_Occurred()) SWIG_fail;
10710 }
10711 {
10712 #if wxUSE_UNICODE
10713 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10714 #else
10715 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10716 #endif
10717 }
10718 return resultobj;
10719 fail:
10720 return NULL;
10721 }
10722
10723
10724 static PyObject *_wrap_Font_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
10725 PyObject *resultobj;
10726 wxFont *arg1 = (wxFont *) 0 ;
10727 int arg2 ;
10728 PyObject * obj0 = 0 ;
10729 PyObject * obj1 = 0 ;
10730 char *kwnames[] = {
10731 (char *) "self",(char *) "pointSize", NULL
10732 };
10733
10734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
10735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10736 if (SWIG_arg_fail(1)) SWIG_fail;
10737 {
10738 arg2 = (int)(SWIG_As_int(obj1));
10739 if (SWIG_arg_fail(2)) SWIG_fail;
10740 }
10741 {
10742 PyThreadState* __tstate = wxPyBeginAllowThreads();
10743 (arg1)->SetPointSize(arg2);
10744
10745 wxPyEndAllowThreads(__tstate);
10746 if (PyErr_Occurred()) SWIG_fail;
10747 }
10748 Py_INCREF(Py_None); resultobj = Py_None;
10749 return resultobj;
10750 fail:
10751 return NULL;
10752 }
10753
10754
10755 static PyObject *_wrap_Font_SetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
10756 PyObject *resultobj;
10757 wxFont *arg1 = (wxFont *) 0 ;
10758 wxSize *arg2 = 0 ;
10759 wxSize temp2 ;
10760 PyObject * obj0 = 0 ;
10761 PyObject * obj1 = 0 ;
10762 char *kwnames[] = {
10763 (char *) "self",(char *) "pixelSize", NULL
10764 };
10765
10766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPixelSize",kwnames,&obj0,&obj1)) goto fail;
10767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10768 if (SWIG_arg_fail(1)) SWIG_fail;
10769 {
10770 arg2 = &temp2;
10771 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
10772 }
10773 {
10774 PyThreadState* __tstate = wxPyBeginAllowThreads();
10775 (arg1)->SetPixelSize((wxSize const &)*arg2);
10776
10777 wxPyEndAllowThreads(__tstate);
10778 if (PyErr_Occurred()) SWIG_fail;
10779 }
10780 Py_INCREF(Py_None); resultobj = Py_None;
10781 return resultobj;
10782 fail:
10783 return NULL;
10784 }
10785
10786
10787 static PyObject *_wrap_Font_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
10788 PyObject *resultobj;
10789 wxFont *arg1 = (wxFont *) 0 ;
10790 int arg2 ;
10791 PyObject * obj0 = 0 ;
10792 PyObject * obj1 = 0 ;
10793 char *kwnames[] = {
10794 (char *) "self",(char *) "family", NULL
10795 };
10796
10797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFamily",kwnames,&obj0,&obj1)) goto fail;
10798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10799 if (SWIG_arg_fail(1)) SWIG_fail;
10800 {
10801 arg2 = (int)(SWIG_As_int(obj1));
10802 if (SWIG_arg_fail(2)) SWIG_fail;
10803 }
10804 {
10805 PyThreadState* __tstate = wxPyBeginAllowThreads();
10806 (arg1)->SetFamily(arg2);
10807
10808 wxPyEndAllowThreads(__tstate);
10809 if (PyErr_Occurred()) SWIG_fail;
10810 }
10811 Py_INCREF(Py_None); resultobj = Py_None;
10812 return resultobj;
10813 fail:
10814 return NULL;
10815 }
10816
10817
10818 static PyObject *_wrap_Font_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
10819 PyObject *resultobj;
10820 wxFont *arg1 = (wxFont *) 0 ;
10821 int arg2 ;
10822 PyObject * obj0 = 0 ;
10823 PyObject * obj1 = 0 ;
10824 char *kwnames[] = {
10825 (char *) "self",(char *) "style", NULL
10826 };
10827
10828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetStyle",kwnames,&obj0,&obj1)) goto fail;
10829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10830 if (SWIG_arg_fail(1)) SWIG_fail;
10831 {
10832 arg2 = (int)(SWIG_As_int(obj1));
10833 if (SWIG_arg_fail(2)) SWIG_fail;
10834 }
10835 {
10836 PyThreadState* __tstate = wxPyBeginAllowThreads();
10837 (arg1)->SetStyle(arg2);
10838
10839 wxPyEndAllowThreads(__tstate);
10840 if (PyErr_Occurred()) SWIG_fail;
10841 }
10842 Py_INCREF(Py_None); resultobj = Py_None;
10843 return resultobj;
10844 fail:
10845 return NULL;
10846 }
10847
10848
10849 static PyObject *_wrap_Font_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
10850 PyObject *resultobj;
10851 wxFont *arg1 = (wxFont *) 0 ;
10852 int arg2 ;
10853 PyObject * obj0 = 0 ;
10854 PyObject * obj1 = 0 ;
10855 char *kwnames[] = {
10856 (char *) "self",(char *) "weight", NULL
10857 };
10858
10859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetWeight",kwnames,&obj0,&obj1)) goto fail;
10860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10861 if (SWIG_arg_fail(1)) SWIG_fail;
10862 {
10863 arg2 = (int)(SWIG_As_int(obj1));
10864 if (SWIG_arg_fail(2)) SWIG_fail;
10865 }
10866 {
10867 PyThreadState* __tstate = wxPyBeginAllowThreads();
10868 (arg1)->SetWeight(arg2);
10869
10870 wxPyEndAllowThreads(__tstate);
10871 if (PyErr_Occurred()) SWIG_fail;
10872 }
10873 Py_INCREF(Py_None); resultobj = Py_None;
10874 return resultobj;
10875 fail:
10876 return NULL;
10877 }
10878
10879
10880 static PyObject *_wrap_Font_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
10881 PyObject *resultobj;
10882 wxFont *arg1 = (wxFont *) 0 ;
10883 wxString *arg2 = 0 ;
10884 bool temp2 = false ;
10885 PyObject * obj0 = 0 ;
10886 PyObject * obj1 = 0 ;
10887 char *kwnames[] = {
10888 (char *) "self",(char *) "faceName", NULL
10889 };
10890
10891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
10892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10893 if (SWIG_arg_fail(1)) SWIG_fail;
10894 {
10895 arg2 = wxString_in_helper(obj1);
10896 if (arg2 == NULL) SWIG_fail;
10897 temp2 = true;
10898 }
10899 {
10900 PyThreadState* __tstate = wxPyBeginAllowThreads();
10901 (arg1)->SetFaceName((wxString const &)*arg2);
10902
10903 wxPyEndAllowThreads(__tstate);
10904 if (PyErr_Occurred()) SWIG_fail;
10905 }
10906 Py_INCREF(Py_None); resultobj = Py_None;
10907 {
10908 if (temp2)
10909 delete arg2;
10910 }
10911 return resultobj;
10912 fail:
10913 {
10914 if (temp2)
10915 delete arg2;
10916 }
10917 return NULL;
10918 }
10919
10920
10921 static PyObject *_wrap_Font_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
10922 PyObject *resultobj;
10923 wxFont *arg1 = (wxFont *) 0 ;
10924 bool arg2 ;
10925 PyObject * obj0 = 0 ;
10926 PyObject * obj1 = 0 ;
10927 char *kwnames[] = {
10928 (char *) "self",(char *) "underlined", NULL
10929 };
10930
10931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
10932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10933 if (SWIG_arg_fail(1)) SWIG_fail;
10934 {
10935 arg2 = (bool)(SWIG_As_bool(obj1));
10936 if (SWIG_arg_fail(2)) SWIG_fail;
10937 }
10938 {
10939 PyThreadState* __tstate = wxPyBeginAllowThreads();
10940 (arg1)->SetUnderlined(arg2);
10941
10942 wxPyEndAllowThreads(__tstate);
10943 if (PyErr_Occurred()) SWIG_fail;
10944 }
10945 Py_INCREF(Py_None); resultobj = Py_None;
10946 return resultobj;
10947 fail:
10948 return NULL;
10949 }
10950
10951
10952 static PyObject *_wrap_Font_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10953 PyObject *resultobj;
10954 wxFont *arg1 = (wxFont *) 0 ;
10955 wxFontEncoding arg2 ;
10956 PyObject * obj0 = 0 ;
10957 PyObject * obj1 = 0 ;
10958 char *kwnames[] = {
10959 (char *) "self",(char *) "encoding", NULL
10960 };
10961
10962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
10963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10964 if (SWIG_arg_fail(1)) SWIG_fail;
10965 {
10966 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
10967 if (SWIG_arg_fail(2)) SWIG_fail;
10968 }
10969 {
10970 PyThreadState* __tstate = wxPyBeginAllowThreads();
10971 (arg1)->SetEncoding((wxFontEncoding )arg2);
10972
10973 wxPyEndAllowThreads(__tstate);
10974 if (PyErr_Occurred()) SWIG_fail;
10975 }
10976 Py_INCREF(Py_None); resultobj = Py_None;
10977 return resultobj;
10978 fail:
10979 return NULL;
10980 }
10981
10982
10983 static PyObject *_wrap_Font_SetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10984 PyObject *resultobj;
10985 wxFont *arg1 = (wxFont *) 0 ;
10986 wxNativeFontInfo *arg2 = 0 ;
10987 PyObject * obj0 = 0 ;
10988 PyObject * obj1 = 0 ;
10989 char *kwnames[] = {
10990 (char *) "self",(char *) "info", NULL
10991 };
10992
10993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfo",kwnames,&obj0,&obj1)) goto fail;
10994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10995 if (SWIG_arg_fail(1)) SWIG_fail;
10996 {
10997 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
10998 if (SWIG_arg_fail(2)) SWIG_fail;
10999 if (arg2 == NULL) {
11000 SWIG_null_ref("wxNativeFontInfo");
11001 }
11002 if (SWIG_arg_fail(2)) SWIG_fail;
11003 }
11004 {
11005 PyThreadState* __tstate = wxPyBeginAllowThreads();
11006 (arg1)->SetNativeFontInfo((wxNativeFontInfo const &)*arg2);
11007
11008 wxPyEndAllowThreads(__tstate);
11009 if (PyErr_Occurred()) SWIG_fail;
11010 }
11011 Py_INCREF(Py_None); resultobj = Py_None;
11012 return resultobj;
11013 fail:
11014 return NULL;
11015 }
11016
11017
11018 static PyObject *_wrap_Font_SetNativeFontInfoFromString(PyObject *, PyObject *args, PyObject *kwargs) {
11019 PyObject *resultobj;
11020 wxFont *arg1 = (wxFont *) 0 ;
11021 wxString *arg2 = 0 ;
11022 bool temp2 = false ;
11023 PyObject * obj0 = 0 ;
11024 PyObject * obj1 = 0 ;
11025 char *kwnames[] = {
11026 (char *) "self",(char *) "info", NULL
11027 };
11028
11029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoFromString",kwnames,&obj0,&obj1)) goto fail;
11030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11031 if (SWIG_arg_fail(1)) SWIG_fail;
11032 {
11033 arg2 = wxString_in_helper(obj1);
11034 if (arg2 == NULL) SWIG_fail;
11035 temp2 = true;
11036 }
11037 {
11038 PyThreadState* __tstate = wxPyBeginAllowThreads();
11039 (arg1)->SetNativeFontInfo((wxString const &)*arg2);
11040
11041 wxPyEndAllowThreads(__tstate);
11042 if (PyErr_Occurred()) SWIG_fail;
11043 }
11044 Py_INCREF(Py_None); resultobj = Py_None;
11045 {
11046 if (temp2)
11047 delete arg2;
11048 }
11049 return resultobj;
11050 fail:
11051 {
11052 if (temp2)
11053 delete arg2;
11054 }
11055 return NULL;
11056 }
11057
11058
11059 static PyObject *_wrap_Font_SetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
11060 PyObject *resultobj;
11061 wxFont *arg1 = (wxFont *) 0 ;
11062 wxString *arg2 = 0 ;
11063 bool temp2 = false ;
11064 PyObject * obj0 = 0 ;
11065 PyObject * obj1 = 0 ;
11066 char *kwnames[] = {
11067 (char *) "self",(char *) "info", NULL
11068 };
11069
11070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoUserDesc",kwnames,&obj0,&obj1)) goto fail;
11071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11072 if (SWIG_arg_fail(1)) SWIG_fail;
11073 {
11074 arg2 = wxString_in_helper(obj1);
11075 if (arg2 == NULL) SWIG_fail;
11076 temp2 = true;
11077 }
11078 {
11079 PyThreadState* __tstate = wxPyBeginAllowThreads();
11080 (arg1)->SetNativeFontInfoUserDesc((wxString const &)*arg2);
11081
11082 wxPyEndAllowThreads(__tstate);
11083 if (PyErr_Occurred()) SWIG_fail;
11084 }
11085 Py_INCREF(Py_None); resultobj = Py_None;
11086 {
11087 if (temp2)
11088 delete arg2;
11089 }
11090 return resultobj;
11091 fail:
11092 {
11093 if (temp2)
11094 delete arg2;
11095 }
11096 return NULL;
11097 }
11098
11099
11100 static PyObject *_wrap_Font_GetFamilyString(PyObject *, PyObject *args, PyObject *kwargs) {
11101 PyObject *resultobj;
11102 wxFont *arg1 = (wxFont *) 0 ;
11103 wxString result;
11104 PyObject * obj0 = 0 ;
11105 char *kwnames[] = {
11106 (char *) "self", NULL
11107 };
11108
11109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamilyString",kwnames,&obj0)) goto fail;
11110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11111 if (SWIG_arg_fail(1)) SWIG_fail;
11112 {
11113 PyThreadState* __tstate = wxPyBeginAllowThreads();
11114 result = ((wxFont const *)arg1)->GetFamilyString();
11115
11116 wxPyEndAllowThreads(__tstate);
11117 if (PyErr_Occurred()) SWIG_fail;
11118 }
11119 {
11120 #if wxUSE_UNICODE
11121 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11122 #else
11123 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11124 #endif
11125 }
11126 return resultobj;
11127 fail:
11128 return NULL;
11129 }
11130
11131
11132 static PyObject *_wrap_Font_GetStyleString(PyObject *, PyObject *args, PyObject *kwargs) {
11133 PyObject *resultobj;
11134 wxFont *arg1 = (wxFont *) 0 ;
11135 wxString result;
11136 PyObject * obj0 = 0 ;
11137 char *kwnames[] = {
11138 (char *) "self", NULL
11139 };
11140
11141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyleString",kwnames,&obj0)) goto fail;
11142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11143 if (SWIG_arg_fail(1)) SWIG_fail;
11144 {
11145 PyThreadState* __tstate = wxPyBeginAllowThreads();
11146 result = ((wxFont const *)arg1)->GetStyleString();
11147
11148 wxPyEndAllowThreads(__tstate);
11149 if (PyErr_Occurred()) SWIG_fail;
11150 }
11151 {
11152 #if wxUSE_UNICODE
11153 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11154 #else
11155 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11156 #endif
11157 }
11158 return resultobj;
11159 fail:
11160 return NULL;
11161 }
11162
11163
11164 static PyObject *_wrap_Font_GetWeightString(PyObject *, PyObject *args, PyObject *kwargs) {
11165 PyObject *resultobj;
11166 wxFont *arg1 = (wxFont *) 0 ;
11167 wxString result;
11168 PyObject * obj0 = 0 ;
11169 char *kwnames[] = {
11170 (char *) "self", NULL
11171 };
11172
11173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeightString",kwnames,&obj0)) goto fail;
11174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11175 if (SWIG_arg_fail(1)) SWIG_fail;
11176 {
11177 PyThreadState* __tstate = wxPyBeginAllowThreads();
11178 result = ((wxFont const *)arg1)->GetWeightString();
11179
11180 wxPyEndAllowThreads(__tstate);
11181 if (PyErr_Occurred()) SWIG_fail;
11182 }
11183 {
11184 #if wxUSE_UNICODE
11185 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11186 #else
11187 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11188 #endif
11189 }
11190 return resultobj;
11191 fail:
11192 return NULL;
11193 }
11194
11195
11196 static PyObject *_wrap_Font_SetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
11197 PyObject *resultobj;
11198 wxFont *arg1 = (wxFont *) 0 ;
11199 bool arg2 = (bool) true ;
11200 PyObject * obj0 = 0 ;
11201 PyObject * obj1 = 0 ;
11202 char *kwnames[] = {
11203 (char *) "self",(char *) "no", NULL
11204 };
11205
11206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Font_SetNoAntiAliasing",kwnames,&obj0,&obj1)) goto fail;
11207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11208 if (SWIG_arg_fail(1)) SWIG_fail;
11209 if (obj1) {
11210 {
11211 arg2 = (bool)(SWIG_As_bool(obj1));
11212 if (SWIG_arg_fail(2)) SWIG_fail;
11213 }
11214 }
11215 {
11216 PyThreadState* __tstate = wxPyBeginAllowThreads();
11217 (arg1)->SetNoAntiAliasing(arg2);
11218
11219 wxPyEndAllowThreads(__tstate);
11220 if (PyErr_Occurred()) SWIG_fail;
11221 }
11222 Py_INCREF(Py_None); resultobj = Py_None;
11223 return resultobj;
11224 fail:
11225 return NULL;
11226 }
11227
11228
11229 static PyObject *_wrap_Font_GetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
11230 PyObject *resultobj;
11231 wxFont *arg1 = (wxFont *) 0 ;
11232 bool result;
11233 PyObject * obj0 = 0 ;
11234 char *kwnames[] = {
11235 (char *) "self", NULL
11236 };
11237
11238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNoAntiAliasing",kwnames,&obj0)) goto fail;
11239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
11240 if (SWIG_arg_fail(1)) SWIG_fail;
11241 {
11242 PyThreadState* __tstate = wxPyBeginAllowThreads();
11243 result = (bool)((wxFont const *)arg1)->GetNoAntiAliasing();
11244
11245 wxPyEndAllowThreads(__tstate);
11246 if (PyErr_Occurred()) SWIG_fail;
11247 }
11248 {
11249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11250 }
11251 return resultobj;
11252 fail:
11253 return NULL;
11254 }
11255
11256
11257 static PyObject *_wrap_Font_GetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
11258 PyObject *resultobj;
11259 wxFontEncoding result;
11260 char *kwnames[] = {
11261 NULL
11262 };
11263
11264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Font_GetDefaultEncoding",kwnames)) goto fail;
11265 {
11266 if (!wxPyCheckForApp()) SWIG_fail;
11267 PyThreadState* __tstate = wxPyBeginAllowThreads();
11268 result = (wxFontEncoding)wxFont::GetDefaultEncoding();
11269
11270 wxPyEndAllowThreads(__tstate);
11271 if (PyErr_Occurred()) SWIG_fail;
11272 }
11273 resultobj = SWIG_From_int((result));
11274 return resultobj;
11275 fail:
11276 return NULL;
11277 }
11278
11279
11280 static PyObject *_wrap_Font_SetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
11281 PyObject *resultobj;
11282 wxFontEncoding arg1 ;
11283 PyObject * obj0 = 0 ;
11284 char *kwnames[] = {
11285 (char *) "encoding", NULL
11286 };
11287
11288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_SetDefaultEncoding",kwnames,&obj0)) goto fail;
11289 {
11290 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
11291 if (SWIG_arg_fail(1)) SWIG_fail;
11292 }
11293 {
11294 if (!wxPyCheckForApp()) SWIG_fail;
11295 PyThreadState* __tstate = wxPyBeginAllowThreads();
11296 wxFont::SetDefaultEncoding((wxFontEncoding )arg1);
11297
11298 wxPyEndAllowThreads(__tstate);
11299 if (PyErr_Occurred()) SWIG_fail;
11300 }
11301 Py_INCREF(Py_None); resultobj = Py_None;
11302 return resultobj;
11303 fail:
11304 return NULL;
11305 }
11306
11307
11308 static PyObject * Font_swigregister(PyObject *, PyObject *args) {
11309 PyObject *obj;
11310 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11311 SWIG_TypeClientData(SWIGTYPE_p_wxFont, obj);
11312 Py_INCREF(obj);
11313 return Py_BuildValue((char *)"");
11314 }
11315 static PyObject *_wrap_new_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
11316 PyObject *resultobj;
11317 wxPyFontEnumerator *result;
11318 char *kwnames[] = {
11319 NULL
11320 };
11321
11322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontEnumerator",kwnames)) goto fail;
11323 {
11324 if (!wxPyCheckForApp()) SWIG_fail;
11325 PyThreadState* __tstate = wxPyBeginAllowThreads();
11326 result = (wxPyFontEnumerator *)new wxPyFontEnumerator();
11327
11328 wxPyEndAllowThreads(__tstate);
11329 if (PyErr_Occurred()) SWIG_fail;
11330 }
11331 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFontEnumerator, 1);
11332 return resultobj;
11333 fail:
11334 return NULL;
11335 }
11336
11337
11338 static PyObject *_wrap_delete_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
11339 PyObject *resultobj;
11340 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11341 PyObject * obj0 = 0 ;
11342 char *kwnames[] = {
11343 (char *) "self", NULL
11344 };
11345
11346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontEnumerator",kwnames,&obj0)) goto fail;
11347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11348 if (SWIG_arg_fail(1)) SWIG_fail;
11349 {
11350 PyThreadState* __tstate = wxPyBeginAllowThreads();
11351 delete arg1;
11352
11353 wxPyEndAllowThreads(__tstate);
11354 if (PyErr_Occurred()) SWIG_fail;
11355 }
11356 Py_INCREF(Py_None); resultobj = Py_None;
11357 return resultobj;
11358 fail:
11359 return NULL;
11360 }
11361
11362
11363 static PyObject *_wrap_FontEnumerator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11364 PyObject *resultobj;
11365 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11366 PyObject *arg2 = (PyObject *) 0 ;
11367 PyObject *arg3 = (PyObject *) 0 ;
11368 bool arg4 ;
11369 PyObject * obj0 = 0 ;
11370 PyObject * obj1 = 0 ;
11371 PyObject * obj2 = 0 ;
11372 PyObject * obj3 = 0 ;
11373 char *kwnames[] = {
11374 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
11375 };
11376
11377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FontEnumerator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11379 if (SWIG_arg_fail(1)) SWIG_fail;
11380 arg2 = obj1;
11381 arg3 = obj2;
11382 {
11383 arg4 = (bool)(SWIG_As_bool(obj3));
11384 if (SWIG_arg_fail(4)) SWIG_fail;
11385 }
11386 {
11387 PyThreadState* __tstate = wxPyBeginAllowThreads();
11388 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
11389
11390 wxPyEndAllowThreads(__tstate);
11391 if (PyErr_Occurred()) SWIG_fail;
11392 }
11393 Py_INCREF(Py_None); resultobj = Py_None;
11394 return resultobj;
11395 fail:
11396 return NULL;
11397 }
11398
11399
11400 static PyObject *_wrap_FontEnumerator_EnumerateFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
11401 PyObject *resultobj;
11402 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11403 wxFontEncoding arg2 = (wxFontEncoding) wxFONTENCODING_SYSTEM ;
11404 bool arg3 = (bool) false ;
11405 bool result;
11406 PyObject * obj0 = 0 ;
11407 PyObject * obj1 = 0 ;
11408 PyObject * obj2 = 0 ;
11409 char *kwnames[] = {
11410 (char *) "self",(char *) "encoding",(char *) "fixedWidthOnly", NULL
11411 };
11412
11413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FontEnumerator_EnumerateFacenames",kwnames,&obj0,&obj1,&obj2)) goto fail;
11414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11415 if (SWIG_arg_fail(1)) SWIG_fail;
11416 if (obj1) {
11417 {
11418 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
11419 if (SWIG_arg_fail(2)) SWIG_fail;
11420 }
11421 }
11422 if (obj2) {
11423 {
11424 arg3 = (bool)(SWIG_As_bool(obj2));
11425 if (SWIG_arg_fail(3)) SWIG_fail;
11426 }
11427 }
11428 {
11429 PyThreadState* __tstate = wxPyBeginAllowThreads();
11430 result = (bool)(arg1)->EnumerateFacenames((wxFontEncoding )arg2,arg3);
11431
11432 wxPyEndAllowThreads(__tstate);
11433 if (PyErr_Occurred()) SWIG_fail;
11434 }
11435 {
11436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11437 }
11438 return resultobj;
11439 fail:
11440 return NULL;
11441 }
11442
11443
11444 static PyObject *_wrap_FontEnumerator_EnumerateEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
11445 PyObject *resultobj;
11446 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11447 wxString const &arg2_defvalue = wxPyEmptyString ;
11448 wxString *arg2 = (wxString *) &arg2_defvalue ;
11449 bool result;
11450 bool temp2 = false ;
11451 PyObject * obj0 = 0 ;
11452 PyObject * obj1 = 0 ;
11453 char *kwnames[] = {
11454 (char *) "self",(char *) "facename", NULL
11455 };
11456
11457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FontEnumerator_EnumerateEncodings",kwnames,&obj0,&obj1)) goto fail;
11458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11459 if (SWIG_arg_fail(1)) SWIG_fail;
11460 if (obj1) {
11461 {
11462 arg2 = wxString_in_helper(obj1);
11463 if (arg2 == NULL) SWIG_fail;
11464 temp2 = true;
11465 }
11466 }
11467 {
11468 PyThreadState* __tstate = wxPyBeginAllowThreads();
11469 result = (bool)(arg1)->EnumerateEncodings((wxString const &)*arg2);
11470
11471 wxPyEndAllowThreads(__tstate);
11472 if (PyErr_Occurred()) SWIG_fail;
11473 }
11474 {
11475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11476 }
11477 {
11478 if (temp2)
11479 delete arg2;
11480 }
11481 return resultobj;
11482 fail:
11483 {
11484 if (temp2)
11485 delete arg2;
11486 }
11487 return NULL;
11488 }
11489
11490
11491 static PyObject *_wrap_FontEnumerator_GetEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
11492 PyObject *resultobj;
11493 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11494 PyObject *result;
11495 PyObject * obj0 = 0 ;
11496 char *kwnames[] = {
11497 (char *) "self", NULL
11498 };
11499
11500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetEncodings",kwnames,&obj0)) goto fail;
11501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11502 if (SWIG_arg_fail(1)) SWIG_fail;
11503 {
11504 PyThreadState* __tstate = wxPyBeginAllowThreads();
11505 result = (PyObject *)wxPyFontEnumerator_GetEncodings(arg1);
11506
11507 wxPyEndAllowThreads(__tstate);
11508 if (PyErr_Occurred()) SWIG_fail;
11509 }
11510 resultobj = result;
11511 return resultobj;
11512 fail:
11513 return NULL;
11514 }
11515
11516
11517 static PyObject *_wrap_FontEnumerator_GetFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
11518 PyObject *resultobj;
11519 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
11520 PyObject *result;
11521 PyObject * obj0 = 0 ;
11522 char *kwnames[] = {
11523 (char *) "self", NULL
11524 };
11525
11526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetFacenames",kwnames,&obj0)) goto fail;
11527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
11528 if (SWIG_arg_fail(1)) SWIG_fail;
11529 {
11530 PyThreadState* __tstate = wxPyBeginAllowThreads();
11531 result = (PyObject *)wxPyFontEnumerator_GetFacenames(arg1);
11532
11533 wxPyEndAllowThreads(__tstate);
11534 if (PyErr_Occurred()) SWIG_fail;
11535 }
11536 resultobj = result;
11537 return resultobj;
11538 fail:
11539 return NULL;
11540 }
11541
11542
11543 static PyObject * FontEnumerator_swigregister(PyObject *, PyObject *args) {
11544 PyObject *obj;
11545 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11546 SWIG_TypeClientData(SWIGTYPE_p_wxPyFontEnumerator, obj);
11547 Py_INCREF(obj);
11548 return Py_BuildValue((char *)"");
11549 }
11550 static PyObject *_wrap_LanguageInfo_Language_set(PyObject *, PyObject *args, PyObject *kwargs) {
11551 PyObject *resultobj;
11552 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11553 int arg2 ;
11554 PyObject * obj0 = 0 ;
11555 PyObject * obj1 = 0 ;
11556 char *kwnames[] = {
11557 (char *) "self",(char *) "Language", NULL
11558 };
11559
11560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Language_set",kwnames,&obj0,&obj1)) goto fail;
11561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11562 if (SWIG_arg_fail(1)) SWIG_fail;
11563 {
11564 arg2 = (int)(SWIG_As_int(obj1));
11565 if (SWIG_arg_fail(2)) SWIG_fail;
11566 }
11567 if (arg1) (arg1)->Language = arg2;
11568
11569 Py_INCREF(Py_None); resultobj = Py_None;
11570 return resultobj;
11571 fail:
11572 return NULL;
11573 }
11574
11575
11576 static PyObject *_wrap_LanguageInfo_Language_get(PyObject *, PyObject *args, PyObject *kwargs) {
11577 PyObject *resultobj;
11578 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11579 int result;
11580 PyObject * obj0 = 0 ;
11581 char *kwnames[] = {
11582 (char *) "self", NULL
11583 };
11584
11585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Language_get",kwnames,&obj0)) goto fail;
11586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11587 if (SWIG_arg_fail(1)) SWIG_fail;
11588 result = (int) ((arg1)->Language);
11589
11590 {
11591 resultobj = SWIG_From_int((int)(result));
11592 }
11593 return resultobj;
11594 fail:
11595 return NULL;
11596 }
11597
11598
11599 static PyObject *_wrap_LanguageInfo_CanonicalName_set(PyObject *, PyObject *args, PyObject *kwargs) {
11600 PyObject *resultobj;
11601 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11602 wxString *arg2 = (wxString *) 0 ;
11603 bool temp2 = false ;
11604 PyObject * obj0 = 0 ;
11605 PyObject * obj1 = 0 ;
11606 char *kwnames[] = {
11607 (char *) "self",(char *) "CanonicalName", NULL
11608 };
11609
11610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_CanonicalName_set",kwnames,&obj0,&obj1)) goto fail;
11611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11612 if (SWIG_arg_fail(1)) SWIG_fail;
11613 {
11614 arg2 = wxString_in_helper(obj1);
11615 if (arg2 == NULL) SWIG_fail;
11616 temp2 = true;
11617 }
11618 if (arg1) (arg1)->CanonicalName = *arg2;
11619
11620 Py_INCREF(Py_None); resultobj = Py_None;
11621 {
11622 if (temp2)
11623 delete arg2;
11624 }
11625 return resultobj;
11626 fail:
11627 {
11628 if (temp2)
11629 delete arg2;
11630 }
11631 return NULL;
11632 }
11633
11634
11635 static PyObject *_wrap_LanguageInfo_CanonicalName_get(PyObject *, PyObject *args, PyObject *kwargs) {
11636 PyObject *resultobj;
11637 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11638 wxString *result;
11639 PyObject * obj0 = 0 ;
11640 char *kwnames[] = {
11641 (char *) "self", NULL
11642 };
11643
11644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_CanonicalName_get",kwnames,&obj0)) goto fail;
11645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11646 if (SWIG_arg_fail(1)) SWIG_fail;
11647 result = (wxString *)& ((arg1)->CanonicalName);
11648
11649 {
11650 #if wxUSE_UNICODE
11651 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
11652 #else
11653 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
11654 #endif
11655 }
11656 return resultobj;
11657 fail:
11658 return NULL;
11659 }
11660
11661
11662 static PyObject *_wrap_LanguageInfo_Description_set(PyObject *, PyObject *args, PyObject *kwargs) {
11663 PyObject *resultobj;
11664 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11665 wxString *arg2 = (wxString *) 0 ;
11666 bool temp2 = false ;
11667 PyObject * obj0 = 0 ;
11668 PyObject * obj1 = 0 ;
11669 char *kwnames[] = {
11670 (char *) "self",(char *) "Description", NULL
11671 };
11672
11673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Description_set",kwnames,&obj0,&obj1)) goto fail;
11674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11675 if (SWIG_arg_fail(1)) SWIG_fail;
11676 {
11677 arg2 = wxString_in_helper(obj1);
11678 if (arg2 == NULL) SWIG_fail;
11679 temp2 = true;
11680 }
11681 if (arg1) (arg1)->Description = *arg2;
11682
11683 Py_INCREF(Py_None); resultobj = Py_None;
11684 {
11685 if (temp2)
11686 delete arg2;
11687 }
11688 return resultobj;
11689 fail:
11690 {
11691 if (temp2)
11692 delete arg2;
11693 }
11694 return NULL;
11695 }
11696
11697
11698 static PyObject *_wrap_LanguageInfo_Description_get(PyObject *, PyObject *args, PyObject *kwargs) {
11699 PyObject *resultobj;
11700 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
11701 wxString *result;
11702 PyObject * obj0 = 0 ;
11703 char *kwnames[] = {
11704 (char *) "self", NULL
11705 };
11706
11707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Description_get",kwnames,&obj0)) goto fail;
11708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11709 if (SWIG_arg_fail(1)) SWIG_fail;
11710 result = (wxString *)& ((arg1)->Description);
11711
11712 {
11713 #if wxUSE_UNICODE
11714 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
11715 #else
11716 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
11717 #endif
11718 }
11719 return resultobj;
11720 fail:
11721 return NULL;
11722 }
11723
11724
11725 static PyObject * LanguageInfo_swigregister(PyObject *, PyObject *args) {
11726 PyObject *obj;
11727 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11728 SWIG_TypeClientData(SWIGTYPE_p_wxLanguageInfo, obj);
11729 Py_INCREF(obj);
11730 return Py_BuildValue((char *)"");
11731 }
11732 static PyObject *_wrap_new_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
11733 PyObject *resultobj;
11734 int arg1 = (int) -1 ;
11735 int arg2 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
11736 wxLocale *result;
11737 PyObject * obj0 = 0 ;
11738 PyObject * obj1 = 0 ;
11739 char *kwnames[] = {
11740 (char *) "language",(char *) "flags", NULL
11741 };
11742
11743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Locale",kwnames,&obj0,&obj1)) goto fail;
11744 if (obj0) {
11745 {
11746 arg1 = (int)(SWIG_As_int(obj0));
11747 if (SWIG_arg_fail(1)) SWIG_fail;
11748 }
11749 }
11750 if (obj1) {
11751 {
11752 arg2 = (int)(SWIG_As_int(obj1));
11753 if (SWIG_arg_fail(2)) SWIG_fail;
11754 }
11755 }
11756 {
11757 PyThreadState* __tstate = wxPyBeginAllowThreads();
11758 result = (wxLocale *)new_wxLocale(arg1,arg2);
11759
11760 wxPyEndAllowThreads(__tstate);
11761 if (PyErr_Occurred()) SWIG_fail;
11762 }
11763 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 1);
11764 return resultobj;
11765 fail:
11766 return NULL;
11767 }
11768
11769
11770 static PyObject *_wrap_delete_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
11771 PyObject *resultobj;
11772 wxLocale *arg1 = (wxLocale *) 0 ;
11773 PyObject * obj0 = 0 ;
11774 char *kwnames[] = {
11775 (char *) "self", NULL
11776 };
11777
11778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Locale",kwnames,&obj0)) goto fail;
11779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11780 if (SWIG_arg_fail(1)) SWIG_fail;
11781 {
11782 PyThreadState* __tstate = wxPyBeginAllowThreads();
11783 delete arg1;
11784
11785 wxPyEndAllowThreads(__tstate);
11786 if (PyErr_Occurred()) SWIG_fail;
11787 }
11788 Py_INCREF(Py_None); resultobj = Py_None;
11789 return resultobj;
11790 fail:
11791 return NULL;
11792 }
11793
11794
11795 static PyObject *_wrap_Locale_Init1(PyObject *, PyObject *args, PyObject *kwargs) {
11796 PyObject *resultobj;
11797 wxLocale *arg1 = (wxLocale *) 0 ;
11798 wxString *arg2 = 0 ;
11799 wxString const &arg3_defvalue = wxPyEmptyString ;
11800 wxString *arg3 = (wxString *) &arg3_defvalue ;
11801 wxString const &arg4_defvalue = wxPyEmptyString ;
11802 wxString *arg4 = (wxString *) &arg4_defvalue ;
11803 bool arg5 = (bool) true ;
11804 bool arg6 = (bool) false ;
11805 bool result;
11806 bool temp2 = false ;
11807 bool temp3 = false ;
11808 bool temp4 = false ;
11809 PyObject * obj0 = 0 ;
11810 PyObject * obj1 = 0 ;
11811 PyObject * obj2 = 0 ;
11812 PyObject * obj3 = 0 ;
11813 PyObject * obj4 = 0 ;
11814 PyObject * obj5 = 0 ;
11815 char *kwnames[] = {
11816 (char *) "self",(char *) "szName",(char *) "szShort",(char *) "szLocale",(char *) "bLoadDefault",(char *) "bConvertEncoding", NULL
11817 };
11818
11819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Locale_Init1",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11821 if (SWIG_arg_fail(1)) SWIG_fail;
11822 {
11823 arg2 = wxString_in_helper(obj1);
11824 if (arg2 == NULL) SWIG_fail;
11825 temp2 = true;
11826 }
11827 if (obj2) {
11828 {
11829 arg3 = wxString_in_helper(obj2);
11830 if (arg3 == NULL) SWIG_fail;
11831 temp3 = true;
11832 }
11833 }
11834 if (obj3) {
11835 {
11836 arg4 = wxString_in_helper(obj3);
11837 if (arg4 == NULL) SWIG_fail;
11838 temp4 = true;
11839 }
11840 }
11841 if (obj4) {
11842 {
11843 arg5 = (bool)(SWIG_As_bool(obj4));
11844 if (SWIG_arg_fail(5)) SWIG_fail;
11845 }
11846 }
11847 if (obj5) {
11848 {
11849 arg6 = (bool)(SWIG_As_bool(obj5));
11850 if (SWIG_arg_fail(6)) SWIG_fail;
11851 }
11852 }
11853 {
11854 PyThreadState* __tstate = wxPyBeginAllowThreads();
11855 result = (bool)wxLocale_Init1(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
11856
11857 wxPyEndAllowThreads(__tstate);
11858 if (PyErr_Occurred()) SWIG_fail;
11859 }
11860 {
11861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11862 }
11863 {
11864 if (temp2)
11865 delete arg2;
11866 }
11867 {
11868 if (temp3)
11869 delete arg3;
11870 }
11871 {
11872 if (temp4)
11873 delete arg4;
11874 }
11875 return resultobj;
11876 fail:
11877 {
11878 if (temp2)
11879 delete arg2;
11880 }
11881 {
11882 if (temp3)
11883 delete arg3;
11884 }
11885 {
11886 if (temp4)
11887 delete arg4;
11888 }
11889 return NULL;
11890 }
11891
11892
11893 static PyObject *_wrap_Locale_Init2(PyObject *, PyObject *args, PyObject *kwargs) {
11894 PyObject *resultobj;
11895 wxLocale *arg1 = (wxLocale *) 0 ;
11896 int arg2 = (int) wxLANGUAGE_DEFAULT ;
11897 int arg3 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
11898 bool result;
11899 PyObject * obj0 = 0 ;
11900 PyObject * obj1 = 0 ;
11901 PyObject * obj2 = 0 ;
11902 char *kwnames[] = {
11903 (char *) "self",(char *) "language",(char *) "flags", NULL
11904 };
11905
11906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Locale_Init2",kwnames,&obj0,&obj1,&obj2)) goto fail;
11907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11908 if (SWIG_arg_fail(1)) SWIG_fail;
11909 if (obj1) {
11910 {
11911 arg2 = (int)(SWIG_As_int(obj1));
11912 if (SWIG_arg_fail(2)) SWIG_fail;
11913 }
11914 }
11915 if (obj2) {
11916 {
11917 arg3 = (int)(SWIG_As_int(obj2));
11918 if (SWIG_arg_fail(3)) SWIG_fail;
11919 }
11920 }
11921 {
11922 PyThreadState* __tstate = wxPyBeginAllowThreads();
11923 result = (bool)wxLocale_Init2(arg1,arg2,arg3);
11924
11925 wxPyEndAllowThreads(__tstate);
11926 if (PyErr_Occurred()) SWIG_fail;
11927 }
11928 {
11929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11930 }
11931 return resultobj;
11932 fail:
11933 return NULL;
11934 }
11935
11936
11937 static PyObject *_wrap_Locale_GetSystemLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11938 PyObject *resultobj;
11939 int result;
11940 char *kwnames[] = {
11941 NULL
11942 };
11943
11944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemLanguage",kwnames)) goto fail;
11945 {
11946 PyThreadState* __tstate = wxPyBeginAllowThreads();
11947 result = (int)wxLocale::GetSystemLanguage();
11948
11949 wxPyEndAllowThreads(__tstate);
11950 if (PyErr_Occurred()) SWIG_fail;
11951 }
11952 {
11953 resultobj = SWIG_From_int((int)(result));
11954 }
11955 return resultobj;
11956 fail:
11957 return NULL;
11958 }
11959
11960
11961 static PyObject *_wrap_Locale_GetSystemEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
11962 PyObject *resultobj;
11963 wxFontEncoding result;
11964 char *kwnames[] = {
11965 NULL
11966 };
11967
11968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncoding",kwnames)) goto fail;
11969 {
11970 PyThreadState* __tstate = wxPyBeginAllowThreads();
11971 result = (wxFontEncoding)wxLocale::GetSystemEncoding();
11972
11973 wxPyEndAllowThreads(__tstate);
11974 if (PyErr_Occurred()) SWIG_fail;
11975 }
11976 resultobj = SWIG_From_int((result));
11977 return resultobj;
11978 fail:
11979 return NULL;
11980 }
11981
11982
11983 static PyObject *_wrap_Locale_GetSystemEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
11984 PyObject *resultobj;
11985 wxString result;
11986 char *kwnames[] = {
11987 NULL
11988 };
11989
11990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncodingName",kwnames)) goto fail;
11991 {
11992 PyThreadState* __tstate = wxPyBeginAllowThreads();
11993 result = wxLocale::GetSystemEncodingName();
11994
11995 wxPyEndAllowThreads(__tstate);
11996 if (PyErr_Occurred()) SWIG_fail;
11997 }
11998 {
11999 #if wxUSE_UNICODE
12000 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12001 #else
12002 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12003 #endif
12004 }
12005 return resultobj;
12006 fail:
12007 return NULL;
12008 }
12009
12010
12011 static PyObject *_wrap_Locale_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
12012 PyObject *resultobj;
12013 wxLocale *arg1 = (wxLocale *) 0 ;
12014 bool result;
12015 PyObject * obj0 = 0 ;
12016 char *kwnames[] = {
12017 (char *) "self", NULL
12018 };
12019
12020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_IsOk",kwnames,&obj0)) goto fail;
12021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12022 if (SWIG_arg_fail(1)) SWIG_fail;
12023 {
12024 PyThreadState* __tstate = wxPyBeginAllowThreads();
12025 result = (bool)((wxLocale const *)arg1)->IsOk();
12026
12027 wxPyEndAllowThreads(__tstate);
12028 if (PyErr_Occurred()) SWIG_fail;
12029 }
12030 {
12031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12032 }
12033 return resultobj;
12034 fail:
12035 return NULL;
12036 }
12037
12038
12039 static PyObject *_wrap_Locale_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
12040 PyObject *resultobj;
12041 wxLocale *arg1 = (wxLocale *) 0 ;
12042 wxString result;
12043 PyObject * obj0 = 0 ;
12044 char *kwnames[] = {
12045 (char *) "self", NULL
12046 };
12047
12048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLocale",kwnames,&obj0)) goto fail;
12049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12050 if (SWIG_arg_fail(1)) SWIG_fail;
12051 {
12052 PyThreadState* __tstate = wxPyBeginAllowThreads();
12053 result = ((wxLocale const *)arg1)->GetLocale();
12054
12055 wxPyEndAllowThreads(__tstate);
12056 if (PyErr_Occurred()) SWIG_fail;
12057 }
12058 {
12059 #if wxUSE_UNICODE
12060 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12061 #else
12062 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12063 #endif
12064 }
12065 return resultobj;
12066 fail:
12067 return NULL;
12068 }
12069
12070
12071 static PyObject *_wrap_Locale_GetLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
12072 PyObject *resultobj;
12073 wxLocale *arg1 = (wxLocale *) 0 ;
12074 int result;
12075 PyObject * obj0 = 0 ;
12076 char *kwnames[] = {
12077 (char *) "self", NULL
12078 };
12079
12080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguage",kwnames,&obj0)) goto fail;
12081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12082 if (SWIG_arg_fail(1)) SWIG_fail;
12083 {
12084 PyThreadState* __tstate = wxPyBeginAllowThreads();
12085 result = (int)((wxLocale const *)arg1)->GetLanguage();
12086
12087 wxPyEndAllowThreads(__tstate);
12088 if (PyErr_Occurred()) SWIG_fail;
12089 }
12090 {
12091 resultobj = SWIG_From_int((int)(result));
12092 }
12093 return resultobj;
12094 fail:
12095 return NULL;
12096 }
12097
12098
12099 static PyObject *_wrap_Locale_GetSysName(PyObject *, PyObject *args, PyObject *kwargs) {
12100 PyObject *resultobj;
12101 wxLocale *arg1 = (wxLocale *) 0 ;
12102 wxString result;
12103 PyObject * obj0 = 0 ;
12104 char *kwnames[] = {
12105 (char *) "self", NULL
12106 };
12107
12108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetSysName",kwnames,&obj0)) goto fail;
12109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12110 if (SWIG_arg_fail(1)) SWIG_fail;
12111 {
12112 PyThreadState* __tstate = wxPyBeginAllowThreads();
12113 result = ((wxLocale const *)arg1)->GetSysName();
12114
12115 wxPyEndAllowThreads(__tstate);
12116 if (PyErr_Occurred()) SWIG_fail;
12117 }
12118 {
12119 #if wxUSE_UNICODE
12120 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12121 #else
12122 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12123 #endif
12124 }
12125 return resultobj;
12126 fail:
12127 return NULL;
12128 }
12129
12130
12131 static PyObject *_wrap_Locale_GetCanonicalName(PyObject *, PyObject *args, PyObject *kwargs) {
12132 PyObject *resultobj;
12133 wxLocale *arg1 = (wxLocale *) 0 ;
12134 wxString result;
12135 PyObject * obj0 = 0 ;
12136 char *kwnames[] = {
12137 (char *) "self", NULL
12138 };
12139
12140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetCanonicalName",kwnames,&obj0)) goto fail;
12141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12142 if (SWIG_arg_fail(1)) SWIG_fail;
12143 {
12144 PyThreadState* __tstate = wxPyBeginAllowThreads();
12145 result = ((wxLocale const *)arg1)->GetCanonicalName();
12146
12147 wxPyEndAllowThreads(__tstate);
12148 if (PyErr_Occurred()) SWIG_fail;
12149 }
12150 {
12151 #if wxUSE_UNICODE
12152 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12153 #else
12154 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12155 #endif
12156 }
12157 return resultobj;
12158 fail:
12159 return NULL;
12160 }
12161
12162
12163 static PyObject *_wrap_Locale_AddCatalogLookupPathPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
12164 PyObject *resultobj;
12165 wxString *arg1 = 0 ;
12166 bool temp1 = false ;
12167 PyObject * obj0 = 0 ;
12168 char *kwnames[] = {
12169 (char *) "prefix", NULL
12170 };
12171
12172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddCatalogLookupPathPrefix",kwnames,&obj0)) goto fail;
12173 {
12174 arg1 = wxString_in_helper(obj0);
12175 if (arg1 == NULL) SWIG_fail;
12176 temp1 = true;
12177 }
12178 {
12179 PyThreadState* __tstate = wxPyBeginAllowThreads();
12180 wxLocale::AddCatalogLookupPathPrefix((wxString const &)*arg1);
12181
12182 wxPyEndAllowThreads(__tstate);
12183 if (PyErr_Occurred()) SWIG_fail;
12184 }
12185 Py_INCREF(Py_None); resultobj = Py_None;
12186 {
12187 if (temp1)
12188 delete arg1;
12189 }
12190 return resultobj;
12191 fail:
12192 {
12193 if (temp1)
12194 delete arg1;
12195 }
12196 return NULL;
12197 }
12198
12199
12200 static PyObject *_wrap_Locale_AddCatalog(PyObject *, PyObject *args, PyObject *kwargs) {
12201 PyObject *resultobj;
12202 wxLocale *arg1 = (wxLocale *) 0 ;
12203 wxString *arg2 = 0 ;
12204 bool result;
12205 bool temp2 = false ;
12206 PyObject * obj0 = 0 ;
12207 PyObject * obj1 = 0 ;
12208 char *kwnames[] = {
12209 (char *) "self",(char *) "szDomain", NULL
12210 };
12211
12212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_AddCatalog",kwnames,&obj0,&obj1)) goto fail;
12213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12214 if (SWIG_arg_fail(1)) SWIG_fail;
12215 {
12216 arg2 = wxString_in_helper(obj1);
12217 if (arg2 == NULL) SWIG_fail;
12218 temp2 = true;
12219 }
12220 {
12221 PyThreadState* __tstate = wxPyBeginAllowThreads();
12222 result = (bool)(arg1)->AddCatalog((wxString const &)*arg2);
12223
12224 wxPyEndAllowThreads(__tstate);
12225 if (PyErr_Occurred()) SWIG_fail;
12226 }
12227 {
12228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12229 }
12230 {
12231 if (temp2)
12232 delete arg2;
12233 }
12234 return resultobj;
12235 fail:
12236 {
12237 if (temp2)
12238 delete arg2;
12239 }
12240 return NULL;
12241 }
12242
12243
12244 static PyObject *_wrap_Locale_IsLoaded(PyObject *, PyObject *args, PyObject *kwargs) {
12245 PyObject *resultobj;
12246 wxLocale *arg1 = (wxLocale *) 0 ;
12247 wxString *arg2 = 0 ;
12248 bool result;
12249 bool temp2 = false ;
12250 PyObject * obj0 = 0 ;
12251 PyObject * obj1 = 0 ;
12252 char *kwnames[] = {
12253 (char *) "self",(char *) "szDomain", NULL
12254 };
12255
12256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_IsLoaded",kwnames,&obj0,&obj1)) goto fail;
12257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12258 if (SWIG_arg_fail(1)) SWIG_fail;
12259 {
12260 arg2 = wxString_in_helper(obj1);
12261 if (arg2 == NULL) SWIG_fail;
12262 temp2 = true;
12263 }
12264 {
12265 PyThreadState* __tstate = wxPyBeginAllowThreads();
12266 result = (bool)((wxLocale const *)arg1)->IsLoaded((wxString const &)*arg2);
12267
12268 wxPyEndAllowThreads(__tstate);
12269 if (PyErr_Occurred()) SWIG_fail;
12270 }
12271 {
12272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12273 }
12274 {
12275 if (temp2)
12276 delete arg2;
12277 }
12278 return resultobj;
12279 fail:
12280 {
12281 if (temp2)
12282 delete arg2;
12283 }
12284 return NULL;
12285 }
12286
12287
12288 static PyObject *_wrap_Locale_GetLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
12289 PyObject *resultobj;
12290 int arg1 ;
12291 wxLanguageInfo *result;
12292 PyObject * obj0 = 0 ;
12293 char *kwnames[] = {
12294 (char *) "lang", NULL
12295 };
12296
12297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageInfo",kwnames,&obj0)) goto fail;
12298 {
12299 arg1 = (int)(SWIG_As_int(obj0));
12300 if (SWIG_arg_fail(1)) SWIG_fail;
12301 }
12302 {
12303 PyThreadState* __tstate = wxPyBeginAllowThreads();
12304 result = (wxLanguageInfo *)wxLocale::GetLanguageInfo(arg1);
12305
12306 wxPyEndAllowThreads(__tstate);
12307 if (PyErr_Occurred()) SWIG_fail;
12308 }
12309 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
12310 return resultobj;
12311 fail:
12312 return NULL;
12313 }
12314
12315
12316 static PyObject *_wrap_Locale_GetLanguageName(PyObject *, PyObject *args, PyObject *kwargs) {
12317 PyObject *resultobj;
12318 int arg1 ;
12319 wxString result;
12320 PyObject * obj0 = 0 ;
12321 char *kwnames[] = {
12322 (char *) "lang", NULL
12323 };
12324
12325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageName",kwnames,&obj0)) goto fail;
12326 {
12327 arg1 = (int)(SWIG_As_int(obj0));
12328 if (SWIG_arg_fail(1)) SWIG_fail;
12329 }
12330 {
12331 PyThreadState* __tstate = wxPyBeginAllowThreads();
12332 result = wxLocale::GetLanguageName(arg1);
12333
12334 wxPyEndAllowThreads(__tstate);
12335 if (PyErr_Occurred()) SWIG_fail;
12336 }
12337 {
12338 #if wxUSE_UNICODE
12339 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12340 #else
12341 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12342 #endif
12343 }
12344 return resultobj;
12345 fail:
12346 return NULL;
12347 }
12348
12349
12350 static PyObject *_wrap_Locale_FindLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
12351 PyObject *resultobj;
12352 wxString *arg1 = 0 ;
12353 wxLanguageInfo *result;
12354 bool temp1 = false ;
12355 PyObject * obj0 = 0 ;
12356 char *kwnames[] = {
12357 (char *) "locale", NULL
12358 };
12359
12360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_FindLanguageInfo",kwnames,&obj0)) goto fail;
12361 {
12362 arg1 = wxString_in_helper(obj0);
12363 if (arg1 == NULL) SWIG_fail;
12364 temp1 = true;
12365 }
12366 {
12367 PyThreadState* __tstate = wxPyBeginAllowThreads();
12368 result = (wxLanguageInfo *)wxLocale::FindLanguageInfo((wxString const &)*arg1);
12369
12370 wxPyEndAllowThreads(__tstate);
12371 if (PyErr_Occurred()) SWIG_fail;
12372 }
12373 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
12374 {
12375 if (temp1)
12376 delete arg1;
12377 }
12378 return resultobj;
12379 fail:
12380 {
12381 if (temp1)
12382 delete arg1;
12383 }
12384 return NULL;
12385 }
12386
12387
12388 static PyObject *_wrap_Locale_AddLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
12389 PyObject *resultobj;
12390 wxLanguageInfo *arg1 = 0 ;
12391 PyObject * obj0 = 0 ;
12392 char *kwnames[] = {
12393 (char *) "info", NULL
12394 };
12395
12396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddLanguage",kwnames,&obj0)) goto fail;
12397 {
12398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
12399 if (SWIG_arg_fail(1)) SWIG_fail;
12400 if (arg1 == NULL) {
12401 SWIG_null_ref("wxLanguageInfo");
12402 }
12403 if (SWIG_arg_fail(1)) SWIG_fail;
12404 }
12405 {
12406 PyThreadState* __tstate = wxPyBeginAllowThreads();
12407 wxLocale::AddLanguage((wxLanguageInfo const &)*arg1);
12408
12409 wxPyEndAllowThreads(__tstate);
12410 if (PyErr_Occurred()) SWIG_fail;
12411 }
12412 Py_INCREF(Py_None); resultobj = Py_None;
12413 return resultobj;
12414 fail:
12415 return NULL;
12416 }
12417
12418
12419 static PyObject *_wrap_Locale_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
12420 PyObject *resultobj;
12421 wxLocale *arg1 = (wxLocale *) 0 ;
12422 wxString *arg2 = 0 ;
12423 wxString const &arg3_defvalue = wxPyEmptyString ;
12424 wxString *arg3 = (wxString *) &arg3_defvalue ;
12425 wxString result;
12426 bool temp2 = false ;
12427 bool temp3 = false ;
12428 PyObject * obj0 = 0 ;
12429 PyObject * obj1 = 0 ;
12430 PyObject * obj2 = 0 ;
12431 char *kwnames[] = {
12432 (char *) "self",(char *) "szOrigString",(char *) "szDomain", NULL
12433 };
12434
12435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Locale_GetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
12436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12437 if (SWIG_arg_fail(1)) SWIG_fail;
12438 {
12439 arg2 = wxString_in_helper(obj1);
12440 if (arg2 == NULL) SWIG_fail;
12441 temp2 = true;
12442 }
12443 if (obj2) {
12444 {
12445 arg3 = wxString_in_helper(obj2);
12446 if (arg3 == NULL) SWIG_fail;
12447 temp3 = true;
12448 }
12449 }
12450 {
12451 PyThreadState* __tstate = wxPyBeginAllowThreads();
12452 result = ((wxLocale const *)arg1)->GetString((wxString const &)*arg2,(wxString const &)*arg3);
12453
12454 wxPyEndAllowThreads(__tstate);
12455 if (PyErr_Occurred()) SWIG_fail;
12456 }
12457 {
12458 #if wxUSE_UNICODE
12459 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12460 #else
12461 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12462 #endif
12463 }
12464 {
12465 if (temp2)
12466 delete arg2;
12467 }
12468 {
12469 if (temp3)
12470 delete arg3;
12471 }
12472 return resultobj;
12473 fail:
12474 {
12475 if (temp2)
12476 delete arg2;
12477 }
12478 {
12479 if (temp3)
12480 delete arg3;
12481 }
12482 return NULL;
12483 }
12484
12485
12486 static PyObject *_wrap_Locale_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
12487 PyObject *resultobj;
12488 wxLocale *arg1 = (wxLocale *) 0 ;
12489 wxString *result;
12490 PyObject * obj0 = 0 ;
12491 char *kwnames[] = {
12492 (char *) "self", NULL
12493 };
12494
12495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetName",kwnames,&obj0)) goto fail;
12496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
12497 if (SWIG_arg_fail(1)) SWIG_fail;
12498 {
12499 PyThreadState* __tstate = wxPyBeginAllowThreads();
12500 {
12501 wxString const &_result_ref = ((wxLocale const *)arg1)->GetName();
12502 result = (wxString *) &_result_ref;
12503 }
12504
12505 wxPyEndAllowThreads(__tstate);
12506 if (PyErr_Occurred()) SWIG_fail;
12507 }
12508 {
12509 #if wxUSE_UNICODE
12510 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12511 #else
12512 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12513 #endif
12514 }
12515 return resultobj;
12516 fail:
12517 return NULL;
12518 }
12519
12520
12521 static PyObject * Locale_swigregister(PyObject *, PyObject *args) {
12522 PyObject *obj;
12523 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12524 SWIG_TypeClientData(SWIGTYPE_p_wxLocale, obj);
12525 Py_INCREF(obj);
12526 return Py_BuildValue((char *)"");
12527 }
12528 static PyObject *_wrap_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
12529 PyObject *resultobj;
12530 wxLocale *result;
12531 char *kwnames[] = {
12532 NULL
12533 };
12534
12535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocale",kwnames)) goto fail;
12536 {
12537 PyThreadState* __tstate = wxPyBeginAllowThreads();
12538 result = (wxLocale *)wxGetLocale();
12539
12540 wxPyEndAllowThreads(__tstate);
12541 if (PyErr_Occurred()) SWIG_fail;
12542 }
12543 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 0);
12544 return resultobj;
12545 fail:
12546 return NULL;
12547 }
12548
12549
12550 static PyObject *_wrap_GetTranslation__SWIG_0(PyObject *, PyObject *args) {
12551 PyObject *resultobj;
12552 wxString *arg1 = 0 ;
12553 wxString result;
12554 bool temp1 = false ;
12555 PyObject * obj0 = 0 ;
12556
12557 if(!PyArg_ParseTuple(args,(char *)"O:GetTranslation",&obj0)) goto fail;
12558 {
12559 arg1 = wxString_in_helper(obj0);
12560 if (arg1 == NULL) SWIG_fail;
12561 temp1 = true;
12562 }
12563 {
12564 PyThreadState* __tstate = wxPyBeginAllowThreads();
12565 result = wxGetTranslation((wxString const &)*arg1);
12566
12567 wxPyEndAllowThreads(__tstate);
12568 if (PyErr_Occurred()) SWIG_fail;
12569 }
12570 {
12571 #if wxUSE_UNICODE
12572 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12573 #else
12574 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12575 #endif
12576 }
12577 {
12578 if (temp1)
12579 delete arg1;
12580 }
12581 return resultobj;
12582 fail:
12583 {
12584 if (temp1)
12585 delete arg1;
12586 }
12587 return NULL;
12588 }
12589
12590
12591 static PyObject *_wrap_GetTranslation__SWIG_1(PyObject *, PyObject *args) {
12592 PyObject *resultobj;
12593 wxString *arg1 = 0 ;
12594 wxString *arg2 = 0 ;
12595 size_t arg3 ;
12596 wxString result;
12597 bool temp1 = false ;
12598 bool temp2 = false ;
12599 PyObject * obj0 = 0 ;
12600 PyObject * obj1 = 0 ;
12601 PyObject * obj2 = 0 ;
12602
12603 if(!PyArg_ParseTuple(args,(char *)"OOO:GetTranslation",&obj0,&obj1,&obj2)) goto fail;
12604 {
12605 arg1 = wxString_in_helper(obj0);
12606 if (arg1 == NULL) SWIG_fail;
12607 temp1 = true;
12608 }
12609 {
12610 arg2 = wxString_in_helper(obj1);
12611 if (arg2 == NULL) SWIG_fail;
12612 temp2 = true;
12613 }
12614 {
12615 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
12616 if (SWIG_arg_fail(3)) SWIG_fail;
12617 }
12618 {
12619 PyThreadState* __tstate = wxPyBeginAllowThreads();
12620 result = wxGetTranslation((wxString const &)*arg1,(wxString const &)*arg2,arg3);
12621
12622 wxPyEndAllowThreads(__tstate);
12623 if (PyErr_Occurred()) SWIG_fail;
12624 }
12625 {
12626 #if wxUSE_UNICODE
12627 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12628 #else
12629 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12630 #endif
12631 }
12632 {
12633 if (temp1)
12634 delete arg1;
12635 }
12636 {
12637 if (temp2)
12638 delete arg2;
12639 }
12640 return resultobj;
12641 fail:
12642 {
12643 if (temp1)
12644 delete arg1;
12645 }
12646 {
12647 if (temp2)
12648 delete arg2;
12649 }
12650 return NULL;
12651 }
12652
12653
12654 static PyObject *_wrap_GetTranslation(PyObject *self, PyObject *args) {
12655 int argc;
12656 PyObject *argv[4];
12657 int ii;
12658
12659 argc = PyObject_Length(args);
12660 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
12661 argv[ii] = PyTuple_GetItem(args,ii);
12662 }
12663 if (argc == 1) {
12664 int _v;
12665 {
12666 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12667 }
12668 if (_v) {
12669 return _wrap_GetTranslation__SWIG_0(self,args);
12670 }
12671 }
12672 if (argc == 3) {
12673 int _v;
12674 {
12675 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12676 }
12677 if (_v) {
12678 {
12679 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
12680 }
12681 if (_v) {
12682 _v = SWIG_Check_unsigned_SS_long(argv[2]);
12683 if (_v) {
12684 return _wrap_GetTranslation__SWIG_1(self,args);
12685 }
12686 }
12687 }
12688 }
12689
12690 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GetTranslation'");
12691 return NULL;
12692 }
12693
12694
12695 static PyObject *_wrap_new_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
12696 PyObject *resultobj;
12697 wxEncodingConverter *result;
12698 char *kwnames[] = {
12699 NULL
12700 };
12701
12702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EncodingConverter",kwnames)) goto fail;
12703 {
12704 PyThreadState* __tstate = wxPyBeginAllowThreads();
12705 result = (wxEncodingConverter *)new wxEncodingConverter();
12706
12707 wxPyEndAllowThreads(__tstate);
12708 if (PyErr_Occurred()) SWIG_fail;
12709 }
12710 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEncodingConverter, 1);
12711 return resultobj;
12712 fail:
12713 return NULL;
12714 }
12715
12716
12717 static PyObject *_wrap_delete_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
12718 PyObject *resultobj;
12719 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12720 PyObject * obj0 = 0 ;
12721 char *kwnames[] = {
12722 (char *) "self", NULL
12723 };
12724
12725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EncodingConverter",kwnames,&obj0)) goto fail;
12726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12727 if (SWIG_arg_fail(1)) SWIG_fail;
12728 {
12729 PyThreadState* __tstate = wxPyBeginAllowThreads();
12730 delete arg1;
12731
12732 wxPyEndAllowThreads(__tstate);
12733 if (PyErr_Occurred()) SWIG_fail;
12734 }
12735 Py_INCREF(Py_None); resultobj = Py_None;
12736 return resultobj;
12737 fail:
12738 return NULL;
12739 }
12740
12741
12742 static PyObject *_wrap_EncodingConverter_Init(PyObject *, PyObject *args, PyObject *kwargs) {
12743 PyObject *resultobj;
12744 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12745 wxFontEncoding arg2 ;
12746 wxFontEncoding arg3 ;
12747 int arg4 = (int) wxCONVERT_STRICT ;
12748 bool result;
12749 PyObject * obj0 = 0 ;
12750 PyObject * obj1 = 0 ;
12751 PyObject * obj2 = 0 ;
12752 PyObject * obj3 = 0 ;
12753 char *kwnames[] = {
12754 (char *) "self",(char *) "input_enc",(char *) "output_enc",(char *) "method", NULL
12755 };
12756
12757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:EncodingConverter_Init",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12759 if (SWIG_arg_fail(1)) SWIG_fail;
12760 {
12761 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12762 if (SWIG_arg_fail(2)) SWIG_fail;
12763 }
12764 {
12765 arg3 = (wxFontEncoding)(SWIG_As_int(obj2));
12766 if (SWIG_arg_fail(3)) SWIG_fail;
12767 }
12768 if (obj3) {
12769 {
12770 arg4 = (int)(SWIG_As_int(obj3));
12771 if (SWIG_arg_fail(4)) SWIG_fail;
12772 }
12773 }
12774 {
12775 PyThreadState* __tstate = wxPyBeginAllowThreads();
12776 result = (bool)(arg1)->Init((wxFontEncoding )arg2,(wxFontEncoding )arg3,arg4);
12777
12778 wxPyEndAllowThreads(__tstate);
12779 if (PyErr_Occurred()) SWIG_fail;
12780 }
12781 {
12782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12783 }
12784 return resultobj;
12785 fail:
12786 return NULL;
12787 }
12788
12789
12790 static PyObject *_wrap_EncodingConverter_Convert(PyObject *, PyObject *args, PyObject *kwargs) {
12791 PyObject *resultobj;
12792 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12793 wxString *arg2 = 0 ;
12794 wxString result;
12795 bool temp2 = false ;
12796 PyObject * obj0 = 0 ;
12797 PyObject * obj1 = 0 ;
12798 char *kwnames[] = {
12799 (char *) "self",(char *) "input", NULL
12800 };
12801
12802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_Convert",kwnames,&obj0,&obj1)) goto fail;
12803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12804 if (SWIG_arg_fail(1)) SWIG_fail;
12805 {
12806 arg2 = wxString_in_helper(obj1);
12807 if (arg2 == NULL) SWIG_fail;
12808 temp2 = true;
12809 }
12810 {
12811 PyThreadState* __tstate = wxPyBeginAllowThreads();
12812 result = (arg1)->Convert((wxString const &)*arg2);
12813
12814 wxPyEndAllowThreads(__tstate);
12815 if (PyErr_Occurred()) SWIG_fail;
12816 }
12817 {
12818 #if wxUSE_UNICODE
12819 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12820 #else
12821 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12822 #endif
12823 }
12824 {
12825 if (temp2)
12826 delete arg2;
12827 }
12828 return resultobj;
12829 fail:
12830 {
12831 if (temp2)
12832 delete arg2;
12833 }
12834 return NULL;
12835 }
12836
12837
12838 static PyObject *_wrap_EncodingConverter_GetPlatformEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12839 PyObject *resultobj;
12840 wxFontEncoding arg1 ;
12841 int arg2 = (int) wxPLATFORM_CURRENT ;
12842 wxFontEncodingArray result;
12843 PyObject * obj0 = 0 ;
12844 PyObject * obj1 = 0 ;
12845 char *kwnames[] = {
12846 (char *) "enc",(char *) "platform", NULL
12847 };
12848
12849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EncodingConverter_GetPlatformEquivalents",kwnames,&obj0,&obj1)) goto fail;
12850 {
12851 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12852 if (SWIG_arg_fail(1)) SWIG_fail;
12853 }
12854 if (obj1) {
12855 {
12856 arg2 = (int)(SWIG_As_int(obj1));
12857 if (SWIG_arg_fail(2)) SWIG_fail;
12858 }
12859 }
12860 {
12861 PyThreadState* __tstate = wxPyBeginAllowThreads();
12862 result = wxEncodingConverter::GetPlatformEquivalents((wxFontEncoding )arg1,arg2);
12863
12864 wxPyEndAllowThreads(__tstate);
12865 if (PyErr_Occurred()) SWIG_fail;
12866 }
12867 {
12868 resultobj = PyList_New(0);
12869 for (size_t i=0; i < (&result)->GetCount(); i++) {
12870 PyObject* number = PyInt_FromLong((&result)->Item(i));
12871 PyList_Append(resultobj, number);
12872 Py_DECREF(number);
12873 }
12874 }
12875 return resultobj;
12876 fail:
12877 return NULL;
12878 }
12879
12880
12881 static PyObject *_wrap_EncodingConverter_GetAllEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12882 PyObject *resultobj;
12883 wxFontEncoding arg1 ;
12884 wxFontEncodingArray result;
12885 PyObject * obj0 = 0 ;
12886 char *kwnames[] = {
12887 (char *) "enc", NULL
12888 };
12889
12890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EncodingConverter_GetAllEquivalents",kwnames,&obj0)) goto fail;
12891 {
12892 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12893 if (SWIG_arg_fail(1)) SWIG_fail;
12894 }
12895 {
12896 PyThreadState* __tstate = wxPyBeginAllowThreads();
12897 result = wxEncodingConverter::GetAllEquivalents((wxFontEncoding )arg1);
12898
12899 wxPyEndAllowThreads(__tstate);
12900 if (PyErr_Occurred()) SWIG_fail;
12901 }
12902 {
12903 resultobj = PyList_New(0);
12904 for (size_t i=0; i < (&result)->GetCount(); i++) {
12905 PyObject* number = PyInt_FromLong((&result)->Item(i));
12906 PyList_Append(resultobj, number);
12907 Py_DECREF(number);
12908 }
12909 }
12910 return resultobj;
12911 fail:
12912 return NULL;
12913 }
12914
12915
12916 static PyObject *_wrap_EncodingConverter_CanConvert(PyObject *, PyObject *args, PyObject *kwargs) {
12917 PyObject *resultobj;
12918 wxFontEncoding arg1 ;
12919 wxFontEncoding arg2 ;
12920 bool result;
12921 PyObject * obj0 = 0 ;
12922 PyObject * obj1 = 0 ;
12923 char *kwnames[] = {
12924 (char *) "encIn",(char *) "encOut", NULL
12925 };
12926
12927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_CanConvert",kwnames,&obj0,&obj1)) goto fail;
12928 {
12929 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12930 if (SWIG_arg_fail(1)) SWIG_fail;
12931 }
12932 {
12933 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12934 if (SWIG_arg_fail(2)) SWIG_fail;
12935 }
12936 {
12937 PyThreadState* __tstate = wxPyBeginAllowThreads();
12938 result = (bool)wxEncodingConverter::CanConvert((wxFontEncoding )arg1,(wxFontEncoding )arg2);
12939
12940 wxPyEndAllowThreads(__tstate);
12941 if (PyErr_Occurred()) SWIG_fail;
12942 }
12943 {
12944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12945 }
12946 return resultobj;
12947 fail:
12948 return NULL;
12949 }
12950
12951
12952 static PyObject * EncodingConverter_swigregister(PyObject *, PyObject *args) {
12953 PyObject *obj;
12954 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12955 SWIG_TypeClientData(SWIGTYPE_p_wxEncodingConverter, obj);
12956 Py_INCREF(obj);
12957 return Py_BuildValue((char *)"");
12958 }
12959 static PyObject *_wrap_delete_DC(PyObject *, PyObject *args, PyObject *kwargs) {
12960 PyObject *resultobj;
12961 wxDC *arg1 = (wxDC *) 0 ;
12962 PyObject * obj0 = 0 ;
12963 char *kwnames[] = {
12964 (char *) "self", NULL
12965 };
12966
12967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DC",kwnames,&obj0)) goto fail;
12968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12969 if (SWIG_arg_fail(1)) SWIG_fail;
12970 {
12971 PyThreadState* __tstate = wxPyBeginAllowThreads();
12972 delete arg1;
12973
12974 wxPyEndAllowThreads(__tstate);
12975 if (PyErr_Occurred()) SWIG_fail;
12976 }
12977 Py_INCREF(Py_None); resultobj = Py_None;
12978 return resultobj;
12979 fail:
12980 return NULL;
12981 }
12982
12983
12984 static PyObject *_wrap_DC_BeginDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12985 PyObject *resultobj;
12986 wxDC *arg1 = (wxDC *) 0 ;
12987 PyObject * obj0 = 0 ;
12988 char *kwnames[] = {
12989 (char *) "self", NULL
12990 };
12991
12992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_BeginDrawing",kwnames,&obj0)) goto fail;
12993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12994 if (SWIG_arg_fail(1)) SWIG_fail;
12995 {
12996 PyThreadState* __tstate = wxPyBeginAllowThreads();
12997 (arg1)->BeginDrawing();
12998
12999 wxPyEndAllowThreads(__tstate);
13000 if (PyErr_Occurred()) SWIG_fail;
13001 }
13002 Py_INCREF(Py_None); resultobj = Py_None;
13003 return resultobj;
13004 fail:
13005 return NULL;
13006 }
13007
13008
13009 static PyObject *_wrap_DC_EndDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
13010 PyObject *resultobj;
13011 wxDC *arg1 = (wxDC *) 0 ;
13012 PyObject * obj0 = 0 ;
13013 char *kwnames[] = {
13014 (char *) "self", NULL
13015 };
13016
13017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDrawing",kwnames,&obj0)) goto fail;
13018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13019 if (SWIG_arg_fail(1)) SWIG_fail;
13020 {
13021 PyThreadState* __tstate = wxPyBeginAllowThreads();
13022 (arg1)->EndDrawing();
13023
13024 wxPyEndAllowThreads(__tstate);
13025 if (PyErr_Occurred()) SWIG_fail;
13026 }
13027 Py_INCREF(Py_None); resultobj = Py_None;
13028 return resultobj;
13029 fail:
13030 return NULL;
13031 }
13032
13033
13034 static PyObject *_wrap_DC_FloodFill(PyObject *, PyObject *args, PyObject *kwargs) {
13035 PyObject *resultobj;
13036 wxDC *arg1 = (wxDC *) 0 ;
13037 int arg2 ;
13038 int arg3 ;
13039 wxColour *arg4 = 0 ;
13040 int arg5 = (int) wxFLOOD_SURFACE ;
13041 bool result;
13042 wxColour temp4 ;
13043 PyObject * obj0 = 0 ;
13044 PyObject * obj1 = 0 ;
13045 PyObject * obj2 = 0 ;
13046 PyObject * obj3 = 0 ;
13047 PyObject * obj4 = 0 ;
13048 char *kwnames[] = {
13049 (char *) "self",(char *) "x",(char *) "y",(char *) "col",(char *) "style", NULL
13050 };
13051
13052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_FloodFill",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13054 if (SWIG_arg_fail(1)) SWIG_fail;
13055 {
13056 arg2 = (int)(SWIG_As_int(obj1));
13057 if (SWIG_arg_fail(2)) SWIG_fail;
13058 }
13059 {
13060 arg3 = (int)(SWIG_As_int(obj2));
13061 if (SWIG_arg_fail(3)) SWIG_fail;
13062 }
13063 {
13064 arg4 = &temp4;
13065 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
13066 }
13067 if (obj4) {
13068 {
13069 arg5 = (int)(SWIG_As_int(obj4));
13070 if (SWIG_arg_fail(5)) SWIG_fail;
13071 }
13072 }
13073 {
13074 PyThreadState* __tstate = wxPyBeginAllowThreads();
13075 result = (bool)(arg1)->FloodFill(arg2,arg3,(wxColour const &)*arg4,arg5);
13076
13077 wxPyEndAllowThreads(__tstate);
13078 if (PyErr_Occurred()) SWIG_fail;
13079 }
13080 {
13081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13082 }
13083 return resultobj;
13084 fail:
13085 return NULL;
13086 }
13087
13088
13089 static PyObject *_wrap_DC_FloodFillPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13090 PyObject *resultobj;
13091 wxDC *arg1 = (wxDC *) 0 ;
13092 wxPoint *arg2 = 0 ;
13093 wxColour *arg3 = 0 ;
13094 int arg4 = (int) wxFLOOD_SURFACE ;
13095 bool result;
13096 wxPoint temp2 ;
13097 wxColour temp3 ;
13098 PyObject * obj0 = 0 ;
13099 PyObject * obj1 = 0 ;
13100 PyObject * obj2 = 0 ;
13101 PyObject * obj3 = 0 ;
13102 char *kwnames[] = {
13103 (char *) "self",(char *) "pt",(char *) "col",(char *) "style", NULL
13104 };
13105
13106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_FloodFillPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13108 if (SWIG_arg_fail(1)) SWIG_fail;
13109 {
13110 arg2 = &temp2;
13111 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13112 }
13113 {
13114 arg3 = &temp3;
13115 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
13116 }
13117 if (obj3) {
13118 {
13119 arg4 = (int)(SWIG_As_int(obj3));
13120 if (SWIG_arg_fail(4)) SWIG_fail;
13121 }
13122 }
13123 {
13124 PyThreadState* __tstate = wxPyBeginAllowThreads();
13125 result = (bool)(arg1)->FloodFill((wxPoint const &)*arg2,(wxColour const &)*arg3,arg4);
13126
13127 wxPyEndAllowThreads(__tstate);
13128 if (PyErr_Occurred()) SWIG_fail;
13129 }
13130 {
13131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13132 }
13133 return resultobj;
13134 fail:
13135 return NULL;
13136 }
13137
13138
13139 static PyObject *_wrap_DC_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
13140 PyObject *resultobj;
13141 wxDC *arg1 = (wxDC *) 0 ;
13142 int arg2 ;
13143 int arg3 ;
13144 wxColour result;
13145 PyObject * obj0 = 0 ;
13146 PyObject * obj1 = 0 ;
13147 PyObject * obj2 = 0 ;
13148 char *kwnames[] = {
13149 (char *) "self",(char *) "x",(char *) "y", NULL
13150 };
13151
13152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_GetPixel",kwnames,&obj0,&obj1,&obj2)) goto fail;
13153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13154 if (SWIG_arg_fail(1)) SWIG_fail;
13155 {
13156 arg2 = (int)(SWIG_As_int(obj1));
13157 if (SWIG_arg_fail(2)) SWIG_fail;
13158 }
13159 {
13160 arg3 = (int)(SWIG_As_int(obj2));
13161 if (SWIG_arg_fail(3)) SWIG_fail;
13162 }
13163 {
13164 PyThreadState* __tstate = wxPyBeginAllowThreads();
13165 result = wxDC_GetPixel(arg1,arg2,arg3);
13166
13167 wxPyEndAllowThreads(__tstate);
13168 if (PyErr_Occurred()) SWIG_fail;
13169 }
13170 {
13171 wxColour * resultptr;
13172 resultptr = new wxColour((wxColour &)(result));
13173 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13174 }
13175 return resultobj;
13176 fail:
13177 return NULL;
13178 }
13179
13180
13181 static PyObject *_wrap_DC_GetPixelPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13182 PyObject *resultobj;
13183 wxDC *arg1 = (wxDC *) 0 ;
13184 wxPoint *arg2 = 0 ;
13185 wxColour result;
13186 wxPoint temp2 ;
13187 PyObject * obj0 = 0 ;
13188 PyObject * obj1 = 0 ;
13189 char *kwnames[] = {
13190 (char *) "self",(char *) "pt", NULL
13191 };
13192
13193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPixelPoint",kwnames,&obj0,&obj1)) goto fail;
13194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13195 if (SWIG_arg_fail(1)) SWIG_fail;
13196 {
13197 arg2 = &temp2;
13198 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13199 }
13200 {
13201 PyThreadState* __tstate = wxPyBeginAllowThreads();
13202 result = wxDC_GetPixelPoint(arg1,(wxPoint const &)*arg2);
13203
13204 wxPyEndAllowThreads(__tstate);
13205 if (PyErr_Occurred()) SWIG_fail;
13206 }
13207 {
13208 wxColour * resultptr;
13209 resultptr = new wxColour((wxColour &)(result));
13210 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
13211 }
13212 return resultobj;
13213 fail:
13214 return NULL;
13215 }
13216
13217
13218 static PyObject *_wrap_DC_DrawLine(PyObject *, PyObject *args, PyObject *kwargs) {
13219 PyObject *resultobj;
13220 wxDC *arg1 = (wxDC *) 0 ;
13221 int arg2 ;
13222 int arg3 ;
13223 int arg4 ;
13224 int arg5 ;
13225 PyObject * obj0 = 0 ;
13226 PyObject * obj1 = 0 ;
13227 PyObject * obj2 = 0 ;
13228 PyObject * obj3 = 0 ;
13229 PyObject * obj4 = 0 ;
13230 char *kwnames[] = {
13231 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2", NULL
13232 };
13233
13234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawLine",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13236 if (SWIG_arg_fail(1)) SWIG_fail;
13237 {
13238 arg2 = (int)(SWIG_As_int(obj1));
13239 if (SWIG_arg_fail(2)) SWIG_fail;
13240 }
13241 {
13242 arg3 = (int)(SWIG_As_int(obj2));
13243 if (SWIG_arg_fail(3)) SWIG_fail;
13244 }
13245 {
13246 arg4 = (int)(SWIG_As_int(obj3));
13247 if (SWIG_arg_fail(4)) SWIG_fail;
13248 }
13249 {
13250 arg5 = (int)(SWIG_As_int(obj4));
13251 if (SWIG_arg_fail(5)) SWIG_fail;
13252 }
13253 {
13254 PyThreadState* __tstate = wxPyBeginAllowThreads();
13255 (arg1)->DrawLine(arg2,arg3,arg4,arg5);
13256
13257 wxPyEndAllowThreads(__tstate);
13258 if (PyErr_Occurred()) SWIG_fail;
13259 }
13260 Py_INCREF(Py_None); resultobj = Py_None;
13261 return resultobj;
13262 fail:
13263 return NULL;
13264 }
13265
13266
13267 static PyObject *_wrap_DC_DrawLinePoint(PyObject *, PyObject *args, PyObject *kwargs) {
13268 PyObject *resultobj;
13269 wxDC *arg1 = (wxDC *) 0 ;
13270 wxPoint *arg2 = 0 ;
13271 wxPoint *arg3 = 0 ;
13272 wxPoint temp2 ;
13273 wxPoint temp3 ;
13274 PyObject * obj0 = 0 ;
13275 PyObject * obj1 = 0 ;
13276 PyObject * obj2 = 0 ;
13277 char *kwnames[] = {
13278 (char *) "self",(char *) "pt1",(char *) "pt2", NULL
13279 };
13280
13281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawLinePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13283 if (SWIG_arg_fail(1)) SWIG_fail;
13284 {
13285 arg2 = &temp2;
13286 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13287 }
13288 {
13289 arg3 = &temp3;
13290 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13291 }
13292 {
13293 PyThreadState* __tstate = wxPyBeginAllowThreads();
13294 (arg1)->DrawLine((wxPoint const &)*arg2,(wxPoint const &)*arg3);
13295
13296 wxPyEndAllowThreads(__tstate);
13297 if (PyErr_Occurred()) SWIG_fail;
13298 }
13299 Py_INCREF(Py_None); resultobj = Py_None;
13300 return resultobj;
13301 fail:
13302 return NULL;
13303 }
13304
13305
13306 static PyObject *_wrap_DC_CrossHair(PyObject *, PyObject *args, PyObject *kwargs) {
13307 PyObject *resultobj;
13308 wxDC *arg1 = (wxDC *) 0 ;
13309 int arg2 ;
13310 int arg3 ;
13311 PyObject * obj0 = 0 ;
13312 PyObject * obj1 = 0 ;
13313 PyObject * obj2 = 0 ;
13314 char *kwnames[] = {
13315 (char *) "self",(char *) "x",(char *) "y", NULL
13316 };
13317
13318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CrossHair",kwnames,&obj0,&obj1,&obj2)) goto fail;
13319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13320 if (SWIG_arg_fail(1)) SWIG_fail;
13321 {
13322 arg2 = (int)(SWIG_As_int(obj1));
13323 if (SWIG_arg_fail(2)) SWIG_fail;
13324 }
13325 {
13326 arg3 = (int)(SWIG_As_int(obj2));
13327 if (SWIG_arg_fail(3)) SWIG_fail;
13328 }
13329 {
13330 PyThreadState* __tstate = wxPyBeginAllowThreads();
13331 (arg1)->CrossHair(arg2,arg3);
13332
13333 wxPyEndAllowThreads(__tstate);
13334 if (PyErr_Occurred()) SWIG_fail;
13335 }
13336 Py_INCREF(Py_None); resultobj = Py_None;
13337 return resultobj;
13338 fail:
13339 return NULL;
13340 }
13341
13342
13343 static PyObject *_wrap_DC_CrossHairPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13344 PyObject *resultobj;
13345 wxDC *arg1 = (wxDC *) 0 ;
13346 wxPoint *arg2 = 0 ;
13347 wxPoint temp2 ;
13348 PyObject * obj0 = 0 ;
13349 PyObject * obj1 = 0 ;
13350 char *kwnames[] = {
13351 (char *) "self",(char *) "pt", NULL
13352 };
13353
13354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CrossHairPoint",kwnames,&obj0,&obj1)) goto fail;
13355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13356 if (SWIG_arg_fail(1)) SWIG_fail;
13357 {
13358 arg2 = &temp2;
13359 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13360 }
13361 {
13362 PyThreadState* __tstate = wxPyBeginAllowThreads();
13363 (arg1)->CrossHair((wxPoint const &)*arg2);
13364
13365 wxPyEndAllowThreads(__tstate);
13366 if (PyErr_Occurred()) SWIG_fail;
13367 }
13368 Py_INCREF(Py_None); resultobj = Py_None;
13369 return resultobj;
13370 fail:
13371 return NULL;
13372 }
13373
13374
13375 static PyObject *_wrap_DC_DrawArc(PyObject *, PyObject *args, PyObject *kwargs) {
13376 PyObject *resultobj;
13377 wxDC *arg1 = (wxDC *) 0 ;
13378 int arg2 ;
13379 int arg3 ;
13380 int arg4 ;
13381 int arg5 ;
13382 int arg6 ;
13383 int arg7 ;
13384 PyObject * obj0 = 0 ;
13385 PyObject * obj1 = 0 ;
13386 PyObject * obj2 = 0 ;
13387 PyObject * obj3 = 0 ;
13388 PyObject * obj4 = 0 ;
13389 PyObject * obj5 = 0 ;
13390 PyObject * obj6 = 0 ;
13391 char *kwnames[] = {
13392 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2",(char *) "xc",(char *) "yc", NULL
13393 };
13394
13395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13397 if (SWIG_arg_fail(1)) SWIG_fail;
13398 {
13399 arg2 = (int)(SWIG_As_int(obj1));
13400 if (SWIG_arg_fail(2)) SWIG_fail;
13401 }
13402 {
13403 arg3 = (int)(SWIG_As_int(obj2));
13404 if (SWIG_arg_fail(3)) SWIG_fail;
13405 }
13406 {
13407 arg4 = (int)(SWIG_As_int(obj3));
13408 if (SWIG_arg_fail(4)) SWIG_fail;
13409 }
13410 {
13411 arg5 = (int)(SWIG_As_int(obj4));
13412 if (SWIG_arg_fail(5)) SWIG_fail;
13413 }
13414 {
13415 arg6 = (int)(SWIG_As_int(obj5));
13416 if (SWIG_arg_fail(6)) SWIG_fail;
13417 }
13418 {
13419 arg7 = (int)(SWIG_As_int(obj6));
13420 if (SWIG_arg_fail(7)) SWIG_fail;
13421 }
13422 {
13423 PyThreadState* __tstate = wxPyBeginAllowThreads();
13424 (arg1)->DrawArc(arg2,arg3,arg4,arg5,arg6,arg7);
13425
13426 wxPyEndAllowThreads(__tstate);
13427 if (PyErr_Occurred()) SWIG_fail;
13428 }
13429 Py_INCREF(Py_None); resultobj = Py_None;
13430 return resultobj;
13431 fail:
13432 return NULL;
13433 }
13434
13435
13436 static PyObject *_wrap_DC_DrawArcPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13437 PyObject *resultobj;
13438 wxDC *arg1 = (wxDC *) 0 ;
13439 wxPoint *arg2 = 0 ;
13440 wxPoint *arg3 = 0 ;
13441 wxPoint *arg4 = 0 ;
13442 wxPoint temp2 ;
13443 wxPoint temp3 ;
13444 wxPoint temp4 ;
13445 PyObject * obj0 = 0 ;
13446 PyObject * obj1 = 0 ;
13447 PyObject * obj2 = 0 ;
13448 PyObject * obj3 = 0 ;
13449 char *kwnames[] = {
13450 (char *) "self",(char *) "pt1",(char *) "pt2",(char *) "center", NULL
13451 };
13452
13453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawArcPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13455 if (SWIG_arg_fail(1)) SWIG_fail;
13456 {
13457 arg2 = &temp2;
13458 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13459 }
13460 {
13461 arg3 = &temp3;
13462 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13463 }
13464 {
13465 arg4 = &temp4;
13466 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
13467 }
13468 {
13469 PyThreadState* __tstate = wxPyBeginAllowThreads();
13470 (arg1)->DrawArc((wxPoint const &)*arg2,(wxPoint const &)*arg3,(wxPoint const &)*arg4);
13471
13472 wxPyEndAllowThreads(__tstate);
13473 if (PyErr_Occurred()) SWIG_fail;
13474 }
13475 Py_INCREF(Py_None); resultobj = Py_None;
13476 return resultobj;
13477 fail:
13478 return NULL;
13479 }
13480
13481
13482 static PyObject *_wrap_DC_DrawCheckMark(PyObject *, PyObject *args, PyObject *kwargs) {
13483 PyObject *resultobj;
13484 wxDC *arg1 = (wxDC *) 0 ;
13485 int arg2 ;
13486 int arg3 ;
13487 int arg4 ;
13488 int arg5 ;
13489 PyObject * obj0 = 0 ;
13490 PyObject * obj1 = 0 ;
13491 PyObject * obj2 = 0 ;
13492 PyObject * obj3 = 0 ;
13493 PyObject * obj4 = 0 ;
13494 char *kwnames[] = {
13495 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13496 };
13497
13498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawCheckMark",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13500 if (SWIG_arg_fail(1)) SWIG_fail;
13501 {
13502 arg2 = (int)(SWIG_As_int(obj1));
13503 if (SWIG_arg_fail(2)) SWIG_fail;
13504 }
13505 {
13506 arg3 = (int)(SWIG_As_int(obj2));
13507 if (SWIG_arg_fail(3)) SWIG_fail;
13508 }
13509 {
13510 arg4 = (int)(SWIG_As_int(obj3));
13511 if (SWIG_arg_fail(4)) SWIG_fail;
13512 }
13513 {
13514 arg5 = (int)(SWIG_As_int(obj4));
13515 if (SWIG_arg_fail(5)) SWIG_fail;
13516 }
13517 {
13518 PyThreadState* __tstate = wxPyBeginAllowThreads();
13519 (arg1)->DrawCheckMark(arg2,arg3,arg4,arg5);
13520
13521 wxPyEndAllowThreads(__tstate);
13522 if (PyErr_Occurred()) SWIG_fail;
13523 }
13524 Py_INCREF(Py_None); resultobj = Py_None;
13525 return resultobj;
13526 fail:
13527 return NULL;
13528 }
13529
13530
13531 static PyObject *_wrap_DC_DrawCheckMarkRect(PyObject *, PyObject *args, PyObject *kwargs) {
13532 PyObject *resultobj;
13533 wxDC *arg1 = (wxDC *) 0 ;
13534 wxRect *arg2 = 0 ;
13535 wxRect temp2 ;
13536 PyObject * obj0 = 0 ;
13537 PyObject * obj1 = 0 ;
13538 char *kwnames[] = {
13539 (char *) "self",(char *) "rect", NULL
13540 };
13541
13542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawCheckMarkRect",kwnames,&obj0,&obj1)) goto fail;
13543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13544 if (SWIG_arg_fail(1)) SWIG_fail;
13545 {
13546 arg2 = &temp2;
13547 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13548 }
13549 {
13550 PyThreadState* __tstate = wxPyBeginAllowThreads();
13551 (arg1)->DrawCheckMark((wxRect const &)*arg2);
13552
13553 wxPyEndAllowThreads(__tstate);
13554 if (PyErr_Occurred()) SWIG_fail;
13555 }
13556 Py_INCREF(Py_None); resultobj = Py_None;
13557 return resultobj;
13558 fail:
13559 return NULL;
13560 }
13561
13562
13563 static PyObject *_wrap_DC_DrawEllipticArc(PyObject *, PyObject *args, PyObject *kwargs) {
13564 PyObject *resultobj;
13565 wxDC *arg1 = (wxDC *) 0 ;
13566 int arg2 ;
13567 int arg3 ;
13568 int arg4 ;
13569 int arg5 ;
13570 double arg6 ;
13571 double arg7 ;
13572 PyObject * obj0 = 0 ;
13573 PyObject * obj1 = 0 ;
13574 PyObject * obj2 = 0 ;
13575 PyObject * obj3 = 0 ;
13576 PyObject * obj4 = 0 ;
13577 PyObject * obj5 = 0 ;
13578 PyObject * obj6 = 0 ;
13579 char *kwnames[] = {
13580 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h",(char *) "start",(char *) "end", NULL
13581 };
13582
13583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawEllipticArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13585 if (SWIG_arg_fail(1)) SWIG_fail;
13586 {
13587 arg2 = (int)(SWIG_As_int(obj1));
13588 if (SWIG_arg_fail(2)) SWIG_fail;
13589 }
13590 {
13591 arg3 = (int)(SWIG_As_int(obj2));
13592 if (SWIG_arg_fail(3)) SWIG_fail;
13593 }
13594 {
13595 arg4 = (int)(SWIG_As_int(obj3));
13596 if (SWIG_arg_fail(4)) SWIG_fail;
13597 }
13598 {
13599 arg5 = (int)(SWIG_As_int(obj4));
13600 if (SWIG_arg_fail(5)) SWIG_fail;
13601 }
13602 {
13603 arg6 = (double)(SWIG_As_double(obj5));
13604 if (SWIG_arg_fail(6)) SWIG_fail;
13605 }
13606 {
13607 arg7 = (double)(SWIG_As_double(obj6));
13608 if (SWIG_arg_fail(7)) SWIG_fail;
13609 }
13610 {
13611 PyThreadState* __tstate = wxPyBeginAllowThreads();
13612 (arg1)->DrawEllipticArc(arg2,arg3,arg4,arg5,arg6,arg7);
13613
13614 wxPyEndAllowThreads(__tstate);
13615 if (PyErr_Occurred()) SWIG_fail;
13616 }
13617 Py_INCREF(Py_None); resultobj = Py_None;
13618 return resultobj;
13619 fail:
13620 return NULL;
13621 }
13622
13623
13624 static PyObject *_wrap_DC_DrawEllipticArcPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13625 PyObject *resultobj;
13626 wxDC *arg1 = (wxDC *) 0 ;
13627 wxPoint *arg2 = 0 ;
13628 wxSize *arg3 = 0 ;
13629 double arg4 ;
13630 double arg5 ;
13631 wxPoint temp2 ;
13632 wxSize temp3 ;
13633 PyObject * obj0 = 0 ;
13634 PyObject * obj1 = 0 ;
13635 PyObject * obj2 = 0 ;
13636 PyObject * obj3 = 0 ;
13637 PyObject * obj4 = 0 ;
13638 char *kwnames[] = {
13639 (char *) "self",(char *) "pt",(char *) "sz",(char *) "start",(char *) "end", NULL
13640 };
13641
13642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipticArcPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13644 if (SWIG_arg_fail(1)) SWIG_fail;
13645 {
13646 arg2 = &temp2;
13647 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13648 }
13649 {
13650 arg3 = &temp3;
13651 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13652 }
13653 {
13654 arg4 = (double)(SWIG_As_double(obj3));
13655 if (SWIG_arg_fail(4)) SWIG_fail;
13656 }
13657 {
13658 arg5 = (double)(SWIG_As_double(obj4));
13659 if (SWIG_arg_fail(5)) SWIG_fail;
13660 }
13661 {
13662 PyThreadState* __tstate = wxPyBeginAllowThreads();
13663 (arg1)->DrawEllipticArc((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,arg5);
13664
13665 wxPyEndAllowThreads(__tstate);
13666 if (PyErr_Occurred()) SWIG_fail;
13667 }
13668 Py_INCREF(Py_None); resultobj = Py_None;
13669 return resultobj;
13670 fail:
13671 return NULL;
13672 }
13673
13674
13675 static PyObject *_wrap_DC_DrawPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13676 PyObject *resultobj;
13677 wxDC *arg1 = (wxDC *) 0 ;
13678 int arg2 ;
13679 int arg3 ;
13680 PyObject * obj0 = 0 ;
13681 PyObject * obj1 = 0 ;
13682 PyObject * obj2 = 0 ;
13683 char *kwnames[] = {
13684 (char *) "self",(char *) "x",(char *) "y", NULL
13685 };
13686
13687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13689 if (SWIG_arg_fail(1)) SWIG_fail;
13690 {
13691 arg2 = (int)(SWIG_As_int(obj1));
13692 if (SWIG_arg_fail(2)) SWIG_fail;
13693 }
13694 {
13695 arg3 = (int)(SWIG_As_int(obj2));
13696 if (SWIG_arg_fail(3)) SWIG_fail;
13697 }
13698 {
13699 PyThreadState* __tstate = wxPyBeginAllowThreads();
13700 (arg1)->DrawPoint(arg2,arg3);
13701
13702 wxPyEndAllowThreads(__tstate);
13703 if (PyErr_Occurred()) SWIG_fail;
13704 }
13705 Py_INCREF(Py_None); resultobj = Py_None;
13706 return resultobj;
13707 fail:
13708 return NULL;
13709 }
13710
13711
13712 static PyObject *_wrap_DC_DrawPointPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13713 PyObject *resultobj;
13714 wxDC *arg1 = (wxDC *) 0 ;
13715 wxPoint *arg2 = 0 ;
13716 wxPoint temp2 ;
13717 PyObject * obj0 = 0 ;
13718 PyObject * obj1 = 0 ;
13719 char *kwnames[] = {
13720 (char *) "self",(char *) "pt", NULL
13721 };
13722
13723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawPointPoint",kwnames,&obj0,&obj1)) goto fail;
13724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13725 if (SWIG_arg_fail(1)) SWIG_fail;
13726 {
13727 arg2 = &temp2;
13728 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13729 }
13730 {
13731 PyThreadState* __tstate = wxPyBeginAllowThreads();
13732 (arg1)->DrawPoint((wxPoint const &)*arg2);
13733
13734 wxPyEndAllowThreads(__tstate);
13735 if (PyErr_Occurred()) SWIG_fail;
13736 }
13737 Py_INCREF(Py_None); resultobj = Py_None;
13738 return resultobj;
13739 fail:
13740 return NULL;
13741 }
13742
13743
13744 static PyObject *_wrap_DC_DrawRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
13745 PyObject *resultobj;
13746 wxDC *arg1 = (wxDC *) 0 ;
13747 int arg2 ;
13748 int arg3 ;
13749 int arg4 ;
13750 int arg5 ;
13751 PyObject * obj0 = 0 ;
13752 PyObject * obj1 = 0 ;
13753 PyObject * obj2 = 0 ;
13754 PyObject * obj3 = 0 ;
13755 PyObject * obj4 = 0 ;
13756 char *kwnames[] = {
13757 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13758 };
13759
13760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13762 if (SWIG_arg_fail(1)) SWIG_fail;
13763 {
13764 arg2 = (int)(SWIG_As_int(obj1));
13765 if (SWIG_arg_fail(2)) SWIG_fail;
13766 }
13767 {
13768 arg3 = (int)(SWIG_As_int(obj2));
13769 if (SWIG_arg_fail(3)) SWIG_fail;
13770 }
13771 {
13772 arg4 = (int)(SWIG_As_int(obj3));
13773 if (SWIG_arg_fail(4)) SWIG_fail;
13774 }
13775 {
13776 arg5 = (int)(SWIG_As_int(obj4));
13777 if (SWIG_arg_fail(5)) SWIG_fail;
13778 }
13779 {
13780 PyThreadState* __tstate = wxPyBeginAllowThreads();
13781 (arg1)->DrawRectangle(arg2,arg3,arg4,arg5);
13782
13783 wxPyEndAllowThreads(__tstate);
13784 if (PyErr_Occurred()) SWIG_fail;
13785 }
13786 Py_INCREF(Py_None); resultobj = Py_None;
13787 return resultobj;
13788 fail:
13789 return NULL;
13790 }
13791
13792
13793 static PyObject *_wrap_DC_DrawRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13794 PyObject *resultobj;
13795 wxDC *arg1 = (wxDC *) 0 ;
13796 wxRect *arg2 = 0 ;
13797 wxRect temp2 ;
13798 PyObject * obj0 = 0 ;
13799 PyObject * obj1 = 0 ;
13800 char *kwnames[] = {
13801 (char *) "self",(char *) "rect", NULL
13802 };
13803
13804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawRectangleRect",kwnames,&obj0,&obj1)) goto fail;
13805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13806 if (SWIG_arg_fail(1)) SWIG_fail;
13807 {
13808 arg2 = &temp2;
13809 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13810 }
13811 {
13812 PyThreadState* __tstate = wxPyBeginAllowThreads();
13813 (arg1)->DrawRectangle((wxRect const &)*arg2);
13814
13815 wxPyEndAllowThreads(__tstate);
13816 if (PyErr_Occurred()) SWIG_fail;
13817 }
13818 Py_INCREF(Py_None); resultobj = Py_None;
13819 return resultobj;
13820 fail:
13821 return NULL;
13822 }
13823
13824
13825 static PyObject *_wrap_DC_DrawRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13826 PyObject *resultobj;
13827 wxDC *arg1 = (wxDC *) 0 ;
13828 wxPoint *arg2 = 0 ;
13829 wxSize *arg3 = 0 ;
13830 wxPoint temp2 ;
13831 wxSize temp3 ;
13832 PyObject * obj0 = 0 ;
13833 PyObject * obj1 = 0 ;
13834 PyObject * obj2 = 0 ;
13835 char *kwnames[] = {
13836 (char *) "self",(char *) "pt",(char *) "sz", NULL
13837 };
13838
13839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRectanglePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13841 if (SWIG_arg_fail(1)) SWIG_fail;
13842 {
13843 arg2 = &temp2;
13844 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13845 }
13846 {
13847 arg3 = &temp3;
13848 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13849 }
13850 {
13851 PyThreadState* __tstate = wxPyBeginAllowThreads();
13852 (arg1)->DrawRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3);
13853
13854 wxPyEndAllowThreads(__tstate);
13855 if (PyErr_Occurred()) SWIG_fail;
13856 }
13857 Py_INCREF(Py_None); resultobj = Py_None;
13858 return resultobj;
13859 fail:
13860 return NULL;
13861 }
13862
13863
13864 static PyObject *_wrap_DC_DrawRoundedRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
13865 PyObject *resultobj;
13866 wxDC *arg1 = (wxDC *) 0 ;
13867 int arg2 ;
13868 int arg3 ;
13869 int arg4 ;
13870 int arg5 ;
13871 double arg6 ;
13872 PyObject * obj0 = 0 ;
13873 PyObject * obj1 = 0 ;
13874 PyObject * obj2 = 0 ;
13875 PyObject * obj3 = 0 ;
13876 PyObject * obj4 = 0 ;
13877 PyObject * obj5 = 0 ;
13878 char *kwnames[] = {
13879 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "radius", NULL
13880 };
13881
13882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:DC_DrawRoundedRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
13883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13884 if (SWIG_arg_fail(1)) SWIG_fail;
13885 {
13886 arg2 = (int)(SWIG_As_int(obj1));
13887 if (SWIG_arg_fail(2)) SWIG_fail;
13888 }
13889 {
13890 arg3 = (int)(SWIG_As_int(obj2));
13891 if (SWIG_arg_fail(3)) SWIG_fail;
13892 }
13893 {
13894 arg4 = (int)(SWIG_As_int(obj3));
13895 if (SWIG_arg_fail(4)) SWIG_fail;
13896 }
13897 {
13898 arg5 = (int)(SWIG_As_int(obj4));
13899 if (SWIG_arg_fail(5)) SWIG_fail;
13900 }
13901 {
13902 arg6 = (double)(SWIG_As_double(obj5));
13903 if (SWIG_arg_fail(6)) SWIG_fail;
13904 }
13905 {
13906 PyThreadState* __tstate = wxPyBeginAllowThreads();
13907 (arg1)->DrawRoundedRectangle(arg2,arg3,arg4,arg5,arg6);
13908
13909 wxPyEndAllowThreads(__tstate);
13910 if (PyErr_Occurred()) SWIG_fail;
13911 }
13912 Py_INCREF(Py_None); resultobj = Py_None;
13913 return resultobj;
13914 fail:
13915 return NULL;
13916 }
13917
13918
13919 static PyObject *_wrap_DC_DrawRoundedRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13920 PyObject *resultobj;
13921 wxDC *arg1 = (wxDC *) 0 ;
13922 wxRect *arg2 = 0 ;
13923 double arg3 ;
13924 wxRect temp2 ;
13925 PyObject * obj0 = 0 ;
13926 PyObject * obj1 = 0 ;
13927 PyObject * obj2 = 0 ;
13928 char *kwnames[] = {
13929 (char *) "self",(char *) "r",(char *) "radius", NULL
13930 };
13931
13932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRoundedRectangleRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
13933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13934 if (SWIG_arg_fail(1)) SWIG_fail;
13935 {
13936 arg2 = &temp2;
13937 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13938 }
13939 {
13940 arg3 = (double)(SWIG_As_double(obj2));
13941 if (SWIG_arg_fail(3)) SWIG_fail;
13942 }
13943 {
13944 PyThreadState* __tstate = wxPyBeginAllowThreads();
13945 (arg1)->DrawRoundedRectangle((wxRect const &)*arg2,arg3);
13946
13947 wxPyEndAllowThreads(__tstate);
13948 if (PyErr_Occurred()) SWIG_fail;
13949 }
13950 Py_INCREF(Py_None); resultobj = Py_None;
13951 return resultobj;
13952 fail:
13953 return NULL;
13954 }
13955
13956
13957 static PyObject *_wrap_DC_DrawRoundedRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13958 PyObject *resultobj;
13959 wxDC *arg1 = (wxDC *) 0 ;
13960 wxPoint *arg2 = 0 ;
13961 wxSize *arg3 = 0 ;
13962 double arg4 ;
13963 wxPoint temp2 ;
13964 wxSize temp3 ;
13965 PyObject * obj0 = 0 ;
13966 PyObject * obj1 = 0 ;
13967 PyObject * obj2 = 0 ;
13968 PyObject * obj3 = 0 ;
13969 char *kwnames[] = {
13970 (char *) "self",(char *) "pt",(char *) "sz",(char *) "radius", NULL
13971 };
13972
13973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRoundedRectanglePointSize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13975 if (SWIG_arg_fail(1)) SWIG_fail;
13976 {
13977 arg2 = &temp2;
13978 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13979 }
13980 {
13981 arg3 = &temp3;
13982 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13983 }
13984 {
13985 arg4 = (double)(SWIG_As_double(obj3));
13986 if (SWIG_arg_fail(4)) SWIG_fail;
13987 }
13988 {
13989 PyThreadState* __tstate = wxPyBeginAllowThreads();
13990 (arg1)->DrawRoundedRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4);
13991
13992 wxPyEndAllowThreads(__tstate);
13993 if (PyErr_Occurred()) SWIG_fail;
13994 }
13995 Py_INCREF(Py_None); resultobj = Py_None;
13996 return resultobj;
13997 fail:
13998 return NULL;
13999 }
14000
14001
14002 static PyObject *_wrap_DC_DrawCircle(PyObject *, PyObject *args, PyObject *kwargs) {
14003 PyObject *resultobj;
14004 wxDC *arg1 = (wxDC *) 0 ;
14005 int arg2 ;
14006 int arg3 ;
14007 int arg4 ;
14008 PyObject * obj0 = 0 ;
14009 PyObject * obj1 = 0 ;
14010 PyObject * obj2 = 0 ;
14011 PyObject * obj3 = 0 ;
14012 char *kwnames[] = {
14013 (char *) "self",(char *) "x",(char *) "y",(char *) "radius", NULL
14014 };
14015
14016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawCircle",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14018 if (SWIG_arg_fail(1)) SWIG_fail;
14019 {
14020 arg2 = (int)(SWIG_As_int(obj1));
14021 if (SWIG_arg_fail(2)) SWIG_fail;
14022 }
14023 {
14024 arg3 = (int)(SWIG_As_int(obj2));
14025 if (SWIG_arg_fail(3)) SWIG_fail;
14026 }
14027 {
14028 arg4 = (int)(SWIG_As_int(obj3));
14029 if (SWIG_arg_fail(4)) SWIG_fail;
14030 }
14031 {
14032 PyThreadState* __tstate = wxPyBeginAllowThreads();
14033 (arg1)->DrawCircle(arg2,arg3,arg4);
14034
14035 wxPyEndAllowThreads(__tstate);
14036 if (PyErr_Occurred()) SWIG_fail;
14037 }
14038 Py_INCREF(Py_None); resultobj = Py_None;
14039 return resultobj;
14040 fail:
14041 return NULL;
14042 }
14043
14044
14045 static PyObject *_wrap_DC_DrawCirclePoint(PyObject *, PyObject *args, PyObject *kwargs) {
14046 PyObject *resultobj;
14047 wxDC *arg1 = (wxDC *) 0 ;
14048 wxPoint *arg2 = 0 ;
14049 int arg3 ;
14050 wxPoint temp2 ;
14051 PyObject * obj0 = 0 ;
14052 PyObject * obj1 = 0 ;
14053 PyObject * obj2 = 0 ;
14054 char *kwnames[] = {
14055 (char *) "self",(char *) "pt",(char *) "radius", NULL
14056 };
14057
14058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawCirclePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
14059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14060 if (SWIG_arg_fail(1)) SWIG_fail;
14061 {
14062 arg2 = &temp2;
14063 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14064 }
14065 {
14066 arg3 = (int)(SWIG_As_int(obj2));
14067 if (SWIG_arg_fail(3)) SWIG_fail;
14068 }
14069 {
14070 PyThreadState* __tstate = wxPyBeginAllowThreads();
14071 (arg1)->DrawCircle((wxPoint const &)*arg2,arg3);
14072
14073 wxPyEndAllowThreads(__tstate);
14074 if (PyErr_Occurred()) SWIG_fail;
14075 }
14076 Py_INCREF(Py_None); resultobj = Py_None;
14077 return resultobj;
14078 fail:
14079 return NULL;
14080 }
14081
14082
14083 static PyObject *_wrap_DC_DrawEllipse(PyObject *, PyObject *args, PyObject *kwargs) {
14084 PyObject *resultobj;
14085 wxDC *arg1 = (wxDC *) 0 ;
14086 int arg2 ;
14087 int arg3 ;
14088 int arg4 ;
14089 int arg5 ;
14090 PyObject * obj0 = 0 ;
14091 PyObject * obj1 = 0 ;
14092 PyObject * obj2 = 0 ;
14093 PyObject * obj3 = 0 ;
14094 PyObject * obj4 = 0 ;
14095 char *kwnames[] = {
14096 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
14097 };
14098
14099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipse",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14101 if (SWIG_arg_fail(1)) SWIG_fail;
14102 {
14103 arg2 = (int)(SWIG_As_int(obj1));
14104 if (SWIG_arg_fail(2)) SWIG_fail;
14105 }
14106 {
14107 arg3 = (int)(SWIG_As_int(obj2));
14108 if (SWIG_arg_fail(3)) SWIG_fail;
14109 }
14110 {
14111 arg4 = (int)(SWIG_As_int(obj3));
14112 if (SWIG_arg_fail(4)) SWIG_fail;
14113 }
14114 {
14115 arg5 = (int)(SWIG_As_int(obj4));
14116 if (SWIG_arg_fail(5)) SWIG_fail;
14117 }
14118 {
14119 PyThreadState* __tstate = wxPyBeginAllowThreads();
14120 (arg1)->DrawEllipse(arg2,arg3,arg4,arg5);
14121
14122 wxPyEndAllowThreads(__tstate);
14123 if (PyErr_Occurred()) SWIG_fail;
14124 }
14125 Py_INCREF(Py_None); resultobj = Py_None;
14126 return resultobj;
14127 fail:
14128 return NULL;
14129 }
14130
14131
14132 static PyObject *_wrap_DC_DrawEllipseRect(PyObject *, PyObject *args, PyObject *kwargs) {
14133 PyObject *resultobj;
14134 wxDC *arg1 = (wxDC *) 0 ;
14135 wxRect *arg2 = 0 ;
14136 wxRect temp2 ;
14137 PyObject * obj0 = 0 ;
14138 PyObject * obj1 = 0 ;
14139 char *kwnames[] = {
14140 (char *) "self",(char *) "rect", NULL
14141 };
14142
14143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawEllipseRect",kwnames,&obj0,&obj1)) goto fail;
14144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14145 if (SWIG_arg_fail(1)) SWIG_fail;
14146 {
14147 arg2 = &temp2;
14148 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14149 }
14150 {
14151 PyThreadState* __tstate = wxPyBeginAllowThreads();
14152 (arg1)->DrawEllipse((wxRect const &)*arg2);
14153
14154 wxPyEndAllowThreads(__tstate);
14155 if (PyErr_Occurred()) SWIG_fail;
14156 }
14157 Py_INCREF(Py_None); resultobj = Py_None;
14158 return resultobj;
14159 fail:
14160 return NULL;
14161 }
14162
14163
14164 static PyObject *_wrap_DC_DrawEllipsePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14165 PyObject *resultobj;
14166 wxDC *arg1 = (wxDC *) 0 ;
14167 wxPoint *arg2 = 0 ;
14168 wxSize *arg3 = 0 ;
14169 wxPoint temp2 ;
14170 wxSize temp3 ;
14171 PyObject * obj0 = 0 ;
14172 PyObject * obj1 = 0 ;
14173 PyObject * obj2 = 0 ;
14174 char *kwnames[] = {
14175 (char *) "self",(char *) "pt",(char *) "sz", NULL
14176 };
14177
14178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawEllipsePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14180 if (SWIG_arg_fail(1)) SWIG_fail;
14181 {
14182 arg2 = &temp2;
14183 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14184 }
14185 {
14186 arg3 = &temp3;
14187 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14188 }
14189 {
14190 PyThreadState* __tstate = wxPyBeginAllowThreads();
14191 (arg1)->DrawEllipse((wxPoint const &)*arg2,(wxSize const &)*arg3);
14192
14193 wxPyEndAllowThreads(__tstate);
14194 if (PyErr_Occurred()) SWIG_fail;
14195 }
14196 Py_INCREF(Py_None); resultobj = Py_None;
14197 return resultobj;
14198 fail:
14199 return NULL;
14200 }
14201
14202
14203 static PyObject *_wrap_DC_DrawIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14204 PyObject *resultobj;
14205 wxDC *arg1 = (wxDC *) 0 ;
14206 wxIcon *arg2 = 0 ;
14207 int arg3 ;
14208 int arg4 ;
14209 PyObject * obj0 = 0 ;
14210 PyObject * obj1 = 0 ;
14211 PyObject * obj2 = 0 ;
14212 PyObject * obj3 = 0 ;
14213 char *kwnames[] = {
14214 (char *) "self",(char *) "icon",(char *) "x",(char *) "y", NULL
14215 };
14216
14217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawIcon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14219 if (SWIG_arg_fail(1)) SWIG_fail;
14220 {
14221 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
14222 if (SWIG_arg_fail(2)) SWIG_fail;
14223 if (arg2 == NULL) {
14224 SWIG_null_ref("wxIcon");
14225 }
14226 if (SWIG_arg_fail(2)) SWIG_fail;
14227 }
14228 {
14229 arg3 = (int)(SWIG_As_int(obj2));
14230 if (SWIG_arg_fail(3)) SWIG_fail;
14231 }
14232 {
14233 arg4 = (int)(SWIG_As_int(obj3));
14234 if (SWIG_arg_fail(4)) SWIG_fail;
14235 }
14236 {
14237 PyThreadState* __tstate = wxPyBeginAllowThreads();
14238 (arg1)->DrawIcon((wxIcon const &)*arg2,arg3,arg4);
14239
14240 wxPyEndAllowThreads(__tstate);
14241 if (PyErr_Occurred()) SWIG_fail;
14242 }
14243 Py_INCREF(Py_None); resultobj = Py_None;
14244 return resultobj;
14245 fail:
14246 return NULL;
14247 }
14248
14249
14250 static PyObject *_wrap_DC_DrawIconPoint(PyObject *, PyObject *args, PyObject *kwargs) {
14251 PyObject *resultobj;
14252 wxDC *arg1 = (wxDC *) 0 ;
14253 wxIcon *arg2 = 0 ;
14254 wxPoint *arg3 = 0 ;
14255 wxPoint temp3 ;
14256 PyObject * obj0 = 0 ;
14257 PyObject * obj1 = 0 ;
14258 PyObject * obj2 = 0 ;
14259 char *kwnames[] = {
14260 (char *) "self",(char *) "icon",(char *) "pt", NULL
14261 };
14262
14263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawIconPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
14264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14265 if (SWIG_arg_fail(1)) SWIG_fail;
14266 {
14267 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
14268 if (SWIG_arg_fail(2)) SWIG_fail;
14269 if (arg2 == NULL) {
14270 SWIG_null_ref("wxIcon");
14271 }
14272 if (SWIG_arg_fail(2)) SWIG_fail;
14273 }
14274 {
14275 arg3 = &temp3;
14276 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14277 }
14278 {
14279 PyThreadState* __tstate = wxPyBeginAllowThreads();
14280 (arg1)->DrawIcon((wxIcon const &)*arg2,(wxPoint const &)*arg3);
14281
14282 wxPyEndAllowThreads(__tstate);
14283 if (PyErr_Occurred()) SWIG_fail;
14284 }
14285 Py_INCREF(Py_None); resultobj = Py_None;
14286 return resultobj;
14287 fail:
14288 return NULL;
14289 }
14290
14291
14292 static PyObject *_wrap_DC_DrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
14293 PyObject *resultobj;
14294 wxDC *arg1 = (wxDC *) 0 ;
14295 wxBitmap *arg2 = 0 ;
14296 int arg3 ;
14297 int arg4 ;
14298 bool arg5 = (bool) false ;
14299 PyObject * obj0 = 0 ;
14300 PyObject * obj1 = 0 ;
14301 PyObject * obj2 = 0 ;
14302 PyObject * obj3 = 0 ;
14303 PyObject * obj4 = 0 ;
14304 char *kwnames[] = {
14305 (char *) "self",(char *) "bmp",(char *) "x",(char *) "y",(char *) "useMask", NULL
14306 };
14307
14308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_DrawBitmap",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14310 if (SWIG_arg_fail(1)) SWIG_fail;
14311 {
14312 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
14313 if (SWIG_arg_fail(2)) SWIG_fail;
14314 if (arg2 == NULL) {
14315 SWIG_null_ref("wxBitmap");
14316 }
14317 if (SWIG_arg_fail(2)) SWIG_fail;
14318 }
14319 {
14320 arg3 = (int)(SWIG_As_int(obj2));
14321 if (SWIG_arg_fail(3)) SWIG_fail;
14322 }
14323 {
14324 arg4 = (int)(SWIG_As_int(obj3));
14325 if (SWIG_arg_fail(4)) SWIG_fail;
14326 }
14327 if (obj4) {
14328 {
14329 arg5 = (bool)(SWIG_As_bool(obj4));
14330 if (SWIG_arg_fail(5)) SWIG_fail;
14331 }
14332 }
14333 {
14334 PyThreadState* __tstate = wxPyBeginAllowThreads();
14335 (arg1)->DrawBitmap((wxBitmap const &)*arg2,arg3,arg4,arg5);
14336
14337 wxPyEndAllowThreads(__tstate);
14338 if (PyErr_Occurred()) SWIG_fail;
14339 }
14340 Py_INCREF(Py_None); resultobj = Py_None;
14341 return resultobj;
14342 fail:
14343 return NULL;
14344 }
14345
14346
14347 static PyObject *_wrap_DC_DrawBitmapPoint(PyObject *, PyObject *args, PyObject *kwargs) {
14348 PyObject *resultobj;
14349 wxDC *arg1 = (wxDC *) 0 ;
14350 wxBitmap *arg2 = 0 ;
14351 wxPoint *arg3 = 0 ;
14352 bool arg4 = (bool) false ;
14353 wxPoint temp3 ;
14354 PyObject * obj0 = 0 ;
14355 PyObject * obj1 = 0 ;
14356 PyObject * obj2 = 0 ;
14357 PyObject * obj3 = 0 ;
14358 char *kwnames[] = {
14359 (char *) "self",(char *) "bmp",(char *) "pt",(char *) "useMask", NULL
14360 };
14361
14362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_DrawBitmapPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14364 if (SWIG_arg_fail(1)) SWIG_fail;
14365 {
14366 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
14367 if (SWIG_arg_fail(2)) SWIG_fail;
14368 if (arg2 == NULL) {
14369 SWIG_null_ref("wxBitmap");
14370 }
14371 if (SWIG_arg_fail(2)) SWIG_fail;
14372 }
14373 {
14374 arg3 = &temp3;
14375 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14376 }
14377 if (obj3) {
14378 {
14379 arg4 = (bool)(SWIG_As_bool(obj3));
14380 if (SWIG_arg_fail(4)) SWIG_fail;
14381 }
14382 }
14383 {
14384 PyThreadState* __tstate = wxPyBeginAllowThreads();
14385 (arg1)->DrawBitmap((wxBitmap const &)*arg2,(wxPoint const &)*arg3,arg4);
14386
14387 wxPyEndAllowThreads(__tstate);
14388 if (PyErr_Occurred()) SWIG_fail;
14389 }
14390 Py_INCREF(Py_None); resultobj = Py_None;
14391 return resultobj;
14392 fail:
14393 return NULL;
14394 }
14395
14396
14397 static PyObject *_wrap_DC_DrawText(PyObject *, PyObject *args, PyObject *kwargs) {
14398 PyObject *resultobj;
14399 wxDC *arg1 = (wxDC *) 0 ;
14400 wxString *arg2 = 0 ;
14401 int arg3 ;
14402 int arg4 ;
14403 bool temp2 = false ;
14404 PyObject * obj0 = 0 ;
14405 PyObject * obj1 = 0 ;
14406 PyObject * obj2 = 0 ;
14407 PyObject * obj3 = 0 ;
14408 char *kwnames[] = {
14409 (char *) "self",(char *) "text",(char *) "x",(char *) "y", NULL
14410 };
14411
14412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawText",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14414 if (SWIG_arg_fail(1)) SWIG_fail;
14415 {
14416 arg2 = wxString_in_helper(obj1);
14417 if (arg2 == NULL) SWIG_fail;
14418 temp2 = true;
14419 }
14420 {
14421 arg3 = (int)(SWIG_As_int(obj2));
14422 if (SWIG_arg_fail(3)) SWIG_fail;
14423 }
14424 {
14425 arg4 = (int)(SWIG_As_int(obj3));
14426 if (SWIG_arg_fail(4)) SWIG_fail;
14427 }
14428 {
14429 PyThreadState* __tstate = wxPyBeginAllowThreads();
14430 (arg1)->DrawText((wxString const &)*arg2,arg3,arg4);
14431
14432 wxPyEndAllowThreads(__tstate);
14433 if (PyErr_Occurred()) SWIG_fail;
14434 }
14435 Py_INCREF(Py_None); resultobj = Py_None;
14436 {
14437 if (temp2)
14438 delete arg2;
14439 }
14440 return resultobj;
14441 fail:
14442 {
14443 if (temp2)
14444 delete arg2;
14445 }
14446 return NULL;
14447 }
14448
14449
14450 static PyObject *_wrap_DC_DrawTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
14451 PyObject *resultobj;
14452 wxDC *arg1 = (wxDC *) 0 ;
14453 wxString *arg2 = 0 ;
14454 wxPoint *arg3 = 0 ;
14455 bool temp2 = false ;
14456 wxPoint temp3 ;
14457 PyObject * obj0 = 0 ;
14458 PyObject * obj1 = 0 ;
14459 PyObject * obj2 = 0 ;
14460 char *kwnames[] = {
14461 (char *) "self",(char *) "text",(char *) "pt", NULL
14462 };
14463
14464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawTextPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
14465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14466 if (SWIG_arg_fail(1)) SWIG_fail;
14467 {
14468 arg2 = wxString_in_helper(obj1);
14469 if (arg2 == NULL) SWIG_fail;
14470 temp2 = true;
14471 }
14472 {
14473 arg3 = &temp3;
14474 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14475 }
14476 {
14477 PyThreadState* __tstate = wxPyBeginAllowThreads();
14478 (arg1)->DrawText((wxString const &)*arg2,(wxPoint const &)*arg3);
14479
14480 wxPyEndAllowThreads(__tstate);
14481 if (PyErr_Occurred()) SWIG_fail;
14482 }
14483 Py_INCREF(Py_None); resultobj = Py_None;
14484 {
14485 if (temp2)
14486 delete arg2;
14487 }
14488 return resultobj;
14489 fail:
14490 {
14491 if (temp2)
14492 delete arg2;
14493 }
14494 return NULL;
14495 }
14496
14497
14498 static PyObject *_wrap_DC_DrawRotatedText(PyObject *, PyObject *args, PyObject *kwargs) {
14499 PyObject *resultobj;
14500 wxDC *arg1 = (wxDC *) 0 ;
14501 wxString *arg2 = 0 ;
14502 int arg3 ;
14503 int arg4 ;
14504 double arg5 ;
14505 bool temp2 = false ;
14506 PyObject * obj0 = 0 ;
14507 PyObject * obj1 = 0 ;
14508 PyObject * obj2 = 0 ;
14509 PyObject * obj3 = 0 ;
14510 PyObject * obj4 = 0 ;
14511 char *kwnames[] = {
14512 (char *) "self",(char *) "text",(char *) "x",(char *) "y",(char *) "angle", NULL
14513 };
14514
14515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRotatedText",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14517 if (SWIG_arg_fail(1)) SWIG_fail;
14518 {
14519 arg2 = wxString_in_helper(obj1);
14520 if (arg2 == NULL) SWIG_fail;
14521 temp2 = true;
14522 }
14523 {
14524 arg3 = (int)(SWIG_As_int(obj2));
14525 if (SWIG_arg_fail(3)) SWIG_fail;
14526 }
14527 {
14528 arg4 = (int)(SWIG_As_int(obj3));
14529 if (SWIG_arg_fail(4)) SWIG_fail;
14530 }
14531 {
14532 arg5 = (double)(SWIG_As_double(obj4));
14533 if (SWIG_arg_fail(5)) SWIG_fail;
14534 }
14535 {
14536 PyThreadState* __tstate = wxPyBeginAllowThreads();
14537 (arg1)->DrawRotatedText((wxString const &)*arg2,arg3,arg4,arg5);
14538
14539 wxPyEndAllowThreads(__tstate);
14540 if (PyErr_Occurred()) SWIG_fail;
14541 }
14542 Py_INCREF(Py_None); resultobj = Py_None;
14543 {
14544 if (temp2)
14545 delete arg2;
14546 }
14547 return resultobj;
14548 fail:
14549 {
14550 if (temp2)
14551 delete arg2;
14552 }
14553 return NULL;
14554 }
14555
14556
14557 static PyObject *_wrap_DC_DrawRotatedTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
14558 PyObject *resultobj;
14559 wxDC *arg1 = (wxDC *) 0 ;
14560 wxString *arg2 = 0 ;
14561 wxPoint *arg3 = 0 ;
14562 double arg4 ;
14563 bool temp2 = false ;
14564 wxPoint temp3 ;
14565 PyObject * obj0 = 0 ;
14566 PyObject * obj1 = 0 ;
14567 PyObject * obj2 = 0 ;
14568 PyObject * obj3 = 0 ;
14569 char *kwnames[] = {
14570 (char *) "self",(char *) "text",(char *) "pt",(char *) "angle", NULL
14571 };
14572
14573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRotatedTextPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14575 if (SWIG_arg_fail(1)) SWIG_fail;
14576 {
14577 arg2 = wxString_in_helper(obj1);
14578 if (arg2 == NULL) SWIG_fail;
14579 temp2 = true;
14580 }
14581 {
14582 arg3 = &temp3;
14583 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14584 }
14585 {
14586 arg4 = (double)(SWIG_As_double(obj3));
14587 if (SWIG_arg_fail(4)) SWIG_fail;
14588 }
14589 {
14590 PyThreadState* __tstate = wxPyBeginAllowThreads();
14591 (arg1)->DrawRotatedText((wxString const &)*arg2,(wxPoint const &)*arg3,arg4);
14592
14593 wxPyEndAllowThreads(__tstate);
14594 if (PyErr_Occurred()) SWIG_fail;
14595 }
14596 Py_INCREF(Py_None); resultobj = Py_None;
14597 {
14598 if (temp2)
14599 delete arg2;
14600 }
14601 return resultobj;
14602 fail:
14603 {
14604 if (temp2)
14605 delete arg2;
14606 }
14607 return NULL;
14608 }
14609
14610
14611 static PyObject *_wrap_DC_Blit(PyObject *, PyObject *args, PyObject *kwargs) {
14612 PyObject *resultobj;
14613 wxDC *arg1 = (wxDC *) 0 ;
14614 int arg2 ;
14615 int arg3 ;
14616 int arg4 ;
14617 int arg5 ;
14618 wxDC *arg6 = (wxDC *) 0 ;
14619 int arg7 ;
14620 int arg8 ;
14621 int arg9 = (int) wxCOPY ;
14622 bool arg10 = (bool) false ;
14623 int arg11 = (int) -1 ;
14624 int arg12 = (int) -1 ;
14625 bool result;
14626 PyObject * obj0 = 0 ;
14627 PyObject * obj1 = 0 ;
14628 PyObject * obj2 = 0 ;
14629 PyObject * obj3 = 0 ;
14630 PyObject * obj4 = 0 ;
14631 PyObject * obj5 = 0 ;
14632 PyObject * obj6 = 0 ;
14633 PyObject * obj7 = 0 ;
14634 PyObject * obj8 = 0 ;
14635 PyObject * obj9 = 0 ;
14636 PyObject * obj10 = 0 ;
14637 PyObject * obj11 = 0 ;
14638 char *kwnames[] = {
14639 (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
14640 };
14641
14642 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;
14643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14644 if (SWIG_arg_fail(1)) SWIG_fail;
14645 {
14646 arg2 = (int)(SWIG_As_int(obj1));
14647 if (SWIG_arg_fail(2)) SWIG_fail;
14648 }
14649 {
14650 arg3 = (int)(SWIG_As_int(obj2));
14651 if (SWIG_arg_fail(3)) SWIG_fail;
14652 }
14653 {
14654 arg4 = (int)(SWIG_As_int(obj3));
14655 if (SWIG_arg_fail(4)) SWIG_fail;
14656 }
14657 {
14658 arg5 = (int)(SWIG_As_int(obj4));
14659 if (SWIG_arg_fail(5)) SWIG_fail;
14660 }
14661 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14662 if (SWIG_arg_fail(6)) SWIG_fail;
14663 {
14664 arg7 = (int)(SWIG_As_int(obj6));
14665 if (SWIG_arg_fail(7)) SWIG_fail;
14666 }
14667 {
14668 arg8 = (int)(SWIG_As_int(obj7));
14669 if (SWIG_arg_fail(8)) SWIG_fail;
14670 }
14671 if (obj8) {
14672 {
14673 arg9 = (int)(SWIG_As_int(obj8));
14674 if (SWIG_arg_fail(9)) SWIG_fail;
14675 }
14676 }
14677 if (obj9) {
14678 {
14679 arg10 = (bool)(SWIG_As_bool(obj9));
14680 if (SWIG_arg_fail(10)) SWIG_fail;
14681 }
14682 }
14683 if (obj10) {
14684 {
14685 arg11 = (int)(SWIG_As_int(obj10));
14686 if (SWIG_arg_fail(11)) SWIG_fail;
14687 }
14688 }
14689 if (obj11) {
14690 {
14691 arg12 = (int)(SWIG_As_int(obj11));
14692 if (SWIG_arg_fail(12)) SWIG_fail;
14693 }
14694 }
14695 {
14696 PyThreadState* __tstate = wxPyBeginAllowThreads();
14697 result = (bool)(arg1)->Blit(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
14698
14699 wxPyEndAllowThreads(__tstate);
14700 if (PyErr_Occurred()) SWIG_fail;
14701 }
14702 {
14703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14704 }
14705 return resultobj;
14706 fail:
14707 return NULL;
14708 }
14709
14710
14711 static PyObject *_wrap_DC_BlitPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14712 PyObject *resultobj;
14713 wxDC *arg1 = (wxDC *) 0 ;
14714 wxPoint *arg2 = 0 ;
14715 wxSize *arg3 = 0 ;
14716 wxDC *arg4 = (wxDC *) 0 ;
14717 wxPoint *arg5 = 0 ;
14718 int arg6 = (int) wxCOPY ;
14719 bool arg7 = (bool) false ;
14720 wxPoint const &arg8_defvalue = wxDefaultPosition ;
14721 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
14722 bool result;
14723 wxPoint temp2 ;
14724 wxSize temp3 ;
14725 wxPoint temp5 ;
14726 wxPoint temp8 ;
14727 PyObject * obj0 = 0 ;
14728 PyObject * obj1 = 0 ;
14729 PyObject * obj2 = 0 ;
14730 PyObject * obj3 = 0 ;
14731 PyObject * obj4 = 0 ;
14732 PyObject * obj5 = 0 ;
14733 PyObject * obj6 = 0 ;
14734 PyObject * obj7 = 0 ;
14735 char *kwnames[] = {
14736 (char *) "self",(char *) "destPt",(char *) "sz",(char *) "source",(char *) "srcPt",(char *) "rop",(char *) "useMask",(char *) "srcPtMask", NULL
14737 };
14738
14739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:DC_BlitPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
14740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14741 if (SWIG_arg_fail(1)) SWIG_fail;
14742 {
14743 arg2 = &temp2;
14744 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14745 }
14746 {
14747 arg3 = &temp3;
14748 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14749 }
14750 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14751 if (SWIG_arg_fail(4)) SWIG_fail;
14752 {
14753 arg5 = &temp5;
14754 if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
14755 }
14756 if (obj5) {
14757 {
14758 arg6 = (int)(SWIG_As_int(obj5));
14759 if (SWIG_arg_fail(6)) SWIG_fail;
14760 }
14761 }
14762 if (obj6) {
14763 {
14764 arg7 = (bool)(SWIG_As_bool(obj6));
14765 if (SWIG_arg_fail(7)) SWIG_fail;
14766 }
14767 }
14768 if (obj7) {
14769 {
14770 arg8 = &temp8;
14771 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
14772 }
14773 }
14774 {
14775 PyThreadState* __tstate = wxPyBeginAllowThreads();
14776 result = (bool)(arg1)->Blit((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,(wxPoint const &)*arg5,arg6,arg7,(wxPoint const &)*arg8);
14777
14778 wxPyEndAllowThreads(__tstate);
14779 if (PyErr_Occurred()) SWIG_fail;
14780 }
14781 {
14782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14783 }
14784 return resultobj;
14785 fail:
14786 return NULL;
14787 }
14788
14789
14790 static PyObject *_wrap_DC_SetClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14791 PyObject *resultobj;
14792 wxDC *arg1 = (wxDC *) 0 ;
14793 int arg2 ;
14794 int arg3 ;
14795 int arg4 ;
14796 int arg5 ;
14797 PyObject * obj0 = 0 ;
14798 PyObject * obj1 = 0 ;
14799 PyObject * obj2 = 0 ;
14800 PyObject * obj3 = 0 ;
14801 PyObject * obj4 = 0 ;
14802 char *kwnames[] = {
14803 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
14804 };
14805
14806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_SetClippingRegion",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14808 if (SWIG_arg_fail(1)) SWIG_fail;
14809 {
14810 arg2 = (int)(SWIG_As_int(obj1));
14811 if (SWIG_arg_fail(2)) SWIG_fail;
14812 }
14813 {
14814 arg3 = (int)(SWIG_As_int(obj2));
14815 if (SWIG_arg_fail(3)) SWIG_fail;
14816 }
14817 {
14818 arg4 = (int)(SWIG_As_int(obj3));
14819 if (SWIG_arg_fail(4)) SWIG_fail;
14820 }
14821 {
14822 arg5 = (int)(SWIG_As_int(obj4));
14823 if (SWIG_arg_fail(5)) SWIG_fail;
14824 }
14825 {
14826 PyThreadState* __tstate = wxPyBeginAllowThreads();
14827 (arg1)->SetClippingRegion(arg2,arg3,arg4,arg5);
14828
14829 wxPyEndAllowThreads(__tstate);
14830 if (PyErr_Occurred()) SWIG_fail;
14831 }
14832 Py_INCREF(Py_None); resultobj = Py_None;
14833 return resultobj;
14834 fail:
14835 return NULL;
14836 }
14837
14838
14839 static PyObject *_wrap_DC_SetClippingRegionPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14840 PyObject *resultobj;
14841 wxDC *arg1 = (wxDC *) 0 ;
14842 wxPoint *arg2 = 0 ;
14843 wxSize *arg3 = 0 ;
14844 wxPoint temp2 ;
14845 wxSize temp3 ;
14846 PyObject * obj0 = 0 ;
14847 PyObject * obj1 = 0 ;
14848 PyObject * obj2 = 0 ;
14849 char *kwnames[] = {
14850 (char *) "self",(char *) "pt",(char *) "sz", NULL
14851 };
14852
14853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetClippingRegionPointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14855 if (SWIG_arg_fail(1)) SWIG_fail;
14856 {
14857 arg2 = &temp2;
14858 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14859 }
14860 {
14861 arg3 = &temp3;
14862 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14863 }
14864 {
14865 PyThreadState* __tstate = wxPyBeginAllowThreads();
14866 (arg1)->SetClippingRegion((wxPoint const &)*arg2,(wxSize const &)*arg3);
14867
14868 wxPyEndAllowThreads(__tstate);
14869 if (PyErr_Occurred()) SWIG_fail;
14870 }
14871 Py_INCREF(Py_None); resultobj = Py_None;
14872 return resultobj;
14873 fail:
14874 return NULL;
14875 }
14876
14877
14878 static PyObject *_wrap_DC_SetClippingRegionAsRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14879 PyObject *resultobj;
14880 wxDC *arg1 = (wxDC *) 0 ;
14881 wxRegion *arg2 = 0 ;
14882 PyObject * obj0 = 0 ;
14883 PyObject * obj1 = 0 ;
14884 char *kwnames[] = {
14885 (char *) "self",(char *) "region", NULL
14886 };
14887
14888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRegionAsRegion",kwnames,&obj0,&obj1)) goto fail;
14889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14890 if (SWIG_arg_fail(1)) SWIG_fail;
14891 {
14892 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
14893 if (SWIG_arg_fail(2)) SWIG_fail;
14894 if (arg2 == NULL) {
14895 SWIG_null_ref("wxRegion");
14896 }
14897 if (SWIG_arg_fail(2)) SWIG_fail;
14898 }
14899 {
14900 PyThreadState* __tstate = wxPyBeginAllowThreads();
14901 (arg1)->SetClippingRegion((wxRegion const &)*arg2);
14902
14903 wxPyEndAllowThreads(__tstate);
14904 if (PyErr_Occurred()) SWIG_fail;
14905 }
14906 Py_INCREF(Py_None); resultobj = Py_None;
14907 return resultobj;
14908 fail:
14909 return NULL;
14910 }
14911
14912
14913 static PyObject *_wrap_DC_SetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
14914 PyObject *resultobj;
14915 wxDC *arg1 = (wxDC *) 0 ;
14916 wxRect *arg2 = 0 ;
14917 wxRect temp2 ;
14918 PyObject * obj0 = 0 ;
14919 PyObject * obj1 = 0 ;
14920 char *kwnames[] = {
14921 (char *) "self",(char *) "rect", NULL
14922 };
14923
14924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRect",kwnames,&obj0,&obj1)) goto fail;
14925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14926 if (SWIG_arg_fail(1)) SWIG_fail;
14927 {
14928 arg2 = &temp2;
14929 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14930 }
14931 {
14932 PyThreadState* __tstate = wxPyBeginAllowThreads();
14933 (arg1)->SetClippingRegion((wxRect const &)*arg2);
14934
14935 wxPyEndAllowThreads(__tstate);
14936 if (PyErr_Occurred()) SWIG_fail;
14937 }
14938 Py_INCREF(Py_None); resultobj = Py_None;
14939 return resultobj;
14940 fail:
14941 return NULL;
14942 }
14943
14944
14945 static PyObject *_wrap_DC_DrawLines(PyObject *, PyObject *args, PyObject *kwargs) {
14946 PyObject *resultobj;
14947 wxDC *arg1 = (wxDC *) 0 ;
14948 int arg2 ;
14949 wxPoint *arg3 = (wxPoint *) 0 ;
14950 int arg4 = (int) 0 ;
14951 int arg5 = (int) 0 ;
14952 PyObject * obj0 = 0 ;
14953 PyObject * obj1 = 0 ;
14954 PyObject * obj2 = 0 ;
14955 PyObject * obj3 = 0 ;
14956 char *kwnames[] = {
14957 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset", NULL
14958 };
14959
14960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DC_DrawLines",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14962 if (SWIG_arg_fail(1)) SWIG_fail;
14963 {
14964 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14965 if (arg3 == NULL) SWIG_fail;
14966 }
14967 if (obj2) {
14968 {
14969 arg4 = (int)(SWIG_As_int(obj2));
14970 if (SWIG_arg_fail(4)) SWIG_fail;
14971 }
14972 }
14973 if (obj3) {
14974 {
14975 arg5 = (int)(SWIG_As_int(obj3));
14976 if (SWIG_arg_fail(5)) SWIG_fail;
14977 }
14978 }
14979 {
14980 PyThreadState* __tstate = wxPyBeginAllowThreads();
14981 (arg1)->DrawLines(arg2,arg3,arg4,arg5);
14982
14983 wxPyEndAllowThreads(__tstate);
14984 if (PyErr_Occurred()) SWIG_fail;
14985 }
14986 Py_INCREF(Py_None); resultobj = Py_None;
14987 {
14988 if (arg3) delete [] arg3;
14989 }
14990 return resultobj;
14991 fail:
14992 {
14993 if (arg3) delete [] arg3;
14994 }
14995 return NULL;
14996 }
14997
14998
14999 static PyObject *_wrap_DC_DrawPolygon(PyObject *, PyObject *args, PyObject *kwargs) {
15000 PyObject *resultobj;
15001 wxDC *arg1 = (wxDC *) 0 ;
15002 int arg2 ;
15003 wxPoint *arg3 = (wxPoint *) 0 ;
15004 int arg4 = (int) 0 ;
15005 int arg5 = (int) 0 ;
15006 int arg6 = (int) wxODDEVEN_RULE ;
15007 PyObject * obj0 = 0 ;
15008 PyObject * obj1 = 0 ;
15009 PyObject * obj2 = 0 ;
15010 PyObject * obj3 = 0 ;
15011 PyObject * obj4 = 0 ;
15012 char *kwnames[] = {
15013 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset",(char *) "fillStyle", NULL
15014 };
15015
15016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DC_DrawPolygon",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
15017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15018 if (SWIG_arg_fail(1)) SWIG_fail;
15019 {
15020 arg3 = wxPoint_LIST_helper(obj1, &arg2);
15021 if (arg3 == NULL) SWIG_fail;
15022 }
15023 if (obj2) {
15024 {
15025 arg4 = (int)(SWIG_As_int(obj2));
15026 if (SWIG_arg_fail(4)) SWIG_fail;
15027 }
15028 }
15029 if (obj3) {
15030 {
15031 arg5 = (int)(SWIG_As_int(obj3));
15032 if (SWIG_arg_fail(5)) SWIG_fail;
15033 }
15034 }
15035 if (obj4) {
15036 {
15037 arg6 = (int)(SWIG_As_int(obj4));
15038 if (SWIG_arg_fail(6)) SWIG_fail;
15039 }
15040 }
15041 {
15042 PyThreadState* __tstate = wxPyBeginAllowThreads();
15043 (arg1)->DrawPolygon(arg2,arg3,arg4,arg5,arg6);
15044
15045 wxPyEndAllowThreads(__tstate);
15046 if (PyErr_Occurred()) SWIG_fail;
15047 }
15048 Py_INCREF(Py_None); resultobj = Py_None;
15049 {
15050 if (arg3) delete [] arg3;
15051 }
15052 return resultobj;
15053 fail:
15054 {
15055 if (arg3) delete [] arg3;
15056 }
15057 return NULL;
15058 }
15059
15060
15061 static PyObject *_wrap_DC_DrawLabel(PyObject *, PyObject *args, PyObject *kwargs) {
15062 PyObject *resultobj;
15063 wxDC *arg1 = (wxDC *) 0 ;
15064 wxString *arg2 = 0 ;
15065 wxRect *arg3 = 0 ;
15066 int arg4 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
15067 int arg5 = (int) -1 ;
15068 bool temp2 = false ;
15069 wxRect temp3 ;
15070 PyObject * obj0 = 0 ;
15071 PyObject * obj1 = 0 ;
15072 PyObject * obj2 = 0 ;
15073 PyObject * obj3 = 0 ;
15074 PyObject * obj4 = 0 ;
15075 char *kwnames[] = {
15076 (char *) "self",(char *) "text",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
15077 };
15078
15079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:DC_DrawLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
15080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15081 if (SWIG_arg_fail(1)) SWIG_fail;
15082 {
15083 arg2 = wxString_in_helper(obj1);
15084 if (arg2 == NULL) SWIG_fail;
15085 temp2 = true;
15086 }
15087 {
15088 arg3 = &temp3;
15089 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
15090 }
15091 if (obj3) {
15092 {
15093 arg4 = (int)(SWIG_As_int(obj3));
15094 if (SWIG_arg_fail(4)) SWIG_fail;
15095 }
15096 }
15097 if (obj4) {
15098 {
15099 arg5 = (int)(SWIG_As_int(obj4));
15100 if (SWIG_arg_fail(5)) SWIG_fail;
15101 }
15102 }
15103 {
15104 PyThreadState* __tstate = wxPyBeginAllowThreads();
15105 (arg1)->DrawLabel((wxString const &)*arg2,(wxRect const &)*arg3,arg4,arg5);
15106
15107 wxPyEndAllowThreads(__tstate);
15108 if (PyErr_Occurred()) SWIG_fail;
15109 }
15110 Py_INCREF(Py_None); resultobj = Py_None;
15111 {
15112 if (temp2)
15113 delete arg2;
15114 }
15115 return resultobj;
15116 fail:
15117 {
15118 if (temp2)
15119 delete arg2;
15120 }
15121 return NULL;
15122 }
15123
15124
15125 static PyObject *_wrap_DC_DrawImageLabel(PyObject *, PyObject *args, PyObject *kwargs) {
15126 PyObject *resultobj;
15127 wxDC *arg1 = (wxDC *) 0 ;
15128 wxString *arg2 = 0 ;
15129 wxBitmap *arg3 = 0 ;
15130 wxRect *arg4 = 0 ;
15131 int arg5 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
15132 int arg6 = (int) -1 ;
15133 wxRect result;
15134 bool temp2 = false ;
15135 wxRect temp4 ;
15136 PyObject * obj0 = 0 ;
15137 PyObject * obj1 = 0 ;
15138 PyObject * obj2 = 0 ;
15139 PyObject * obj3 = 0 ;
15140 PyObject * obj4 = 0 ;
15141 PyObject * obj5 = 0 ;
15142 char *kwnames[] = {
15143 (char *) "self",(char *) "text",(char *) "image",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
15144 };
15145
15146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:DC_DrawImageLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
15147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15148 if (SWIG_arg_fail(1)) SWIG_fail;
15149 {
15150 arg2 = wxString_in_helper(obj1);
15151 if (arg2 == NULL) SWIG_fail;
15152 temp2 = true;
15153 }
15154 {
15155 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
15156 if (SWIG_arg_fail(3)) SWIG_fail;
15157 if (arg3 == NULL) {
15158 SWIG_null_ref("wxBitmap");
15159 }
15160 if (SWIG_arg_fail(3)) SWIG_fail;
15161 }
15162 {
15163 arg4 = &temp4;
15164 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
15165 }
15166 if (obj4) {
15167 {
15168 arg5 = (int)(SWIG_As_int(obj4));
15169 if (SWIG_arg_fail(5)) SWIG_fail;
15170 }
15171 }
15172 if (obj5) {
15173 {
15174 arg6 = (int)(SWIG_As_int(obj5));
15175 if (SWIG_arg_fail(6)) SWIG_fail;
15176 }
15177 }
15178 {
15179 PyThreadState* __tstate = wxPyBeginAllowThreads();
15180 result = wxDC_DrawImageLabel(arg1,(wxString const &)*arg2,(wxBitmap const &)*arg3,(wxRect const &)*arg4,arg5,arg6);
15181
15182 wxPyEndAllowThreads(__tstate);
15183 if (PyErr_Occurred()) SWIG_fail;
15184 }
15185 {
15186 wxRect * resultptr;
15187 resultptr = new wxRect((wxRect &)(result));
15188 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
15189 }
15190 {
15191 if (temp2)
15192 delete arg2;
15193 }
15194 return resultobj;
15195 fail:
15196 {
15197 if (temp2)
15198 delete arg2;
15199 }
15200 return NULL;
15201 }
15202
15203
15204 static PyObject *_wrap_DC_DrawSpline(PyObject *, PyObject *args, PyObject *kwargs) {
15205 PyObject *resultobj;
15206 wxDC *arg1 = (wxDC *) 0 ;
15207 int arg2 ;
15208 wxPoint *arg3 = (wxPoint *) 0 ;
15209 PyObject * obj0 = 0 ;
15210 PyObject * obj1 = 0 ;
15211 char *kwnames[] = {
15212 (char *) "self",(char *) "points", NULL
15213 };
15214
15215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawSpline",kwnames,&obj0,&obj1)) goto fail;
15216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15217 if (SWIG_arg_fail(1)) SWIG_fail;
15218 {
15219 arg3 = wxPoint_LIST_helper(obj1, &arg2);
15220 if (arg3 == NULL) SWIG_fail;
15221 }
15222 {
15223 PyThreadState* __tstate = wxPyBeginAllowThreads();
15224 (arg1)->DrawSpline(arg2,arg3);
15225
15226 wxPyEndAllowThreads(__tstate);
15227 if (PyErr_Occurred()) SWIG_fail;
15228 }
15229 Py_INCREF(Py_None); resultobj = Py_None;
15230 {
15231 if (arg3) delete [] arg3;
15232 }
15233 return resultobj;
15234 fail:
15235 {
15236 if (arg3) delete [] arg3;
15237 }
15238 return NULL;
15239 }
15240
15241
15242 static PyObject *_wrap_DC_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
15243 PyObject *resultobj;
15244 wxDC *arg1 = (wxDC *) 0 ;
15245 PyObject * obj0 = 0 ;
15246 char *kwnames[] = {
15247 (char *) "self", NULL
15248 };
15249
15250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Clear",kwnames,&obj0)) goto fail;
15251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15252 if (SWIG_arg_fail(1)) SWIG_fail;
15253 {
15254 PyThreadState* __tstate = wxPyBeginAllowThreads();
15255 (arg1)->Clear();
15256
15257 wxPyEndAllowThreads(__tstate);
15258 if (PyErr_Occurred()) SWIG_fail;
15259 }
15260 Py_INCREF(Py_None); resultobj = Py_None;
15261 return resultobj;
15262 fail:
15263 return NULL;
15264 }
15265
15266
15267 static PyObject *_wrap_DC_StartDoc(PyObject *, PyObject *args, PyObject *kwargs) {
15268 PyObject *resultobj;
15269 wxDC *arg1 = (wxDC *) 0 ;
15270 wxString *arg2 = 0 ;
15271 bool result;
15272 bool temp2 = false ;
15273 PyObject * obj0 = 0 ;
15274 PyObject * obj1 = 0 ;
15275 char *kwnames[] = {
15276 (char *) "self",(char *) "message", NULL
15277 };
15278
15279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_StartDoc",kwnames,&obj0,&obj1)) goto fail;
15280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15281 if (SWIG_arg_fail(1)) SWIG_fail;
15282 {
15283 arg2 = wxString_in_helper(obj1);
15284 if (arg2 == NULL) SWIG_fail;
15285 temp2 = true;
15286 }
15287 {
15288 PyThreadState* __tstate = wxPyBeginAllowThreads();
15289 result = (bool)(arg1)->StartDoc((wxString const &)*arg2);
15290
15291 wxPyEndAllowThreads(__tstate);
15292 if (PyErr_Occurred()) SWIG_fail;
15293 }
15294 {
15295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15296 }
15297 {
15298 if (temp2)
15299 delete arg2;
15300 }
15301 return resultobj;
15302 fail:
15303 {
15304 if (temp2)
15305 delete arg2;
15306 }
15307 return NULL;
15308 }
15309
15310
15311 static PyObject *_wrap_DC_EndDoc(PyObject *, PyObject *args, PyObject *kwargs) {
15312 PyObject *resultobj;
15313 wxDC *arg1 = (wxDC *) 0 ;
15314 PyObject * obj0 = 0 ;
15315 char *kwnames[] = {
15316 (char *) "self", NULL
15317 };
15318
15319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDoc",kwnames,&obj0)) goto fail;
15320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15321 if (SWIG_arg_fail(1)) SWIG_fail;
15322 {
15323 PyThreadState* __tstate = wxPyBeginAllowThreads();
15324 (arg1)->EndDoc();
15325
15326 wxPyEndAllowThreads(__tstate);
15327 if (PyErr_Occurred()) SWIG_fail;
15328 }
15329 Py_INCREF(Py_None); resultobj = Py_None;
15330 return resultobj;
15331 fail:
15332 return NULL;
15333 }
15334
15335
15336 static PyObject *_wrap_DC_StartPage(PyObject *, PyObject *args, PyObject *kwargs) {
15337 PyObject *resultobj;
15338 wxDC *arg1 = (wxDC *) 0 ;
15339 PyObject * obj0 = 0 ;
15340 char *kwnames[] = {
15341 (char *) "self", NULL
15342 };
15343
15344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_StartPage",kwnames,&obj0)) goto fail;
15345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15346 if (SWIG_arg_fail(1)) SWIG_fail;
15347 {
15348 PyThreadState* __tstate = wxPyBeginAllowThreads();
15349 (arg1)->StartPage();
15350
15351 wxPyEndAllowThreads(__tstate);
15352 if (PyErr_Occurred()) SWIG_fail;
15353 }
15354 Py_INCREF(Py_None); resultobj = Py_None;
15355 return resultobj;
15356 fail:
15357 return NULL;
15358 }
15359
15360
15361 static PyObject *_wrap_DC_EndPage(PyObject *, PyObject *args, PyObject *kwargs) {
15362 PyObject *resultobj;
15363 wxDC *arg1 = (wxDC *) 0 ;
15364 PyObject * obj0 = 0 ;
15365 char *kwnames[] = {
15366 (char *) "self", NULL
15367 };
15368
15369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndPage",kwnames,&obj0)) goto fail;
15370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15371 if (SWIG_arg_fail(1)) SWIG_fail;
15372 {
15373 PyThreadState* __tstate = wxPyBeginAllowThreads();
15374 (arg1)->EndPage();
15375
15376 wxPyEndAllowThreads(__tstate);
15377 if (PyErr_Occurred()) SWIG_fail;
15378 }
15379 Py_INCREF(Py_None); resultobj = Py_None;
15380 return resultobj;
15381 fail:
15382 return NULL;
15383 }
15384
15385
15386 static PyObject *_wrap_DC_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
15387 PyObject *resultobj;
15388 wxDC *arg1 = (wxDC *) 0 ;
15389 wxFont *arg2 = 0 ;
15390 PyObject * obj0 = 0 ;
15391 PyObject * obj1 = 0 ;
15392 char *kwnames[] = {
15393 (char *) "self",(char *) "font", NULL
15394 };
15395
15396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetFont",kwnames,&obj0,&obj1)) goto fail;
15397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15398 if (SWIG_arg_fail(1)) SWIG_fail;
15399 {
15400 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15401 if (SWIG_arg_fail(2)) SWIG_fail;
15402 if (arg2 == NULL) {
15403 SWIG_null_ref("wxFont");
15404 }
15405 if (SWIG_arg_fail(2)) SWIG_fail;
15406 }
15407 {
15408 PyThreadState* __tstate = wxPyBeginAllowThreads();
15409 (arg1)->SetFont((wxFont const &)*arg2);
15410
15411 wxPyEndAllowThreads(__tstate);
15412 if (PyErr_Occurred()) SWIG_fail;
15413 }
15414 Py_INCREF(Py_None); resultobj = Py_None;
15415 return resultobj;
15416 fail:
15417 return NULL;
15418 }
15419
15420
15421 static PyObject *_wrap_DC_SetPen(PyObject *, PyObject *args, PyObject *kwargs) {
15422 PyObject *resultobj;
15423 wxDC *arg1 = (wxDC *) 0 ;
15424 wxPen *arg2 = 0 ;
15425 PyObject * obj0 = 0 ;
15426 PyObject * obj1 = 0 ;
15427 char *kwnames[] = {
15428 (char *) "self",(char *) "pen", NULL
15429 };
15430
15431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPen",kwnames,&obj0,&obj1)) goto fail;
15432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15433 if (SWIG_arg_fail(1)) SWIG_fail;
15434 {
15435 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
15436 if (SWIG_arg_fail(2)) SWIG_fail;
15437 if (arg2 == NULL) {
15438 SWIG_null_ref("wxPen");
15439 }
15440 if (SWIG_arg_fail(2)) SWIG_fail;
15441 }
15442 {
15443 PyThreadState* __tstate = wxPyBeginAllowThreads();
15444 (arg1)->SetPen((wxPen const &)*arg2);
15445
15446 wxPyEndAllowThreads(__tstate);
15447 if (PyErr_Occurred()) SWIG_fail;
15448 }
15449 Py_INCREF(Py_None); resultobj = Py_None;
15450 return resultobj;
15451 fail:
15452 return NULL;
15453 }
15454
15455
15456 static PyObject *_wrap_DC_SetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
15457 PyObject *resultobj;
15458 wxDC *arg1 = (wxDC *) 0 ;
15459 wxBrush *arg2 = 0 ;
15460 PyObject * obj0 = 0 ;
15461 PyObject * obj1 = 0 ;
15462 char *kwnames[] = {
15463 (char *) "self",(char *) "brush", NULL
15464 };
15465
15466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBrush",kwnames,&obj0,&obj1)) goto fail;
15467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15468 if (SWIG_arg_fail(1)) SWIG_fail;
15469 {
15470 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
15471 if (SWIG_arg_fail(2)) SWIG_fail;
15472 if (arg2 == NULL) {
15473 SWIG_null_ref("wxBrush");
15474 }
15475 if (SWIG_arg_fail(2)) SWIG_fail;
15476 }
15477 {
15478 PyThreadState* __tstate = wxPyBeginAllowThreads();
15479 (arg1)->SetBrush((wxBrush const &)*arg2);
15480
15481 wxPyEndAllowThreads(__tstate);
15482 if (PyErr_Occurred()) SWIG_fail;
15483 }
15484 Py_INCREF(Py_None); resultobj = Py_None;
15485 return resultobj;
15486 fail:
15487 return NULL;
15488 }
15489
15490
15491 static PyObject *_wrap_DC_SetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
15492 PyObject *resultobj;
15493 wxDC *arg1 = (wxDC *) 0 ;
15494 wxBrush *arg2 = 0 ;
15495 PyObject * obj0 = 0 ;
15496 PyObject * obj1 = 0 ;
15497 char *kwnames[] = {
15498 (char *) "self",(char *) "brush", NULL
15499 };
15500
15501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackground",kwnames,&obj0,&obj1)) goto fail;
15502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15503 if (SWIG_arg_fail(1)) SWIG_fail;
15504 {
15505 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
15506 if (SWIG_arg_fail(2)) SWIG_fail;
15507 if (arg2 == NULL) {
15508 SWIG_null_ref("wxBrush");
15509 }
15510 if (SWIG_arg_fail(2)) SWIG_fail;
15511 }
15512 {
15513 PyThreadState* __tstate = wxPyBeginAllowThreads();
15514 (arg1)->SetBackground((wxBrush const &)*arg2);
15515
15516 wxPyEndAllowThreads(__tstate);
15517 if (PyErr_Occurred()) SWIG_fail;
15518 }
15519 Py_INCREF(Py_None); resultobj = Py_None;
15520 return resultobj;
15521 fail:
15522 return NULL;
15523 }
15524
15525
15526 static PyObject *_wrap_DC_SetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
15527 PyObject *resultobj;
15528 wxDC *arg1 = (wxDC *) 0 ;
15529 int arg2 ;
15530 PyObject * obj0 = 0 ;
15531 PyObject * obj1 = 0 ;
15532 char *kwnames[] = {
15533 (char *) "self",(char *) "mode", NULL
15534 };
15535
15536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackgroundMode",kwnames,&obj0,&obj1)) goto fail;
15537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15538 if (SWIG_arg_fail(1)) SWIG_fail;
15539 {
15540 arg2 = (int)(SWIG_As_int(obj1));
15541 if (SWIG_arg_fail(2)) SWIG_fail;
15542 }
15543 {
15544 PyThreadState* __tstate = wxPyBeginAllowThreads();
15545 (arg1)->SetBackgroundMode(arg2);
15546
15547 wxPyEndAllowThreads(__tstate);
15548 if (PyErr_Occurred()) SWIG_fail;
15549 }
15550 Py_INCREF(Py_None); resultobj = Py_None;
15551 return resultobj;
15552 fail:
15553 return NULL;
15554 }
15555
15556
15557 static PyObject *_wrap_DC_SetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
15558 PyObject *resultobj;
15559 wxDC *arg1 = (wxDC *) 0 ;
15560 wxPalette *arg2 = 0 ;
15561 PyObject * obj0 = 0 ;
15562 PyObject * obj1 = 0 ;
15563 char *kwnames[] = {
15564 (char *) "self",(char *) "palette", NULL
15565 };
15566
15567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPalette",kwnames,&obj0,&obj1)) goto fail;
15568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15569 if (SWIG_arg_fail(1)) SWIG_fail;
15570 {
15571 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
15572 if (SWIG_arg_fail(2)) SWIG_fail;
15573 if (arg2 == NULL) {
15574 SWIG_null_ref("wxPalette");
15575 }
15576 if (SWIG_arg_fail(2)) SWIG_fail;
15577 }
15578 {
15579 PyThreadState* __tstate = wxPyBeginAllowThreads();
15580 (arg1)->SetPalette((wxPalette const &)*arg2);
15581
15582 wxPyEndAllowThreads(__tstate);
15583 if (PyErr_Occurred()) SWIG_fail;
15584 }
15585 Py_INCREF(Py_None); resultobj = Py_None;
15586 return resultobj;
15587 fail:
15588 return NULL;
15589 }
15590
15591
15592 static PyObject *_wrap_DC_DestroyClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
15593 PyObject *resultobj;
15594 wxDC *arg1 = (wxDC *) 0 ;
15595 PyObject * obj0 = 0 ;
15596 char *kwnames[] = {
15597 (char *) "self", NULL
15598 };
15599
15600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_DestroyClippingRegion",kwnames,&obj0)) goto fail;
15601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15602 if (SWIG_arg_fail(1)) SWIG_fail;
15603 {
15604 PyThreadState* __tstate = wxPyBeginAllowThreads();
15605 (arg1)->DestroyClippingRegion();
15606
15607 wxPyEndAllowThreads(__tstate);
15608 if (PyErr_Occurred()) SWIG_fail;
15609 }
15610 Py_INCREF(Py_None); resultobj = Py_None;
15611 return resultobj;
15612 fail:
15613 return NULL;
15614 }
15615
15616
15617 static PyObject *_wrap_DC_GetClippingBox(PyObject *, PyObject *args, PyObject *kwargs) {
15618 PyObject *resultobj;
15619 wxDC *arg1 = (wxDC *) 0 ;
15620 int *arg2 = (int *) 0 ;
15621 int *arg3 = (int *) 0 ;
15622 int *arg4 = (int *) 0 ;
15623 int *arg5 = (int *) 0 ;
15624 int temp2 ;
15625 int res2 = 0 ;
15626 int temp3 ;
15627 int res3 = 0 ;
15628 int temp4 ;
15629 int res4 = 0 ;
15630 int temp5 ;
15631 int res5 = 0 ;
15632 PyObject * obj0 = 0 ;
15633 char *kwnames[] = {
15634 (char *) "self", NULL
15635 };
15636
15637 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15638 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15639 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15640 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingBox",kwnames,&obj0)) goto fail;
15642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15643 if (SWIG_arg_fail(1)) SWIG_fail;
15644 {
15645 PyThreadState* __tstate = wxPyBeginAllowThreads();
15646 ((wxDC const *)arg1)->GetClippingBox(arg2,arg3,arg4,arg5);
15647
15648 wxPyEndAllowThreads(__tstate);
15649 if (PyErr_Occurred()) SWIG_fail;
15650 }
15651 Py_INCREF(Py_None); resultobj = Py_None;
15652 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15653 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15654 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15655 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15656 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15657 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15658 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15659 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15660 return resultobj;
15661 fail:
15662 return NULL;
15663 }
15664
15665
15666 static PyObject *_wrap_DC_GetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
15667 PyObject *resultobj;
15668 wxDC *arg1 = (wxDC *) 0 ;
15669 wxRect result;
15670 PyObject * obj0 = 0 ;
15671 char *kwnames[] = {
15672 (char *) "self", NULL
15673 };
15674
15675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingRect",kwnames,&obj0)) goto fail;
15676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15677 if (SWIG_arg_fail(1)) SWIG_fail;
15678 {
15679 PyThreadState* __tstate = wxPyBeginAllowThreads();
15680 result = wxDC_GetClippingRect(arg1);
15681
15682 wxPyEndAllowThreads(__tstate);
15683 if (PyErr_Occurred()) SWIG_fail;
15684 }
15685 {
15686 wxRect * resultptr;
15687 resultptr = new wxRect((wxRect &)(result));
15688 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
15689 }
15690 return resultobj;
15691 fail:
15692 return NULL;
15693 }
15694
15695
15696 static PyObject *_wrap_DC_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
15697 PyObject *resultobj;
15698 wxDC *arg1 = (wxDC *) 0 ;
15699 int result;
15700 PyObject * obj0 = 0 ;
15701 char *kwnames[] = {
15702 (char *) "self", NULL
15703 };
15704
15705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharHeight",kwnames,&obj0)) goto fail;
15706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15707 if (SWIG_arg_fail(1)) SWIG_fail;
15708 {
15709 PyThreadState* __tstate = wxPyBeginAllowThreads();
15710 result = (int)((wxDC const *)arg1)->GetCharHeight();
15711
15712 wxPyEndAllowThreads(__tstate);
15713 if (PyErr_Occurred()) SWIG_fail;
15714 }
15715 {
15716 resultobj = SWIG_From_int((int)(result));
15717 }
15718 return resultobj;
15719 fail:
15720 return NULL;
15721 }
15722
15723
15724 static PyObject *_wrap_DC_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
15725 PyObject *resultobj;
15726 wxDC *arg1 = (wxDC *) 0 ;
15727 int result;
15728 PyObject * obj0 = 0 ;
15729 char *kwnames[] = {
15730 (char *) "self", NULL
15731 };
15732
15733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharWidth",kwnames,&obj0)) goto fail;
15734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15735 if (SWIG_arg_fail(1)) SWIG_fail;
15736 {
15737 PyThreadState* __tstate = wxPyBeginAllowThreads();
15738 result = (int)((wxDC const *)arg1)->GetCharWidth();
15739
15740 wxPyEndAllowThreads(__tstate);
15741 if (PyErr_Occurred()) SWIG_fail;
15742 }
15743 {
15744 resultobj = SWIG_From_int((int)(result));
15745 }
15746 return resultobj;
15747 fail:
15748 return NULL;
15749 }
15750
15751
15752 static PyObject *_wrap_DC_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15753 PyObject *resultobj;
15754 wxDC *arg1 = (wxDC *) 0 ;
15755 wxString *arg2 = 0 ;
15756 int *arg3 = (int *) 0 ;
15757 int *arg4 = (int *) 0 ;
15758 bool temp2 = false ;
15759 int temp3 ;
15760 int res3 = 0 ;
15761 int temp4 ;
15762 int res4 = 0 ;
15763 PyObject * obj0 = 0 ;
15764 PyObject * obj1 = 0 ;
15765 char *kwnames[] = {
15766 (char *) "self",(char *) "string", NULL
15767 };
15768
15769 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15770 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
15772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15773 if (SWIG_arg_fail(1)) SWIG_fail;
15774 {
15775 arg2 = wxString_in_helper(obj1);
15776 if (arg2 == NULL) SWIG_fail;
15777 temp2 = true;
15778 }
15779 {
15780 PyThreadState* __tstate = wxPyBeginAllowThreads();
15781 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
15782
15783 wxPyEndAllowThreads(__tstate);
15784 if (PyErr_Occurred()) SWIG_fail;
15785 }
15786 Py_INCREF(Py_None); resultobj = Py_None;
15787 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15788 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15789 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15790 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15791 {
15792 if (temp2)
15793 delete arg2;
15794 }
15795 return resultobj;
15796 fail:
15797 {
15798 if (temp2)
15799 delete arg2;
15800 }
15801 return NULL;
15802 }
15803
15804
15805 static PyObject *_wrap_DC_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15806 PyObject *resultobj;
15807 wxDC *arg1 = (wxDC *) 0 ;
15808 wxString *arg2 = 0 ;
15809 int *arg3 = (int *) 0 ;
15810 int *arg4 = (int *) 0 ;
15811 int *arg5 = (int *) 0 ;
15812 int *arg6 = (int *) 0 ;
15813 wxFont *arg7 = (wxFont *) NULL ;
15814 bool temp2 = false ;
15815 int temp3 ;
15816 int res3 = 0 ;
15817 int temp4 ;
15818 int res4 = 0 ;
15819 int temp5 ;
15820 int res5 = 0 ;
15821 int temp6 ;
15822 int res6 = 0 ;
15823 PyObject * obj0 = 0 ;
15824 PyObject * obj1 = 0 ;
15825 PyObject * obj2 = 0 ;
15826 char *kwnames[] = {
15827 (char *) "self",(char *) "string",(char *) "font", NULL
15828 };
15829
15830 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15831 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15832 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15833 arg6 = &temp6; res6 = SWIG_NEWOBJ;
15834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15836 if (SWIG_arg_fail(1)) SWIG_fail;
15837 {
15838 arg2 = wxString_in_helper(obj1);
15839 if (arg2 == NULL) SWIG_fail;
15840 temp2 = true;
15841 }
15842 if (obj2) {
15843 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15844 if (SWIG_arg_fail(7)) SWIG_fail;
15845 }
15846 {
15847 PyThreadState* __tstate = wxPyBeginAllowThreads();
15848 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7);
15849
15850 wxPyEndAllowThreads(__tstate);
15851 if (PyErr_Occurred()) SWIG_fail;
15852 }
15853 Py_INCREF(Py_None); resultobj = Py_None;
15854 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15855 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15856 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15857 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15858 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15859 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15860 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
15861 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
15862 {
15863 if (temp2)
15864 delete arg2;
15865 }
15866 return resultobj;
15867 fail:
15868 {
15869 if (temp2)
15870 delete arg2;
15871 }
15872 return NULL;
15873 }
15874
15875
15876 static PyObject *_wrap_DC_GetMultiLineTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15877 PyObject *resultobj;
15878 wxDC *arg1 = (wxDC *) 0 ;
15879 wxString *arg2 = 0 ;
15880 int *arg3 = (int *) 0 ;
15881 int *arg4 = (int *) 0 ;
15882 int *arg5 = (int *) 0 ;
15883 wxFont *arg6 = (wxFont *) NULL ;
15884 bool temp2 = false ;
15885 int temp3 ;
15886 int res3 = 0 ;
15887 int temp4 ;
15888 int res4 = 0 ;
15889 int temp5 ;
15890 int res5 = 0 ;
15891 PyObject * obj0 = 0 ;
15892 PyObject * obj1 = 0 ;
15893 PyObject * obj2 = 0 ;
15894 char *kwnames[] = {
15895 (char *) "self",(char *) "text",(char *) "font", NULL
15896 };
15897
15898 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15899 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15900 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetMultiLineTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15903 if (SWIG_arg_fail(1)) SWIG_fail;
15904 {
15905 arg2 = wxString_in_helper(obj1);
15906 if (arg2 == NULL) SWIG_fail;
15907 temp2 = true;
15908 }
15909 if (obj2) {
15910 SWIG_Python_ConvertPtr(obj2, (void **)&arg6, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15911 if (SWIG_arg_fail(6)) SWIG_fail;
15912 }
15913 {
15914 PyThreadState* __tstate = wxPyBeginAllowThreads();
15915 (arg1)->GetMultiLineTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6);
15916
15917 wxPyEndAllowThreads(__tstate);
15918 if (PyErr_Occurred()) SWIG_fail;
15919 }
15920 Py_INCREF(Py_None); resultobj = Py_None;
15921 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15922 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15923 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15924 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15925 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15926 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15927 {
15928 if (temp2)
15929 delete arg2;
15930 }
15931 return resultobj;
15932 fail:
15933 {
15934 if (temp2)
15935 delete arg2;
15936 }
15937 return NULL;
15938 }
15939
15940
15941 static PyObject *_wrap_DC_GetPartialTextExtents(PyObject *, PyObject *args, PyObject *kwargs) {
15942 PyObject *resultobj;
15943 wxDC *arg1 = (wxDC *) 0 ;
15944 wxString *arg2 = 0 ;
15945 wxArrayInt result;
15946 bool temp2 = false ;
15947 PyObject * obj0 = 0 ;
15948 PyObject * obj1 = 0 ;
15949 char *kwnames[] = {
15950 (char *) "self",(char *) "text", NULL
15951 };
15952
15953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPartialTextExtents",kwnames,&obj0,&obj1)) goto fail;
15954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15955 if (SWIG_arg_fail(1)) SWIG_fail;
15956 {
15957 arg2 = wxString_in_helper(obj1);
15958 if (arg2 == NULL) SWIG_fail;
15959 temp2 = true;
15960 }
15961 {
15962 PyThreadState* __tstate = wxPyBeginAllowThreads();
15963 result = wxDC_GetPartialTextExtents(arg1,(wxString const &)*arg2);
15964
15965 wxPyEndAllowThreads(__tstate);
15966 if (PyErr_Occurred()) SWIG_fail;
15967 }
15968 {
15969 resultobj = PyList_New(0);
15970 size_t idx;
15971 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
15972 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
15973 PyList_Append(resultobj, val);
15974 Py_DECREF(val);
15975 }
15976 }
15977 {
15978 if (temp2)
15979 delete arg2;
15980 }
15981 return resultobj;
15982 fail:
15983 {
15984 if (temp2)
15985 delete arg2;
15986 }
15987 return NULL;
15988 }
15989
15990
15991 static PyObject *_wrap_DC_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
15992 PyObject *resultobj;
15993 wxDC *arg1 = (wxDC *) 0 ;
15994 wxSize result;
15995 PyObject * obj0 = 0 ;
15996 char *kwnames[] = {
15997 (char *) "self", NULL
15998 };
15999
16000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSize",kwnames,&obj0)) goto fail;
16001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16002 if (SWIG_arg_fail(1)) SWIG_fail;
16003 {
16004 PyThreadState* __tstate = wxPyBeginAllowThreads();
16005 result = (arg1)->GetSize();
16006
16007 wxPyEndAllowThreads(__tstate);
16008 if (PyErr_Occurred()) SWIG_fail;
16009 }
16010 {
16011 wxSize * resultptr;
16012 resultptr = new wxSize((wxSize &)(result));
16013 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
16014 }
16015 return resultobj;
16016 fail:
16017 return NULL;
16018 }
16019
16020
16021 static PyObject *_wrap_DC_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16022 PyObject *resultobj;
16023 wxDC *arg1 = (wxDC *) 0 ;
16024 int *arg2 = (int *) 0 ;
16025 int *arg3 = (int *) 0 ;
16026 int temp2 ;
16027 int res2 = 0 ;
16028 int temp3 ;
16029 int res3 = 0 ;
16030 PyObject * obj0 = 0 ;
16031 char *kwnames[] = {
16032 (char *) "self", NULL
16033 };
16034
16035 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16036 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeTuple",kwnames,&obj0)) goto fail;
16038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16039 if (SWIG_arg_fail(1)) SWIG_fail;
16040 {
16041 PyThreadState* __tstate = wxPyBeginAllowThreads();
16042 (arg1)->GetSize(arg2,arg3);
16043
16044 wxPyEndAllowThreads(__tstate);
16045 if (PyErr_Occurred()) SWIG_fail;
16046 }
16047 Py_INCREF(Py_None); resultobj = Py_None;
16048 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16049 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16050 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16051 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16052 return resultobj;
16053 fail:
16054 return NULL;
16055 }
16056
16057
16058 static PyObject *_wrap_DC_GetSizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
16059 PyObject *resultobj;
16060 wxDC *arg1 = (wxDC *) 0 ;
16061 wxSize result;
16062 PyObject * obj0 = 0 ;
16063 char *kwnames[] = {
16064 (char *) "self", NULL
16065 };
16066
16067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMM",kwnames,&obj0)) goto fail;
16068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16069 if (SWIG_arg_fail(1)) SWIG_fail;
16070 {
16071 PyThreadState* __tstate = wxPyBeginAllowThreads();
16072 result = ((wxDC const *)arg1)->GetSizeMM();
16073
16074 wxPyEndAllowThreads(__tstate);
16075 if (PyErr_Occurred()) SWIG_fail;
16076 }
16077 {
16078 wxSize * resultptr;
16079 resultptr = new wxSize((wxSize &)(result));
16080 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
16081 }
16082 return resultobj;
16083 fail:
16084 return NULL;
16085 }
16086
16087
16088 static PyObject *_wrap_DC_GetSizeMMTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16089 PyObject *resultobj;
16090 wxDC *arg1 = (wxDC *) 0 ;
16091 int *arg2 = (int *) 0 ;
16092 int *arg3 = (int *) 0 ;
16093 int temp2 ;
16094 int res2 = 0 ;
16095 int temp3 ;
16096 int res3 = 0 ;
16097 PyObject * obj0 = 0 ;
16098 char *kwnames[] = {
16099 (char *) "self", NULL
16100 };
16101
16102 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16103 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMMTuple",kwnames,&obj0)) goto fail;
16105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16106 if (SWIG_arg_fail(1)) SWIG_fail;
16107 {
16108 PyThreadState* __tstate = wxPyBeginAllowThreads();
16109 ((wxDC const *)arg1)->GetSizeMM(arg2,arg3);
16110
16111 wxPyEndAllowThreads(__tstate);
16112 if (PyErr_Occurred()) SWIG_fail;
16113 }
16114 Py_INCREF(Py_None); resultobj = Py_None;
16115 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16116 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16117 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16118 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16119 return resultobj;
16120 fail:
16121 return NULL;
16122 }
16123
16124
16125 static PyObject *_wrap_DC_DeviceToLogicalX(PyObject *, PyObject *args, PyObject *kwargs) {
16126 PyObject *resultobj;
16127 wxDC *arg1 = (wxDC *) 0 ;
16128 int arg2 ;
16129 int result;
16130 PyObject * obj0 = 0 ;
16131 PyObject * obj1 = 0 ;
16132 char *kwnames[] = {
16133 (char *) "self",(char *) "x", NULL
16134 };
16135
16136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalX",kwnames,&obj0,&obj1)) goto fail;
16137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16138 if (SWIG_arg_fail(1)) SWIG_fail;
16139 {
16140 arg2 = (int)(SWIG_As_int(obj1));
16141 if (SWIG_arg_fail(2)) SWIG_fail;
16142 }
16143 {
16144 PyThreadState* __tstate = wxPyBeginAllowThreads();
16145 result = (int)((wxDC const *)arg1)->DeviceToLogicalX(arg2);
16146
16147 wxPyEndAllowThreads(__tstate);
16148 if (PyErr_Occurred()) SWIG_fail;
16149 }
16150 {
16151 resultobj = SWIG_From_int((int)(result));
16152 }
16153 return resultobj;
16154 fail:
16155 return NULL;
16156 }
16157
16158
16159 static PyObject *_wrap_DC_DeviceToLogicalY(PyObject *, PyObject *args, PyObject *kwargs) {
16160 PyObject *resultobj;
16161 wxDC *arg1 = (wxDC *) 0 ;
16162 int arg2 ;
16163 int result;
16164 PyObject * obj0 = 0 ;
16165 PyObject * obj1 = 0 ;
16166 char *kwnames[] = {
16167 (char *) "self",(char *) "y", NULL
16168 };
16169
16170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalY",kwnames,&obj0,&obj1)) goto fail;
16171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16172 if (SWIG_arg_fail(1)) SWIG_fail;
16173 {
16174 arg2 = (int)(SWIG_As_int(obj1));
16175 if (SWIG_arg_fail(2)) SWIG_fail;
16176 }
16177 {
16178 PyThreadState* __tstate = wxPyBeginAllowThreads();
16179 result = (int)((wxDC const *)arg1)->DeviceToLogicalY(arg2);
16180
16181 wxPyEndAllowThreads(__tstate);
16182 if (PyErr_Occurred()) SWIG_fail;
16183 }
16184 {
16185 resultobj = SWIG_From_int((int)(result));
16186 }
16187 return resultobj;
16188 fail:
16189 return NULL;
16190 }
16191
16192
16193 static PyObject *_wrap_DC_DeviceToLogicalXRel(PyObject *, PyObject *args, PyObject *kwargs) {
16194 PyObject *resultobj;
16195 wxDC *arg1 = (wxDC *) 0 ;
16196 int arg2 ;
16197 int result;
16198 PyObject * obj0 = 0 ;
16199 PyObject * obj1 = 0 ;
16200 char *kwnames[] = {
16201 (char *) "self",(char *) "x", NULL
16202 };
16203
16204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalXRel",kwnames,&obj0,&obj1)) goto fail;
16205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16206 if (SWIG_arg_fail(1)) SWIG_fail;
16207 {
16208 arg2 = (int)(SWIG_As_int(obj1));
16209 if (SWIG_arg_fail(2)) SWIG_fail;
16210 }
16211 {
16212 PyThreadState* __tstate = wxPyBeginAllowThreads();
16213 result = (int)((wxDC const *)arg1)->DeviceToLogicalXRel(arg2);
16214
16215 wxPyEndAllowThreads(__tstate);
16216 if (PyErr_Occurred()) SWIG_fail;
16217 }
16218 {
16219 resultobj = SWIG_From_int((int)(result));
16220 }
16221 return resultobj;
16222 fail:
16223 return NULL;
16224 }
16225
16226
16227 static PyObject *_wrap_DC_DeviceToLogicalYRel(PyObject *, PyObject *args, PyObject *kwargs) {
16228 PyObject *resultobj;
16229 wxDC *arg1 = (wxDC *) 0 ;
16230 int arg2 ;
16231 int result;
16232 PyObject * obj0 = 0 ;
16233 PyObject * obj1 = 0 ;
16234 char *kwnames[] = {
16235 (char *) "self",(char *) "y", NULL
16236 };
16237
16238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalYRel",kwnames,&obj0,&obj1)) goto fail;
16239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16240 if (SWIG_arg_fail(1)) SWIG_fail;
16241 {
16242 arg2 = (int)(SWIG_As_int(obj1));
16243 if (SWIG_arg_fail(2)) SWIG_fail;
16244 }
16245 {
16246 PyThreadState* __tstate = wxPyBeginAllowThreads();
16247 result = (int)((wxDC const *)arg1)->DeviceToLogicalYRel(arg2);
16248
16249 wxPyEndAllowThreads(__tstate);
16250 if (PyErr_Occurred()) SWIG_fail;
16251 }
16252 {
16253 resultobj = SWIG_From_int((int)(result));
16254 }
16255 return resultobj;
16256 fail:
16257 return NULL;
16258 }
16259
16260
16261 static PyObject *_wrap_DC_LogicalToDeviceX(PyObject *, PyObject *args, PyObject *kwargs) {
16262 PyObject *resultobj;
16263 wxDC *arg1 = (wxDC *) 0 ;
16264 int arg2 ;
16265 int result;
16266 PyObject * obj0 = 0 ;
16267 PyObject * obj1 = 0 ;
16268 char *kwnames[] = {
16269 (char *) "self",(char *) "x", NULL
16270 };
16271
16272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceX",kwnames,&obj0,&obj1)) goto fail;
16273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16274 if (SWIG_arg_fail(1)) SWIG_fail;
16275 {
16276 arg2 = (int)(SWIG_As_int(obj1));
16277 if (SWIG_arg_fail(2)) SWIG_fail;
16278 }
16279 {
16280 PyThreadState* __tstate = wxPyBeginAllowThreads();
16281 result = (int)((wxDC const *)arg1)->LogicalToDeviceX(arg2);
16282
16283 wxPyEndAllowThreads(__tstate);
16284 if (PyErr_Occurred()) SWIG_fail;
16285 }
16286 {
16287 resultobj = SWIG_From_int((int)(result));
16288 }
16289 return resultobj;
16290 fail:
16291 return NULL;
16292 }
16293
16294
16295 static PyObject *_wrap_DC_LogicalToDeviceY(PyObject *, PyObject *args, PyObject *kwargs) {
16296 PyObject *resultobj;
16297 wxDC *arg1 = (wxDC *) 0 ;
16298 int arg2 ;
16299 int result;
16300 PyObject * obj0 = 0 ;
16301 PyObject * obj1 = 0 ;
16302 char *kwnames[] = {
16303 (char *) "self",(char *) "y", NULL
16304 };
16305
16306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceY",kwnames,&obj0,&obj1)) goto fail;
16307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16308 if (SWIG_arg_fail(1)) SWIG_fail;
16309 {
16310 arg2 = (int)(SWIG_As_int(obj1));
16311 if (SWIG_arg_fail(2)) SWIG_fail;
16312 }
16313 {
16314 PyThreadState* __tstate = wxPyBeginAllowThreads();
16315 result = (int)((wxDC const *)arg1)->LogicalToDeviceY(arg2);
16316
16317 wxPyEndAllowThreads(__tstate);
16318 if (PyErr_Occurred()) SWIG_fail;
16319 }
16320 {
16321 resultobj = SWIG_From_int((int)(result));
16322 }
16323 return resultobj;
16324 fail:
16325 return NULL;
16326 }
16327
16328
16329 static PyObject *_wrap_DC_LogicalToDeviceXRel(PyObject *, PyObject *args, PyObject *kwargs) {
16330 PyObject *resultobj;
16331 wxDC *arg1 = (wxDC *) 0 ;
16332 int arg2 ;
16333 int result;
16334 PyObject * obj0 = 0 ;
16335 PyObject * obj1 = 0 ;
16336 char *kwnames[] = {
16337 (char *) "self",(char *) "x", NULL
16338 };
16339
16340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceXRel",kwnames,&obj0,&obj1)) goto fail;
16341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16342 if (SWIG_arg_fail(1)) SWIG_fail;
16343 {
16344 arg2 = (int)(SWIG_As_int(obj1));
16345 if (SWIG_arg_fail(2)) SWIG_fail;
16346 }
16347 {
16348 PyThreadState* __tstate = wxPyBeginAllowThreads();
16349 result = (int)((wxDC const *)arg1)->LogicalToDeviceXRel(arg2);
16350
16351 wxPyEndAllowThreads(__tstate);
16352 if (PyErr_Occurred()) SWIG_fail;
16353 }
16354 {
16355 resultobj = SWIG_From_int((int)(result));
16356 }
16357 return resultobj;
16358 fail:
16359 return NULL;
16360 }
16361
16362
16363 static PyObject *_wrap_DC_LogicalToDeviceYRel(PyObject *, PyObject *args, PyObject *kwargs) {
16364 PyObject *resultobj;
16365 wxDC *arg1 = (wxDC *) 0 ;
16366 int arg2 ;
16367 int result;
16368 PyObject * obj0 = 0 ;
16369 PyObject * obj1 = 0 ;
16370 char *kwnames[] = {
16371 (char *) "self",(char *) "y", NULL
16372 };
16373
16374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceYRel",kwnames,&obj0,&obj1)) goto fail;
16375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16376 if (SWIG_arg_fail(1)) SWIG_fail;
16377 {
16378 arg2 = (int)(SWIG_As_int(obj1));
16379 if (SWIG_arg_fail(2)) SWIG_fail;
16380 }
16381 {
16382 PyThreadState* __tstate = wxPyBeginAllowThreads();
16383 result = (int)((wxDC const *)arg1)->LogicalToDeviceYRel(arg2);
16384
16385 wxPyEndAllowThreads(__tstate);
16386 if (PyErr_Occurred()) SWIG_fail;
16387 }
16388 {
16389 resultobj = SWIG_From_int((int)(result));
16390 }
16391 return resultobj;
16392 fail:
16393 return NULL;
16394 }
16395
16396
16397 static PyObject *_wrap_DC_CanDrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16398 PyObject *resultobj;
16399 wxDC *arg1 = (wxDC *) 0 ;
16400 bool result;
16401 PyObject * obj0 = 0 ;
16402 char *kwnames[] = {
16403 (char *) "self", NULL
16404 };
16405
16406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanDrawBitmap",kwnames,&obj0)) goto fail;
16407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16408 if (SWIG_arg_fail(1)) SWIG_fail;
16409 {
16410 PyThreadState* __tstate = wxPyBeginAllowThreads();
16411 result = (bool)((wxDC const *)arg1)->CanDrawBitmap();
16412
16413 wxPyEndAllowThreads(__tstate);
16414 if (PyErr_Occurred()) SWIG_fail;
16415 }
16416 {
16417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16418 }
16419 return resultobj;
16420 fail:
16421 return NULL;
16422 }
16423
16424
16425 static PyObject *_wrap_DC_CanGetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
16426 PyObject *resultobj;
16427 wxDC *arg1 = (wxDC *) 0 ;
16428 bool result;
16429 PyObject * obj0 = 0 ;
16430 char *kwnames[] = {
16431 (char *) "self", NULL
16432 };
16433
16434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanGetTextExtent",kwnames,&obj0)) goto fail;
16435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16436 if (SWIG_arg_fail(1)) SWIG_fail;
16437 {
16438 PyThreadState* __tstate = wxPyBeginAllowThreads();
16439 result = (bool)((wxDC const *)arg1)->CanGetTextExtent();
16440
16441 wxPyEndAllowThreads(__tstate);
16442 if (PyErr_Occurred()) SWIG_fail;
16443 }
16444 {
16445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16446 }
16447 return resultobj;
16448 fail:
16449 return NULL;
16450 }
16451
16452
16453 static PyObject *_wrap_DC_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
16454 PyObject *resultobj;
16455 wxDC *arg1 = (wxDC *) 0 ;
16456 int result;
16457 PyObject * obj0 = 0 ;
16458 char *kwnames[] = {
16459 (char *) "self", NULL
16460 };
16461
16462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDepth",kwnames,&obj0)) goto fail;
16463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16464 if (SWIG_arg_fail(1)) SWIG_fail;
16465 {
16466 PyThreadState* __tstate = wxPyBeginAllowThreads();
16467 result = (int)((wxDC const *)arg1)->GetDepth();
16468
16469 wxPyEndAllowThreads(__tstate);
16470 if (PyErr_Occurred()) SWIG_fail;
16471 }
16472 {
16473 resultobj = SWIG_From_int((int)(result));
16474 }
16475 return resultobj;
16476 fail:
16477 return NULL;
16478 }
16479
16480
16481 static PyObject *_wrap_DC_GetPPI(PyObject *, PyObject *args, PyObject *kwargs) {
16482 PyObject *resultobj;
16483 wxDC *arg1 = (wxDC *) 0 ;
16484 wxSize result;
16485 PyObject * obj0 = 0 ;
16486 char *kwnames[] = {
16487 (char *) "self", NULL
16488 };
16489
16490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPPI",kwnames,&obj0)) goto fail;
16491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16492 if (SWIG_arg_fail(1)) SWIG_fail;
16493 {
16494 PyThreadState* __tstate = wxPyBeginAllowThreads();
16495 result = ((wxDC const *)arg1)->GetPPI();
16496
16497 wxPyEndAllowThreads(__tstate);
16498 if (PyErr_Occurred()) SWIG_fail;
16499 }
16500 {
16501 wxSize * resultptr;
16502 resultptr = new wxSize((wxSize &)(result));
16503 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
16504 }
16505 return resultobj;
16506 fail:
16507 return NULL;
16508 }
16509
16510
16511 static PyObject *_wrap_DC_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
16512 PyObject *resultobj;
16513 wxDC *arg1 = (wxDC *) 0 ;
16514 bool result;
16515 PyObject * obj0 = 0 ;
16516 char *kwnames[] = {
16517 (char *) "self", NULL
16518 };
16519
16520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Ok",kwnames,&obj0)) goto fail;
16521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16522 if (SWIG_arg_fail(1)) SWIG_fail;
16523 {
16524 PyThreadState* __tstate = wxPyBeginAllowThreads();
16525 result = (bool)((wxDC const *)arg1)->Ok();
16526
16527 wxPyEndAllowThreads(__tstate);
16528 if (PyErr_Occurred()) SWIG_fail;
16529 }
16530 {
16531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16532 }
16533 return resultobj;
16534 fail:
16535 return NULL;
16536 }
16537
16538
16539 static PyObject *_wrap_DC_GetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
16540 PyObject *resultobj;
16541 wxDC *arg1 = (wxDC *) 0 ;
16542 int result;
16543 PyObject * obj0 = 0 ;
16544 char *kwnames[] = {
16545 (char *) "self", NULL
16546 };
16547
16548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackgroundMode",kwnames,&obj0)) goto fail;
16549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16550 if (SWIG_arg_fail(1)) SWIG_fail;
16551 {
16552 PyThreadState* __tstate = wxPyBeginAllowThreads();
16553 result = (int)((wxDC const *)arg1)->GetBackgroundMode();
16554
16555 wxPyEndAllowThreads(__tstate);
16556 if (PyErr_Occurred()) SWIG_fail;
16557 }
16558 {
16559 resultobj = SWIG_From_int((int)(result));
16560 }
16561 return resultobj;
16562 fail:
16563 return NULL;
16564 }
16565
16566
16567 static PyObject *_wrap_DC_GetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16568 PyObject *resultobj;
16569 wxDC *arg1 = (wxDC *) 0 ;
16570 wxBrush *result;
16571 PyObject * obj0 = 0 ;
16572 char *kwnames[] = {
16573 (char *) "self", NULL
16574 };
16575
16576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackground",kwnames,&obj0)) goto fail;
16577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16578 if (SWIG_arg_fail(1)) SWIG_fail;
16579 {
16580 PyThreadState* __tstate = wxPyBeginAllowThreads();
16581 {
16582 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBackground();
16583 result = (wxBrush *) &_result_ref;
16584 }
16585
16586 wxPyEndAllowThreads(__tstate);
16587 if (PyErr_Occurred()) SWIG_fail;
16588 }
16589 {
16590 wxBrush* resultptr = new wxBrush(*result);
16591 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
16592 }
16593 return resultobj;
16594 fail:
16595 return NULL;
16596 }
16597
16598
16599 static PyObject *_wrap_DC_GetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
16600 PyObject *resultobj;
16601 wxDC *arg1 = (wxDC *) 0 ;
16602 wxBrush *result;
16603 PyObject * obj0 = 0 ;
16604 char *kwnames[] = {
16605 (char *) "self", NULL
16606 };
16607
16608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBrush",kwnames,&obj0)) goto fail;
16609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16610 if (SWIG_arg_fail(1)) SWIG_fail;
16611 {
16612 PyThreadState* __tstate = wxPyBeginAllowThreads();
16613 {
16614 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBrush();
16615 result = (wxBrush *) &_result_ref;
16616 }
16617
16618 wxPyEndAllowThreads(__tstate);
16619 if (PyErr_Occurred()) SWIG_fail;
16620 }
16621 {
16622 wxBrush* resultptr = new wxBrush(*result);
16623 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
16624 }
16625 return resultobj;
16626 fail:
16627 return NULL;
16628 }
16629
16630
16631 static PyObject *_wrap_DC_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
16632 PyObject *resultobj;
16633 wxDC *arg1 = (wxDC *) 0 ;
16634 wxFont *result;
16635 PyObject * obj0 = 0 ;
16636 char *kwnames[] = {
16637 (char *) "self", NULL
16638 };
16639
16640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetFont",kwnames,&obj0)) goto fail;
16641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16642 if (SWIG_arg_fail(1)) SWIG_fail;
16643 {
16644 PyThreadState* __tstate = wxPyBeginAllowThreads();
16645 {
16646 wxFont const &_result_ref = ((wxDC const *)arg1)->GetFont();
16647 result = (wxFont *) &_result_ref;
16648 }
16649
16650 wxPyEndAllowThreads(__tstate);
16651 if (PyErr_Occurred()) SWIG_fail;
16652 }
16653 {
16654 wxFont* resultptr = new wxFont(*result);
16655 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxFont, 1);
16656 }
16657 return resultobj;
16658 fail:
16659 return NULL;
16660 }
16661
16662
16663 static PyObject *_wrap_DC_GetPen(PyObject *, PyObject *args, PyObject *kwargs) {
16664 PyObject *resultobj;
16665 wxDC *arg1 = (wxDC *) 0 ;
16666 wxPen *result;
16667 PyObject * obj0 = 0 ;
16668 char *kwnames[] = {
16669 (char *) "self", NULL
16670 };
16671
16672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPen",kwnames,&obj0)) goto fail;
16673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16674 if (SWIG_arg_fail(1)) SWIG_fail;
16675 {
16676 PyThreadState* __tstate = wxPyBeginAllowThreads();
16677 {
16678 wxPen const &_result_ref = ((wxDC const *)arg1)->GetPen();
16679 result = (wxPen *) &_result_ref;
16680 }
16681
16682 wxPyEndAllowThreads(__tstate);
16683 if (PyErr_Occurred()) SWIG_fail;
16684 }
16685 {
16686 wxPen* resultptr = new wxPen(*result);
16687 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxPen, 1);
16688 }
16689 return resultobj;
16690 fail:
16691 return NULL;
16692 }
16693
16694
16695 static PyObject *_wrap_DC_GetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16696 PyObject *resultobj;
16697 wxDC *arg1 = (wxDC *) 0 ;
16698 wxColour *result;
16699 PyObject * obj0 = 0 ;
16700 char *kwnames[] = {
16701 (char *) "self", NULL
16702 };
16703
16704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextBackground",kwnames,&obj0)) goto fail;
16705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16706 if (SWIG_arg_fail(1)) SWIG_fail;
16707 {
16708 PyThreadState* __tstate = wxPyBeginAllowThreads();
16709 {
16710 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextBackground();
16711 result = (wxColour *) &_result_ref;
16712 }
16713
16714 wxPyEndAllowThreads(__tstate);
16715 if (PyErr_Occurred()) SWIG_fail;
16716 }
16717 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
16718 return resultobj;
16719 fail:
16720 return NULL;
16721 }
16722
16723
16724 static PyObject *_wrap_DC_GetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
16725 PyObject *resultobj;
16726 wxDC *arg1 = (wxDC *) 0 ;
16727 wxColour *result;
16728 PyObject * obj0 = 0 ;
16729 char *kwnames[] = {
16730 (char *) "self", NULL
16731 };
16732
16733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextForeground",kwnames,&obj0)) goto fail;
16734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16735 if (SWIG_arg_fail(1)) SWIG_fail;
16736 {
16737 PyThreadState* __tstate = wxPyBeginAllowThreads();
16738 {
16739 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextForeground();
16740 result = (wxColour *) &_result_ref;
16741 }
16742
16743 wxPyEndAllowThreads(__tstate);
16744 if (PyErr_Occurred()) SWIG_fail;
16745 }
16746 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
16747 return resultobj;
16748 fail:
16749 return NULL;
16750 }
16751
16752
16753 static PyObject *_wrap_DC_SetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
16754 PyObject *resultobj;
16755 wxDC *arg1 = (wxDC *) 0 ;
16756 wxColour *arg2 = 0 ;
16757 wxColour temp2 ;
16758 PyObject * obj0 = 0 ;
16759 PyObject * obj1 = 0 ;
16760 char *kwnames[] = {
16761 (char *) "self",(char *) "colour", NULL
16762 };
16763
16764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextForeground",kwnames,&obj0,&obj1)) goto fail;
16765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16766 if (SWIG_arg_fail(1)) SWIG_fail;
16767 {
16768 arg2 = &temp2;
16769 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16770 }
16771 {
16772 PyThreadState* __tstate = wxPyBeginAllowThreads();
16773 (arg1)->SetTextForeground((wxColour const &)*arg2);
16774
16775 wxPyEndAllowThreads(__tstate);
16776 if (PyErr_Occurred()) SWIG_fail;
16777 }
16778 Py_INCREF(Py_None); resultobj = Py_None;
16779 return resultobj;
16780 fail:
16781 return NULL;
16782 }
16783
16784
16785 static PyObject *_wrap_DC_SetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16786 PyObject *resultobj;
16787 wxDC *arg1 = (wxDC *) 0 ;
16788 wxColour *arg2 = 0 ;
16789 wxColour temp2 ;
16790 PyObject * obj0 = 0 ;
16791 PyObject * obj1 = 0 ;
16792 char *kwnames[] = {
16793 (char *) "self",(char *) "colour", NULL
16794 };
16795
16796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextBackground",kwnames,&obj0,&obj1)) goto fail;
16797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16798 if (SWIG_arg_fail(1)) SWIG_fail;
16799 {
16800 arg2 = &temp2;
16801 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16802 }
16803 {
16804 PyThreadState* __tstate = wxPyBeginAllowThreads();
16805 (arg1)->SetTextBackground((wxColour const &)*arg2);
16806
16807 wxPyEndAllowThreads(__tstate);
16808 if (PyErr_Occurred()) SWIG_fail;
16809 }
16810 Py_INCREF(Py_None); resultobj = Py_None;
16811 return resultobj;
16812 fail:
16813 return NULL;
16814 }
16815
16816
16817 static PyObject *_wrap_DC_GetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16818 PyObject *resultobj;
16819 wxDC *arg1 = (wxDC *) 0 ;
16820 int result;
16821 PyObject * obj0 = 0 ;
16822 char *kwnames[] = {
16823 (char *) "self", NULL
16824 };
16825
16826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetMapMode",kwnames,&obj0)) goto fail;
16827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16828 if (SWIG_arg_fail(1)) SWIG_fail;
16829 {
16830 PyThreadState* __tstate = wxPyBeginAllowThreads();
16831 result = (int)((wxDC const *)arg1)->GetMapMode();
16832
16833 wxPyEndAllowThreads(__tstate);
16834 if (PyErr_Occurred()) SWIG_fail;
16835 }
16836 {
16837 resultobj = SWIG_From_int((int)(result));
16838 }
16839 return resultobj;
16840 fail:
16841 return NULL;
16842 }
16843
16844
16845 static PyObject *_wrap_DC_SetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16846 PyObject *resultobj;
16847 wxDC *arg1 = (wxDC *) 0 ;
16848 int arg2 ;
16849 PyObject * obj0 = 0 ;
16850 PyObject * obj1 = 0 ;
16851 char *kwnames[] = {
16852 (char *) "self",(char *) "mode", NULL
16853 };
16854
16855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetMapMode",kwnames,&obj0,&obj1)) goto fail;
16856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16857 if (SWIG_arg_fail(1)) SWIG_fail;
16858 {
16859 arg2 = (int)(SWIG_As_int(obj1));
16860 if (SWIG_arg_fail(2)) SWIG_fail;
16861 }
16862 {
16863 PyThreadState* __tstate = wxPyBeginAllowThreads();
16864 (arg1)->SetMapMode(arg2);
16865
16866 wxPyEndAllowThreads(__tstate);
16867 if (PyErr_Occurred()) SWIG_fail;
16868 }
16869 Py_INCREF(Py_None); resultobj = Py_None;
16870 return resultobj;
16871 fail:
16872 return NULL;
16873 }
16874
16875
16876 static PyObject *_wrap_DC_GetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16877 PyObject *resultobj;
16878 wxDC *arg1 = (wxDC *) 0 ;
16879 double *arg2 = (double *) 0 ;
16880 double *arg3 = (double *) 0 ;
16881 double temp2 ;
16882 int res2 = 0 ;
16883 double temp3 ;
16884 int res3 = 0 ;
16885 PyObject * obj0 = 0 ;
16886 char *kwnames[] = {
16887 (char *) "self", NULL
16888 };
16889
16890 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16891 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetUserScale",kwnames,&obj0)) goto fail;
16893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16894 if (SWIG_arg_fail(1)) SWIG_fail;
16895 {
16896 PyThreadState* __tstate = wxPyBeginAllowThreads();
16897 ((wxDC const *)arg1)->GetUserScale(arg2,arg3);
16898
16899 wxPyEndAllowThreads(__tstate);
16900 if (PyErr_Occurred()) SWIG_fail;
16901 }
16902 Py_INCREF(Py_None); resultobj = Py_None;
16903 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16904 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16905 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16906 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16907 return resultobj;
16908 fail:
16909 return NULL;
16910 }
16911
16912
16913 static PyObject *_wrap_DC_SetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16914 PyObject *resultobj;
16915 wxDC *arg1 = (wxDC *) 0 ;
16916 double arg2 ;
16917 double arg3 ;
16918 PyObject * obj0 = 0 ;
16919 PyObject * obj1 = 0 ;
16920 PyObject * obj2 = 0 ;
16921 char *kwnames[] = {
16922 (char *) "self",(char *) "x",(char *) "y", NULL
16923 };
16924
16925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetUserScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16927 if (SWIG_arg_fail(1)) SWIG_fail;
16928 {
16929 arg2 = (double)(SWIG_As_double(obj1));
16930 if (SWIG_arg_fail(2)) SWIG_fail;
16931 }
16932 {
16933 arg3 = (double)(SWIG_As_double(obj2));
16934 if (SWIG_arg_fail(3)) SWIG_fail;
16935 }
16936 {
16937 PyThreadState* __tstate = wxPyBeginAllowThreads();
16938 (arg1)->SetUserScale(arg2,arg3);
16939
16940 wxPyEndAllowThreads(__tstate);
16941 if (PyErr_Occurred()) SWIG_fail;
16942 }
16943 Py_INCREF(Py_None); resultobj = Py_None;
16944 return resultobj;
16945 fail:
16946 return NULL;
16947 }
16948
16949
16950 static PyObject *_wrap_DC_GetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16951 PyObject *resultobj;
16952 wxDC *arg1 = (wxDC *) 0 ;
16953 double *arg2 = (double *) 0 ;
16954 double *arg3 = (double *) 0 ;
16955 double temp2 ;
16956 int res2 = 0 ;
16957 double temp3 ;
16958 int res3 = 0 ;
16959 PyObject * obj0 = 0 ;
16960 char *kwnames[] = {
16961 (char *) "self", NULL
16962 };
16963
16964 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16965 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalScale",kwnames,&obj0)) goto fail;
16967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16968 if (SWIG_arg_fail(1)) SWIG_fail;
16969 {
16970 PyThreadState* __tstate = wxPyBeginAllowThreads();
16971 (arg1)->GetLogicalScale(arg2,arg3);
16972
16973 wxPyEndAllowThreads(__tstate);
16974 if (PyErr_Occurred()) SWIG_fail;
16975 }
16976 Py_INCREF(Py_None); resultobj = Py_None;
16977 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16978 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16979 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16980 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16981 return resultobj;
16982 fail:
16983 return NULL;
16984 }
16985
16986
16987 static PyObject *_wrap_DC_SetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16988 PyObject *resultobj;
16989 wxDC *arg1 = (wxDC *) 0 ;
16990 double arg2 ;
16991 double arg3 ;
16992 PyObject * obj0 = 0 ;
16993 PyObject * obj1 = 0 ;
16994 PyObject * obj2 = 0 ;
16995 char *kwnames[] = {
16996 (char *) "self",(char *) "x",(char *) "y", NULL
16997 };
16998
16999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
17000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17001 if (SWIG_arg_fail(1)) SWIG_fail;
17002 {
17003 arg2 = (double)(SWIG_As_double(obj1));
17004 if (SWIG_arg_fail(2)) SWIG_fail;
17005 }
17006 {
17007 arg3 = (double)(SWIG_As_double(obj2));
17008 if (SWIG_arg_fail(3)) SWIG_fail;
17009 }
17010 {
17011 PyThreadState* __tstate = wxPyBeginAllowThreads();
17012 (arg1)->SetLogicalScale(arg2,arg3);
17013
17014 wxPyEndAllowThreads(__tstate);
17015 if (PyErr_Occurred()) SWIG_fail;
17016 }
17017 Py_INCREF(Py_None); resultobj = Py_None;
17018 return resultobj;
17019 fail:
17020 return NULL;
17021 }
17022
17023
17024 static PyObject *_wrap_DC_GetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
17025 PyObject *resultobj;
17026 wxDC *arg1 = (wxDC *) 0 ;
17027 wxPoint result;
17028 PyObject * obj0 = 0 ;
17029 char *kwnames[] = {
17030 (char *) "self", NULL
17031 };
17032
17033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOrigin",kwnames,&obj0)) goto fail;
17034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17035 if (SWIG_arg_fail(1)) SWIG_fail;
17036 {
17037 PyThreadState* __tstate = wxPyBeginAllowThreads();
17038 result = ((wxDC const *)arg1)->GetLogicalOrigin();
17039
17040 wxPyEndAllowThreads(__tstate);
17041 if (PyErr_Occurred()) SWIG_fail;
17042 }
17043 {
17044 wxPoint * resultptr;
17045 resultptr = new wxPoint((wxPoint &)(result));
17046 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17047 }
17048 return resultobj;
17049 fail:
17050 return NULL;
17051 }
17052
17053
17054 static PyObject *_wrap_DC_GetLogicalOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17055 PyObject *resultobj;
17056 wxDC *arg1 = (wxDC *) 0 ;
17057 int *arg2 = (int *) 0 ;
17058 int *arg3 = (int *) 0 ;
17059 int temp2 ;
17060 int res2 = 0 ;
17061 int temp3 ;
17062 int res3 = 0 ;
17063 PyObject * obj0 = 0 ;
17064 char *kwnames[] = {
17065 (char *) "self", NULL
17066 };
17067
17068 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17069 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOriginTuple",kwnames,&obj0)) goto fail;
17071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17072 if (SWIG_arg_fail(1)) SWIG_fail;
17073 {
17074 PyThreadState* __tstate = wxPyBeginAllowThreads();
17075 ((wxDC const *)arg1)->GetLogicalOrigin(arg2,arg3);
17076
17077 wxPyEndAllowThreads(__tstate);
17078 if (PyErr_Occurred()) SWIG_fail;
17079 }
17080 Py_INCREF(Py_None); resultobj = Py_None;
17081 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17082 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
17083 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17084 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
17085 return resultobj;
17086 fail:
17087 return NULL;
17088 }
17089
17090
17091 static PyObject *_wrap_DC_SetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
17092 PyObject *resultobj;
17093 wxDC *arg1 = (wxDC *) 0 ;
17094 int arg2 ;
17095 int arg3 ;
17096 PyObject * obj0 = 0 ;
17097 PyObject * obj1 = 0 ;
17098 PyObject * obj2 = 0 ;
17099 char *kwnames[] = {
17100 (char *) "self",(char *) "x",(char *) "y", NULL
17101 };
17102
17103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
17104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17105 if (SWIG_arg_fail(1)) SWIG_fail;
17106 {
17107 arg2 = (int)(SWIG_As_int(obj1));
17108 if (SWIG_arg_fail(2)) SWIG_fail;
17109 }
17110 {
17111 arg3 = (int)(SWIG_As_int(obj2));
17112 if (SWIG_arg_fail(3)) SWIG_fail;
17113 }
17114 {
17115 PyThreadState* __tstate = wxPyBeginAllowThreads();
17116 (arg1)->SetLogicalOrigin(arg2,arg3);
17117
17118 wxPyEndAllowThreads(__tstate);
17119 if (PyErr_Occurred()) SWIG_fail;
17120 }
17121 Py_INCREF(Py_None); resultobj = Py_None;
17122 return resultobj;
17123 fail:
17124 return NULL;
17125 }
17126
17127
17128 static PyObject *_wrap_DC_SetLogicalOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
17129 PyObject *resultobj;
17130 wxDC *arg1 = (wxDC *) 0 ;
17131 wxPoint *arg2 = 0 ;
17132 wxPoint temp2 ;
17133 PyObject * obj0 = 0 ;
17134 PyObject * obj1 = 0 ;
17135 char *kwnames[] = {
17136 (char *) "self",(char *) "point", NULL
17137 };
17138
17139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalOriginPoint",kwnames,&obj0,&obj1)) goto fail;
17140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17141 if (SWIG_arg_fail(1)) SWIG_fail;
17142 {
17143 arg2 = &temp2;
17144 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
17145 }
17146 {
17147 PyThreadState* __tstate = wxPyBeginAllowThreads();
17148 wxDC_SetLogicalOriginPoint(arg1,(wxPoint const &)*arg2);
17149
17150 wxPyEndAllowThreads(__tstate);
17151 if (PyErr_Occurred()) SWIG_fail;
17152 }
17153 Py_INCREF(Py_None); resultobj = Py_None;
17154 return resultobj;
17155 fail:
17156 return NULL;
17157 }
17158
17159
17160 static PyObject *_wrap_DC_GetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
17161 PyObject *resultobj;
17162 wxDC *arg1 = (wxDC *) 0 ;
17163 wxPoint result;
17164 PyObject * obj0 = 0 ;
17165 char *kwnames[] = {
17166 (char *) "self", NULL
17167 };
17168
17169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOrigin",kwnames,&obj0)) goto fail;
17170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17171 if (SWIG_arg_fail(1)) SWIG_fail;
17172 {
17173 PyThreadState* __tstate = wxPyBeginAllowThreads();
17174 result = ((wxDC const *)arg1)->GetDeviceOrigin();
17175
17176 wxPyEndAllowThreads(__tstate);
17177 if (PyErr_Occurred()) SWIG_fail;
17178 }
17179 {
17180 wxPoint * resultptr;
17181 resultptr = new wxPoint((wxPoint &)(result));
17182 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17183 }
17184 return resultobj;
17185 fail:
17186 return NULL;
17187 }
17188
17189
17190 static PyObject *_wrap_DC_GetDeviceOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17191 PyObject *resultobj;
17192 wxDC *arg1 = (wxDC *) 0 ;
17193 int *arg2 = (int *) 0 ;
17194 int *arg3 = (int *) 0 ;
17195 int temp2 ;
17196 int res2 = 0 ;
17197 int temp3 ;
17198 int res3 = 0 ;
17199 PyObject * obj0 = 0 ;
17200 char *kwnames[] = {
17201 (char *) "self", NULL
17202 };
17203
17204 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17205 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOriginTuple",kwnames,&obj0)) goto fail;
17207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17208 if (SWIG_arg_fail(1)) SWIG_fail;
17209 {
17210 PyThreadState* __tstate = wxPyBeginAllowThreads();
17211 ((wxDC const *)arg1)->GetDeviceOrigin(arg2,arg3);
17212
17213 wxPyEndAllowThreads(__tstate);
17214 if (PyErr_Occurred()) SWIG_fail;
17215 }
17216 Py_INCREF(Py_None); resultobj = Py_None;
17217 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17218 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
17219 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17220 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
17221 return resultobj;
17222 fail:
17223 return NULL;
17224 }
17225
17226
17227 static PyObject *_wrap_DC_SetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
17228 PyObject *resultobj;
17229 wxDC *arg1 = (wxDC *) 0 ;
17230 int arg2 ;
17231 int arg3 ;
17232 PyObject * obj0 = 0 ;
17233 PyObject * obj1 = 0 ;
17234 PyObject * obj2 = 0 ;
17235 char *kwnames[] = {
17236 (char *) "self",(char *) "x",(char *) "y", NULL
17237 };
17238
17239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetDeviceOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
17240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17241 if (SWIG_arg_fail(1)) SWIG_fail;
17242 {
17243 arg2 = (int)(SWIG_As_int(obj1));
17244 if (SWIG_arg_fail(2)) SWIG_fail;
17245 }
17246 {
17247 arg3 = (int)(SWIG_As_int(obj2));
17248 if (SWIG_arg_fail(3)) SWIG_fail;
17249 }
17250 {
17251 PyThreadState* __tstate = wxPyBeginAllowThreads();
17252 (arg1)->SetDeviceOrigin(arg2,arg3);
17253
17254 wxPyEndAllowThreads(__tstate);
17255 if (PyErr_Occurred()) SWIG_fail;
17256 }
17257 Py_INCREF(Py_None); resultobj = Py_None;
17258 return resultobj;
17259 fail:
17260 return NULL;
17261 }
17262
17263
17264 static PyObject *_wrap_DC_SetDeviceOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
17265 PyObject *resultobj;
17266 wxDC *arg1 = (wxDC *) 0 ;
17267 wxPoint *arg2 = 0 ;
17268 wxPoint temp2 ;
17269 PyObject * obj0 = 0 ;
17270 PyObject * obj1 = 0 ;
17271 char *kwnames[] = {
17272 (char *) "self",(char *) "point", NULL
17273 };
17274
17275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetDeviceOriginPoint",kwnames,&obj0,&obj1)) goto fail;
17276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17277 if (SWIG_arg_fail(1)) SWIG_fail;
17278 {
17279 arg2 = &temp2;
17280 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
17281 }
17282 {
17283 PyThreadState* __tstate = wxPyBeginAllowThreads();
17284 wxDC_SetDeviceOriginPoint(arg1,(wxPoint const &)*arg2);
17285
17286 wxPyEndAllowThreads(__tstate);
17287 if (PyErr_Occurred()) SWIG_fail;
17288 }
17289 Py_INCREF(Py_None); resultobj = Py_None;
17290 return resultobj;
17291 fail:
17292 return NULL;
17293 }
17294
17295
17296 static PyObject *_wrap_DC_SetAxisOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
17297 PyObject *resultobj;
17298 wxDC *arg1 = (wxDC *) 0 ;
17299 bool arg2 ;
17300 bool arg3 ;
17301 PyObject * obj0 = 0 ;
17302 PyObject * obj1 = 0 ;
17303 PyObject * obj2 = 0 ;
17304 char *kwnames[] = {
17305 (char *) "self",(char *) "xLeftRight",(char *) "yBottomUp", NULL
17306 };
17307
17308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetAxisOrientation",kwnames,&obj0,&obj1,&obj2)) goto fail;
17309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17310 if (SWIG_arg_fail(1)) SWIG_fail;
17311 {
17312 arg2 = (bool)(SWIG_As_bool(obj1));
17313 if (SWIG_arg_fail(2)) SWIG_fail;
17314 }
17315 {
17316 arg3 = (bool)(SWIG_As_bool(obj2));
17317 if (SWIG_arg_fail(3)) SWIG_fail;
17318 }
17319 {
17320 PyThreadState* __tstate = wxPyBeginAllowThreads();
17321 (arg1)->SetAxisOrientation(arg2,arg3);
17322
17323 wxPyEndAllowThreads(__tstate);
17324 if (PyErr_Occurred()) SWIG_fail;
17325 }
17326 Py_INCREF(Py_None); resultobj = Py_None;
17327 return resultobj;
17328 fail:
17329 return NULL;
17330 }
17331
17332
17333 static PyObject *_wrap_DC_GetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
17334 PyObject *resultobj;
17335 wxDC *arg1 = (wxDC *) 0 ;
17336 int result;
17337 PyObject * obj0 = 0 ;
17338 char *kwnames[] = {
17339 (char *) "self", NULL
17340 };
17341
17342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalFunction",kwnames,&obj0)) goto fail;
17343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17344 if (SWIG_arg_fail(1)) SWIG_fail;
17345 {
17346 PyThreadState* __tstate = wxPyBeginAllowThreads();
17347 result = (int)((wxDC const *)arg1)->GetLogicalFunction();
17348
17349 wxPyEndAllowThreads(__tstate);
17350 if (PyErr_Occurred()) SWIG_fail;
17351 }
17352 {
17353 resultobj = SWIG_From_int((int)(result));
17354 }
17355 return resultobj;
17356 fail:
17357 return NULL;
17358 }
17359
17360
17361 static PyObject *_wrap_DC_SetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
17362 PyObject *resultobj;
17363 wxDC *arg1 = (wxDC *) 0 ;
17364 int arg2 ;
17365 PyObject * obj0 = 0 ;
17366 PyObject * obj1 = 0 ;
17367 char *kwnames[] = {
17368 (char *) "self",(char *) "function", NULL
17369 };
17370
17371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalFunction",kwnames,&obj0,&obj1)) goto fail;
17372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17373 if (SWIG_arg_fail(1)) SWIG_fail;
17374 {
17375 arg2 = (int)(SWIG_As_int(obj1));
17376 if (SWIG_arg_fail(2)) SWIG_fail;
17377 }
17378 {
17379 PyThreadState* __tstate = wxPyBeginAllowThreads();
17380 (arg1)->SetLogicalFunction(arg2);
17381
17382 wxPyEndAllowThreads(__tstate);
17383 if (PyErr_Occurred()) SWIG_fail;
17384 }
17385 Py_INCREF(Py_None); resultobj = Py_None;
17386 return resultobj;
17387 fail:
17388 return NULL;
17389 }
17390
17391
17392 static PyObject *_wrap_DC_ComputeScaleAndOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
17393 PyObject *resultobj;
17394 wxDC *arg1 = (wxDC *) 0 ;
17395 PyObject * obj0 = 0 ;
17396 char *kwnames[] = {
17397 (char *) "self", NULL
17398 };
17399
17400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ComputeScaleAndOrigin",kwnames,&obj0)) goto fail;
17401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17402 if (SWIG_arg_fail(1)) SWIG_fail;
17403 {
17404 PyThreadState* __tstate = wxPyBeginAllowThreads();
17405 (arg1)->ComputeScaleAndOrigin();
17406
17407 wxPyEndAllowThreads(__tstate);
17408 if (PyErr_Occurred()) SWIG_fail;
17409 }
17410 Py_INCREF(Py_None); resultobj = Py_None;
17411 return resultobj;
17412 fail:
17413 return NULL;
17414 }
17415
17416
17417 static PyObject *_wrap_DC_CalcBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
17418 PyObject *resultobj;
17419 wxDC *arg1 = (wxDC *) 0 ;
17420 int arg2 ;
17421 int arg3 ;
17422 PyObject * obj0 = 0 ;
17423 PyObject * obj1 = 0 ;
17424 PyObject * obj2 = 0 ;
17425 char *kwnames[] = {
17426 (char *) "self",(char *) "x",(char *) "y", NULL
17427 };
17428
17429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CalcBoundingBox",kwnames,&obj0,&obj1,&obj2)) goto fail;
17430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17431 if (SWIG_arg_fail(1)) SWIG_fail;
17432 {
17433 arg2 = (int)(SWIG_As_int(obj1));
17434 if (SWIG_arg_fail(2)) SWIG_fail;
17435 }
17436 {
17437 arg3 = (int)(SWIG_As_int(obj2));
17438 if (SWIG_arg_fail(3)) SWIG_fail;
17439 }
17440 {
17441 PyThreadState* __tstate = wxPyBeginAllowThreads();
17442 (arg1)->CalcBoundingBox(arg2,arg3);
17443
17444 wxPyEndAllowThreads(__tstate);
17445 if (PyErr_Occurred()) SWIG_fail;
17446 }
17447 Py_INCREF(Py_None); resultobj = Py_None;
17448 return resultobj;
17449 fail:
17450 return NULL;
17451 }
17452
17453
17454 static PyObject *_wrap_DC_CalcBoundingBoxPoint(PyObject *, PyObject *args, PyObject *kwargs) {
17455 PyObject *resultobj;
17456 wxDC *arg1 = (wxDC *) 0 ;
17457 wxPoint *arg2 = 0 ;
17458 wxPoint temp2 ;
17459 PyObject * obj0 = 0 ;
17460 PyObject * obj1 = 0 ;
17461 char *kwnames[] = {
17462 (char *) "self",(char *) "point", NULL
17463 };
17464
17465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CalcBoundingBoxPoint",kwnames,&obj0,&obj1)) goto fail;
17466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17467 if (SWIG_arg_fail(1)) SWIG_fail;
17468 {
17469 arg2 = &temp2;
17470 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
17471 }
17472 {
17473 PyThreadState* __tstate = wxPyBeginAllowThreads();
17474 wxDC_CalcBoundingBoxPoint(arg1,(wxPoint const &)*arg2);
17475
17476 wxPyEndAllowThreads(__tstate);
17477 if (PyErr_Occurred()) SWIG_fail;
17478 }
17479 Py_INCREF(Py_None); resultobj = Py_None;
17480 return resultobj;
17481 fail:
17482 return NULL;
17483 }
17484
17485
17486 static PyObject *_wrap_DC_ResetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
17487 PyObject *resultobj;
17488 wxDC *arg1 = (wxDC *) 0 ;
17489 PyObject * obj0 = 0 ;
17490 char *kwnames[] = {
17491 (char *) "self", NULL
17492 };
17493
17494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ResetBoundingBox",kwnames,&obj0)) goto fail;
17495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17496 if (SWIG_arg_fail(1)) SWIG_fail;
17497 {
17498 PyThreadState* __tstate = wxPyBeginAllowThreads();
17499 (arg1)->ResetBoundingBox();
17500
17501 wxPyEndAllowThreads(__tstate);
17502 if (PyErr_Occurred()) SWIG_fail;
17503 }
17504 Py_INCREF(Py_None); resultobj = Py_None;
17505 return resultobj;
17506 fail:
17507 return NULL;
17508 }
17509
17510
17511 static PyObject *_wrap_DC_MinX(PyObject *, PyObject *args, PyObject *kwargs) {
17512 PyObject *resultobj;
17513 wxDC *arg1 = (wxDC *) 0 ;
17514 int result;
17515 PyObject * obj0 = 0 ;
17516 char *kwnames[] = {
17517 (char *) "self", NULL
17518 };
17519
17520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinX",kwnames,&obj0)) goto fail;
17521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17522 if (SWIG_arg_fail(1)) SWIG_fail;
17523 {
17524 PyThreadState* __tstate = wxPyBeginAllowThreads();
17525 result = (int)((wxDC const *)arg1)->MinX();
17526
17527 wxPyEndAllowThreads(__tstate);
17528 if (PyErr_Occurred()) SWIG_fail;
17529 }
17530 {
17531 resultobj = SWIG_From_int((int)(result));
17532 }
17533 return resultobj;
17534 fail:
17535 return NULL;
17536 }
17537
17538
17539 static PyObject *_wrap_DC_MaxX(PyObject *, PyObject *args, PyObject *kwargs) {
17540 PyObject *resultobj;
17541 wxDC *arg1 = (wxDC *) 0 ;
17542 int result;
17543 PyObject * obj0 = 0 ;
17544 char *kwnames[] = {
17545 (char *) "self", NULL
17546 };
17547
17548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxX",kwnames,&obj0)) goto fail;
17549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17550 if (SWIG_arg_fail(1)) SWIG_fail;
17551 {
17552 PyThreadState* __tstate = wxPyBeginAllowThreads();
17553 result = (int)((wxDC const *)arg1)->MaxX();
17554
17555 wxPyEndAllowThreads(__tstate);
17556 if (PyErr_Occurred()) SWIG_fail;
17557 }
17558 {
17559 resultobj = SWIG_From_int((int)(result));
17560 }
17561 return resultobj;
17562 fail:
17563 return NULL;
17564 }
17565
17566
17567 static PyObject *_wrap_DC_MinY(PyObject *, PyObject *args, PyObject *kwargs) {
17568 PyObject *resultobj;
17569 wxDC *arg1 = (wxDC *) 0 ;
17570 int result;
17571 PyObject * obj0 = 0 ;
17572 char *kwnames[] = {
17573 (char *) "self", NULL
17574 };
17575
17576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinY",kwnames,&obj0)) goto fail;
17577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17578 if (SWIG_arg_fail(1)) SWIG_fail;
17579 {
17580 PyThreadState* __tstate = wxPyBeginAllowThreads();
17581 result = (int)((wxDC const *)arg1)->MinY();
17582
17583 wxPyEndAllowThreads(__tstate);
17584 if (PyErr_Occurred()) SWIG_fail;
17585 }
17586 {
17587 resultobj = SWIG_From_int((int)(result));
17588 }
17589 return resultobj;
17590 fail:
17591 return NULL;
17592 }
17593
17594
17595 static PyObject *_wrap_DC_MaxY(PyObject *, PyObject *args, PyObject *kwargs) {
17596 PyObject *resultobj;
17597 wxDC *arg1 = (wxDC *) 0 ;
17598 int result;
17599 PyObject * obj0 = 0 ;
17600 char *kwnames[] = {
17601 (char *) "self", NULL
17602 };
17603
17604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxY",kwnames,&obj0)) goto fail;
17605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17606 if (SWIG_arg_fail(1)) SWIG_fail;
17607 {
17608 PyThreadState* __tstate = wxPyBeginAllowThreads();
17609 result = (int)((wxDC const *)arg1)->MaxY();
17610
17611 wxPyEndAllowThreads(__tstate);
17612 if (PyErr_Occurred()) SWIG_fail;
17613 }
17614 {
17615 resultobj = SWIG_From_int((int)(result));
17616 }
17617 return resultobj;
17618 fail:
17619 return NULL;
17620 }
17621
17622
17623 static PyObject *_wrap_DC_GetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
17624 PyObject *resultobj;
17625 wxDC *arg1 = (wxDC *) 0 ;
17626 int *arg2 = (int *) 0 ;
17627 int *arg3 = (int *) 0 ;
17628 int *arg4 = (int *) 0 ;
17629 int *arg5 = (int *) 0 ;
17630 int temp2 ;
17631 int res2 = 0 ;
17632 int temp3 ;
17633 int res3 = 0 ;
17634 int temp4 ;
17635 int res4 = 0 ;
17636 int temp5 ;
17637 int res5 = 0 ;
17638 PyObject * obj0 = 0 ;
17639 char *kwnames[] = {
17640 (char *) "self", NULL
17641 };
17642
17643 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17644 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17645 arg4 = &temp4; res4 = SWIG_NEWOBJ;
17646 arg5 = &temp5; res5 = SWIG_NEWOBJ;
17647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBoundingBox",kwnames,&obj0)) goto fail;
17648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17649 if (SWIG_arg_fail(1)) SWIG_fail;
17650 {
17651 PyThreadState* __tstate = wxPyBeginAllowThreads();
17652 wxDC_GetBoundingBox(arg1,arg2,arg3,arg4,arg5);
17653
17654 wxPyEndAllowThreads(__tstate);
17655 if (PyErr_Occurred()) SWIG_fail;
17656 }
17657 Py_INCREF(Py_None); resultobj = Py_None;
17658 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17659 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
17660 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17661 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
17662 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
17663 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
17664 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
17665 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
17666 return resultobj;
17667 fail:
17668 return NULL;
17669 }
17670
17671
17672 static PyObject *_wrap_DC_GetHDC(PyObject *, PyObject *args, PyObject *kwargs) {
17673 PyObject *resultobj;
17674 wxDC *arg1 = (wxDC *) 0 ;
17675 long result;
17676 PyObject * obj0 = 0 ;
17677 char *kwnames[] = {
17678 (char *) "self", NULL
17679 };
17680
17681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetHDC",kwnames,&obj0)) goto fail;
17682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17683 if (SWIG_arg_fail(1)) SWIG_fail;
17684 {
17685 PyThreadState* __tstate = wxPyBeginAllowThreads();
17686 result = (long)(arg1)->GetHDC();
17687
17688 wxPyEndAllowThreads(__tstate);
17689 if (PyErr_Occurred()) SWIG_fail;
17690 }
17691 {
17692 resultobj = SWIG_From_long((long)(result));
17693 }
17694 return resultobj;
17695 fail:
17696 return NULL;
17697 }
17698
17699
17700 static PyObject *_wrap_DC__DrawPointList(PyObject *, PyObject *args, PyObject *kwargs) {
17701 PyObject *resultobj;
17702 wxDC *arg1 = (wxDC *) 0 ;
17703 PyObject *arg2 = (PyObject *) 0 ;
17704 PyObject *arg3 = (PyObject *) 0 ;
17705 PyObject *arg4 = (PyObject *) 0 ;
17706 PyObject *result;
17707 PyObject * obj0 = 0 ;
17708 PyObject * obj1 = 0 ;
17709 PyObject * obj2 = 0 ;
17710 PyObject * obj3 = 0 ;
17711 char *kwnames[] = {
17712 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17713 };
17714
17715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPointList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17717 if (SWIG_arg_fail(1)) SWIG_fail;
17718 arg2 = obj1;
17719 arg3 = obj2;
17720 arg4 = obj3;
17721 {
17722 PyThreadState* __tstate = wxPyBeginAllowThreads();
17723 result = (PyObject *)wxDC__DrawPointList(arg1,arg2,arg3,arg4);
17724
17725 wxPyEndAllowThreads(__tstate);
17726 if (PyErr_Occurred()) SWIG_fail;
17727 }
17728 resultobj = result;
17729 return resultobj;
17730 fail:
17731 return NULL;
17732 }
17733
17734
17735 static PyObject *_wrap_DC__DrawLineList(PyObject *, PyObject *args, PyObject *kwargs) {
17736 PyObject *resultobj;
17737 wxDC *arg1 = (wxDC *) 0 ;
17738 PyObject *arg2 = (PyObject *) 0 ;
17739 PyObject *arg3 = (PyObject *) 0 ;
17740 PyObject *arg4 = (PyObject *) 0 ;
17741 PyObject *result;
17742 PyObject * obj0 = 0 ;
17743 PyObject * obj1 = 0 ;
17744 PyObject * obj2 = 0 ;
17745 PyObject * obj3 = 0 ;
17746 char *kwnames[] = {
17747 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17748 };
17749
17750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawLineList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17752 if (SWIG_arg_fail(1)) SWIG_fail;
17753 arg2 = obj1;
17754 arg3 = obj2;
17755 arg4 = obj3;
17756 {
17757 PyThreadState* __tstate = wxPyBeginAllowThreads();
17758 result = (PyObject *)wxDC__DrawLineList(arg1,arg2,arg3,arg4);
17759
17760 wxPyEndAllowThreads(__tstate);
17761 if (PyErr_Occurred()) SWIG_fail;
17762 }
17763 resultobj = result;
17764 return resultobj;
17765 fail:
17766 return NULL;
17767 }
17768
17769
17770 static PyObject *_wrap_DC__DrawRectangleList(PyObject *, PyObject *args, PyObject *kwargs) {
17771 PyObject *resultobj;
17772 wxDC *arg1 = (wxDC *) 0 ;
17773 PyObject *arg2 = (PyObject *) 0 ;
17774 PyObject *arg3 = (PyObject *) 0 ;
17775 PyObject *arg4 = (PyObject *) 0 ;
17776 PyObject *result;
17777 PyObject * obj0 = 0 ;
17778 PyObject * obj1 = 0 ;
17779 PyObject * obj2 = 0 ;
17780 PyObject * obj3 = 0 ;
17781 char *kwnames[] = {
17782 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17783 };
17784
17785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawRectangleList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17787 if (SWIG_arg_fail(1)) SWIG_fail;
17788 arg2 = obj1;
17789 arg3 = obj2;
17790 arg4 = obj3;
17791 {
17792 PyThreadState* __tstate = wxPyBeginAllowThreads();
17793 result = (PyObject *)wxDC__DrawRectangleList(arg1,arg2,arg3,arg4);
17794
17795 wxPyEndAllowThreads(__tstate);
17796 if (PyErr_Occurred()) SWIG_fail;
17797 }
17798 resultobj = result;
17799 return resultobj;
17800 fail:
17801 return NULL;
17802 }
17803
17804
17805 static PyObject *_wrap_DC__DrawEllipseList(PyObject *, PyObject *args, PyObject *kwargs) {
17806 PyObject *resultobj;
17807 wxDC *arg1 = (wxDC *) 0 ;
17808 PyObject *arg2 = (PyObject *) 0 ;
17809 PyObject *arg3 = (PyObject *) 0 ;
17810 PyObject *arg4 = (PyObject *) 0 ;
17811 PyObject *result;
17812 PyObject * obj0 = 0 ;
17813 PyObject * obj1 = 0 ;
17814 PyObject * obj2 = 0 ;
17815 PyObject * obj3 = 0 ;
17816 char *kwnames[] = {
17817 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17818 };
17819
17820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawEllipseList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17822 if (SWIG_arg_fail(1)) SWIG_fail;
17823 arg2 = obj1;
17824 arg3 = obj2;
17825 arg4 = obj3;
17826 {
17827 PyThreadState* __tstate = wxPyBeginAllowThreads();
17828 result = (PyObject *)wxDC__DrawEllipseList(arg1,arg2,arg3,arg4);
17829
17830 wxPyEndAllowThreads(__tstate);
17831 if (PyErr_Occurred()) SWIG_fail;
17832 }
17833 resultobj = result;
17834 return resultobj;
17835 fail:
17836 return NULL;
17837 }
17838
17839
17840 static PyObject *_wrap_DC__DrawPolygonList(PyObject *, PyObject *args, PyObject *kwargs) {
17841 PyObject *resultobj;
17842 wxDC *arg1 = (wxDC *) 0 ;
17843 PyObject *arg2 = (PyObject *) 0 ;
17844 PyObject *arg3 = (PyObject *) 0 ;
17845 PyObject *arg4 = (PyObject *) 0 ;
17846 PyObject *result;
17847 PyObject * obj0 = 0 ;
17848 PyObject * obj1 = 0 ;
17849 PyObject * obj2 = 0 ;
17850 PyObject * obj3 = 0 ;
17851 char *kwnames[] = {
17852 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17853 };
17854
17855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPolygonList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17857 if (SWIG_arg_fail(1)) SWIG_fail;
17858 arg2 = obj1;
17859 arg3 = obj2;
17860 arg4 = obj3;
17861 {
17862 PyThreadState* __tstate = wxPyBeginAllowThreads();
17863 result = (PyObject *)wxDC__DrawPolygonList(arg1,arg2,arg3,arg4);
17864
17865 wxPyEndAllowThreads(__tstate);
17866 if (PyErr_Occurred()) SWIG_fail;
17867 }
17868 resultobj = result;
17869 return resultobj;
17870 fail:
17871 return NULL;
17872 }
17873
17874
17875 static PyObject *_wrap_DC__DrawTextList(PyObject *, PyObject *args, PyObject *kwargs) {
17876 PyObject *resultobj;
17877 wxDC *arg1 = (wxDC *) 0 ;
17878 PyObject *arg2 = (PyObject *) 0 ;
17879 PyObject *arg3 = (PyObject *) 0 ;
17880 PyObject *arg4 = (PyObject *) 0 ;
17881 PyObject *arg5 = (PyObject *) 0 ;
17882 PyObject *result;
17883 PyObject * obj0 = 0 ;
17884 PyObject * obj1 = 0 ;
17885 PyObject * obj2 = 0 ;
17886 PyObject * obj3 = 0 ;
17887 PyObject * obj4 = 0 ;
17888 char *kwnames[] = {
17889 (char *) "self",(char *) "textList",(char *) "pyPoints",(char *) "foregroundList",(char *) "backgroundList", NULL
17890 };
17891
17892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC__DrawTextList",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
17893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17894 if (SWIG_arg_fail(1)) SWIG_fail;
17895 arg2 = obj1;
17896 arg3 = obj2;
17897 arg4 = obj3;
17898 arg5 = obj4;
17899 {
17900 PyThreadState* __tstate = wxPyBeginAllowThreads();
17901 result = (PyObject *)wxDC__DrawTextList(arg1,arg2,arg3,arg4,arg5);
17902
17903 wxPyEndAllowThreads(__tstate);
17904 if (PyErr_Occurred()) SWIG_fail;
17905 }
17906 resultobj = result;
17907 return resultobj;
17908 fail:
17909 return NULL;
17910 }
17911
17912
17913 static PyObject * DC_swigregister(PyObject *, PyObject *args) {
17914 PyObject *obj;
17915 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17916 SWIG_TypeClientData(SWIGTYPE_p_wxDC, obj);
17917 Py_INCREF(obj);
17918 return Py_BuildValue((char *)"");
17919 }
17920 static PyObject *_wrap_new_MemoryDC(PyObject *, PyObject *args, PyObject *kwargs) {
17921 PyObject *resultobj;
17922 wxMemoryDC *result;
17923 char *kwnames[] = {
17924 NULL
17925 };
17926
17927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryDC",kwnames)) goto fail;
17928 {
17929 if (!wxPyCheckForApp()) SWIG_fail;
17930 PyThreadState* __tstate = wxPyBeginAllowThreads();
17931 result = (wxMemoryDC *)new wxMemoryDC();
17932
17933 wxPyEndAllowThreads(__tstate);
17934 if (PyErr_Occurred()) SWIG_fail;
17935 }
17936 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17937 return resultobj;
17938 fail:
17939 return NULL;
17940 }
17941
17942
17943 static PyObject *_wrap_new_MemoryDCFromDC(PyObject *, PyObject *args, PyObject *kwargs) {
17944 PyObject *resultobj;
17945 wxDC *arg1 = (wxDC *) 0 ;
17946 wxMemoryDC *result;
17947 PyObject * obj0 = 0 ;
17948 char *kwnames[] = {
17949 (char *) "oldDC", NULL
17950 };
17951
17952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_MemoryDCFromDC",kwnames,&obj0)) goto fail;
17953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17954 if (SWIG_arg_fail(1)) SWIG_fail;
17955 {
17956 if (!wxPyCheckForApp()) SWIG_fail;
17957 PyThreadState* __tstate = wxPyBeginAllowThreads();
17958 result = (wxMemoryDC *)new wxMemoryDC(arg1);
17959
17960 wxPyEndAllowThreads(__tstate);
17961 if (PyErr_Occurred()) SWIG_fail;
17962 }
17963 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17964 return resultobj;
17965 fail:
17966 return NULL;
17967 }
17968
17969
17970 static PyObject *_wrap_MemoryDC_SelectObject(PyObject *, PyObject *args, PyObject *kwargs) {
17971 PyObject *resultobj;
17972 wxMemoryDC *arg1 = (wxMemoryDC *) 0 ;
17973 wxBitmap *arg2 = 0 ;
17974 PyObject * obj0 = 0 ;
17975 PyObject * obj1 = 0 ;
17976 char *kwnames[] = {
17977 (char *) "self",(char *) "bitmap", NULL
17978 };
17979
17980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryDC_SelectObject",kwnames,&obj0,&obj1)) goto fail;
17981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryDC, SWIG_POINTER_EXCEPTION | 0);
17982 if (SWIG_arg_fail(1)) SWIG_fail;
17983 {
17984 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17985 if (SWIG_arg_fail(2)) SWIG_fail;
17986 if (arg2 == NULL) {
17987 SWIG_null_ref("wxBitmap");
17988 }
17989 if (SWIG_arg_fail(2)) SWIG_fail;
17990 }
17991 {
17992 PyThreadState* __tstate = wxPyBeginAllowThreads();
17993 (arg1)->SelectObject((wxBitmap const &)*arg2);
17994
17995 wxPyEndAllowThreads(__tstate);
17996 if (PyErr_Occurred()) SWIG_fail;
17997 }
17998 Py_INCREF(Py_None); resultobj = Py_None;
17999 return resultobj;
18000 fail:
18001 return NULL;
18002 }
18003
18004
18005 static PyObject * MemoryDC_swigregister(PyObject *, PyObject *args) {
18006 PyObject *obj;
18007 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18008 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryDC, obj);
18009 Py_INCREF(obj);
18010 return Py_BuildValue((char *)"");
18011 }
18012 static PyObject *_wrap_new_BufferedDC__SWIG_0(PyObject *, PyObject *args) {
18013 PyObject *resultobj;
18014 wxDC *arg1 = (wxDC *) 0 ;
18015 wxBitmap const &arg2_defvalue = wxNullBitmap ;
18016 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
18017 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
18018 wxBufferedDC *result;
18019 PyObject * obj0 = 0 ;
18020 PyObject * obj1 = 0 ;
18021 PyObject * obj2 = 0 ;
18022
18023 if(!PyArg_ParseTuple(args,(char *)"O|OO:new_BufferedDC",&obj0,&obj1,&obj2)) goto fail;
18024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
18025 if (SWIG_arg_fail(1)) SWIG_fail;
18026 if (obj1) {
18027 {
18028 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18029 if (SWIG_arg_fail(2)) SWIG_fail;
18030 if (arg2 == NULL) {
18031 SWIG_null_ref("wxBitmap");
18032 }
18033 if (SWIG_arg_fail(2)) SWIG_fail;
18034 }
18035 }
18036 if (obj2) {
18037 {
18038 arg3 = (int)(SWIG_As_int(obj2));
18039 if (SWIG_arg_fail(3)) SWIG_fail;
18040 }
18041 }
18042 {
18043 if (!wxPyCheckForApp()) SWIG_fail;
18044 PyThreadState* __tstate = wxPyBeginAllowThreads();
18045 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxBitmap const &)*arg2,arg3);
18046
18047 wxPyEndAllowThreads(__tstate);
18048 if (PyErr_Occurred()) SWIG_fail;
18049 }
18050 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
18051 return resultobj;
18052 fail:
18053 return NULL;
18054 }
18055
18056
18057 static PyObject *_wrap_new_BufferedDC__SWIG_1(PyObject *, PyObject *args) {
18058 PyObject *resultobj;
18059 wxDC *arg1 = (wxDC *) 0 ;
18060 wxSize *arg2 = 0 ;
18061 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
18062 wxBufferedDC *result;
18063 wxSize temp2 ;
18064 PyObject * obj0 = 0 ;
18065 PyObject * obj1 = 0 ;
18066 PyObject * obj2 = 0 ;
18067
18068 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_BufferedDC",&obj0,&obj1,&obj2)) goto fail;
18069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
18070 if (SWIG_arg_fail(1)) SWIG_fail;
18071 {
18072 arg2 = &temp2;
18073 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
18074 }
18075 if (obj2) {
18076 {
18077 arg3 = (int)(SWIG_As_int(obj2));
18078 if (SWIG_arg_fail(3)) SWIG_fail;
18079 }
18080 }
18081 {
18082 if (!wxPyCheckForApp()) SWIG_fail;
18083 PyThreadState* __tstate = wxPyBeginAllowThreads();
18084 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxSize const &)*arg2,arg3);
18085
18086 wxPyEndAllowThreads(__tstate);
18087 if (PyErr_Occurred()) SWIG_fail;
18088 }
18089 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
18090 return resultobj;
18091 fail:
18092 return NULL;
18093 }
18094
18095
18096 static PyObject *_wrap_new_BufferedDC(PyObject *self, PyObject *args) {
18097 int argc;
18098 PyObject *argv[4];
18099 int ii;
18100
18101 argc = PyObject_Length(args);
18102 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
18103 argv[ii] = PyTuple_GetItem(args,ii);
18104 }
18105 if ((argc >= 1) && (argc <= 3)) {
18106 int _v;
18107 {
18108 void *ptr;
18109 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
18110 _v = 0;
18111 PyErr_Clear();
18112 } else {
18113 _v = 1;
18114 }
18115 }
18116 if (_v) {
18117 if (argc <= 1) {
18118 return _wrap_new_BufferedDC__SWIG_0(self,args);
18119 }
18120 {
18121 void *ptr = 0;
18122 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxBitmap, 0) == -1) {
18123 _v = 0;
18124 PyErr_Clear();
18125 } else {
18126 _v = (ptr != 0);
18127 }
18128 }
18129 if (_v) {
18130 if (argc <= 2) {
18131 return _wrap_new_BufferedDC__SWIG_0(self,args);
18132 }
18133 _v = SWIG_Check_int(argv[2]);
18134 if (_v) {
18135 return _wrap_new_BufferedDC__SWIG_0(self,args);
18136 }
18137 }
18138 }
18139 }
18140 if ((argc >= 2) && (argc <= 3)) {
18141 int _v;
18142 {
18143 void *ptr;
18144 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
18145 _v = 0;
18146 PyErr_Clear();
18147 } else {
18148 _v = 1;
18149 }
18150 }
18151 if (_v) {
18152 {
18153 _v = wxPySimple_typecheck(argv[1], wxT("wxSize"), 2);
18154 }
18155 if (_v) {
18156 if (argc <= 2) {
18157 return _wrap_new_BufferedDC__SWIG_1(self,args);
18158 }
18159 _v = SWIG_Check_int(argv[2]);
18160 if (_v) {
18161 return _wrap_new_BufferedDC__SWIG_1(self,args);
18162 }
18163 }
18164 }
18165 }
18166
18167 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_BufferedDC'");
18168 return NULL;
18169 }
18170
18171
18172 static PyObject *_wrap_delete_BufferedDC(PyObject *, PyObject *args, PyObject *kwargs) {
18173 PyObject *resultobj;
18174 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
18175 PyObject * obj0 = 0 ;
18176 char *kwnames[] = {
18177 (char *) "self", NULL
18178 };
18179
18180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BufferedDC",kwnames,&obj0)) goto fail;
18181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
18182 if (SWIG_arg_fail(1)) SWIG_fail;
18183 {
18184 PyThreadState* __tstate = wxPyBeginAllowThreads();
18185 delete arg1;
18186
18187 wxPyEndAllowThreads(__tstate);
18188 if (PyErr_Occurred()) SWIG_fail;
18189 }
18190 Py_INCREF(Py_None); resultobj = Py_None;
18191 return resultobj;
18192 fail:
18193 return NULL;
18194 }
18195
18196
18197 static PyObject *_wrap_BufferedDC_UnMask(PyObject *, PyObject *args, PyObject *kwargs) {
18198 PyObject *resultobj;
18199 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
18200 PyObject * obj0 = 0 ;
18201 char *kwnames[] = {
18202 (char *) "self", NULL
18203 };
18204
18205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BufferedDC_UnMask",kwnames,&obj0)) goto fail;
18206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
18207 if (SWIG_arg_fail(1)) SWIG_fail;
18208 {
18209 PyThreadState* __tstate = wxPyBeginAllowThreads();
18210 (arg1)->UnMask();
18211
18212 wxPyEndAllowThreads(__tstate);
18213 if (PyErr_Occurred()) SWIG_fail;
18214 }
18215 Py_INCREF(Py_None); resultobj = Py_None;
18216 return resultobj;
18217 fail:
18218 return NULL;
18219 }
18220
18221
18222 static PyObject * BufferedDC_swigregister(PyObject *, PyObject *args) {
18223 PyObject *obj;
18224 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18225 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedDC, obj);
18226 Py_INCREF(obj);
18227 return Py_BuildValue((char *)"");
18228 }
18229 static PyObject *_wrap_new_BufferedPaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
18230 PyObject *resultobj;
18231 wxWindow *arg1 = (wxWindow *) 0 ;
18232 wxBitmap const &arg2_defvalue = wxNullBitmap ;
18233 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
18234 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
18235 wxBufferedPaintDC *result;
18236 PyObject * obj0 = 0 ;
18237 PyObject * obj1 = 0 ;
18238 PyObject * obj2 = 0 ;
18239 char *kwnames[] = {
18240 (char *) "window",(char *) "buffer",(char *) "style", NULL
18241 };
18242
18243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_BufferedPaintDC",kwnames,&obj0,&obj1,&obj2)) goto fail;
18244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18245 if (SWIG_arg_fail(1)) SWIG_fail;
18246 if (obj1) {
18247 {
18248 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18249 if (SWIG_arg_fail(2)) SWIG_fail;
18250 if (arg2 == NULL) {
18251 SWIG_null_ref("wxBitmap");
18252 }
18253 if (SWIG_arg_fail(2)) SWIG_fail;
18254 }
18255 }
18256 if (obj2) {
18257 {
18258 arg3 = (int)(SWIG_As_int(obj2));
18259 if (SWIG_arg_fail(3)) SWIG_fail;
18260 }
18261 }
18262 {
18263 if (!wxPyCheckForApp()) SWIG_fail;
18264 PyThreadState* __tstate = wxPyBeginAllowThreads();
18265 result = (wxBufferedPaintDC *)new wxBufferedPaintDC(arg1,(wxBitmap const &)*arg2,arg3);
18266
18267 wxPyEndAllowThreads(__tstate);
18268 if (PyErr_Occurred()) SWIG_fail;
18269 }
18270 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedPaintDC, 1);
18271 return resultobj;
18272 fail:
18273 return NULL;
18274 }
18275
18276
18277 static PyObject * BufferedPaintDC_swigregister(PyObject *, PyObject *args) {
18278 PyObject *obj;
18279 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18280 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedPaintDC, obj);
18281 Py_INCREF(obj);
18282 return Py_BuildValue((char *)"");
18283 }
18284 static PyObject *_wrap_new_ScreenDC(PyObject *, PyObject *args, PyObject *kwargs) {
18285 PyObject *resultobj;
18286 wxScreenDC *result;
18287 char *kwnames[] = {
18288 NULL
18289 };
18290
18291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ScreenDC",kwnames)) goto fail;
18292 {
18293 if (!wxPyCheckForApp()) SWIG_fail;
18294 PyThreadState* __tstate = wxPyBeginAllowThreads();
18295 result = (wxScreenDC *)new wxScreenDC();
18296
18297 wxPyEndAllowThreads(__tstate);
18298 if (PyErr_Occurred()) SWIG_fail;
18299 }
18300 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScreenDC, 1);
18301 return resultobj;
18302 fail:
18303 return NULL;
18304 }
18305
18306
18307 static PyObject *_wrap_ScreenDC_StartDrawingOnTopWin(PyObject *, PyObject *args, PyObject *kwargs) {
18308 PyObject *resultobj;
18309 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
18310 wxWindow *arg2 = (wxWindow *) 0 ;
18311 bool result;
18312 PyObject * obj0 = 0 ;
18313 PyObject * obj1 = 0 ;
18314 char *kwnames[] = {
18315 (char *) "self",(char *) "window", NULL
18316 };
18317
18318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScreenDC_StartDrawingOnTopWin",kwnames,&obj0,&obj1)) goto fail;
18319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
18320 if (SWIG_arg_fail(1)) SWIG_fail;
18321 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18322 if (SWIG_arg_fail(2)) SWIG_fail;
18323 {
18324 PyThreadState* __tstate = wxPyBeginAllowThreads();
18325 result = (bool)(arg1)->StartDrawingOnTop(arg2);
18326
18327 wxPyEndAllowThreads(__tstate);
18328 if (PyErr_Occurred()) SWIG_fail;
18329 }
18330 {
18331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18332 }
18333 return resultobj;
18334 fail:
18335 return NULL;
18336 }
18337
18338
18339 static PyObject *_wrap_ScreenDC_StartDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
18340 PyObject *resultobj;
18341 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
18342 wxRect *arg2 = (wxRect *) NULL ;
18343 bool result;
18344 PyObject * obj0 = 0 ;
18345 PyObject * obj1 = 0 ;
18346 char *kwnames[] = {
18347 (char *) "self",(char *) "rect", NULL
18348 };
18349
18350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ScreenDC_StartDrawingOnTop",kwnames,&obj0,&obj1)) goto fail;
18351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
18352 if (SWIG_arg_fail(1)) SWIG_fail;
18353 if (obj1) {
18354 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
18355 if (SWIG_arg_fail(2)) SWIG_fail;
18356 }
18357 {
18358 PyThreadState* __tstate = wxPyBeginAllowThreads();
18359 result = (bool)(arg1)->StartDrawingOnTop(arg2);
18360
18361 wxPyEndAllowThreads(__tstate);
18362 if (PyErr_Occurred()) SWIG_fail;
18363 }
18364 {
18365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18366 }
18367 return resultobj;
18368 fail:
18369 return NULL;
18370 }
18371
18372
18373 static PyObject *_wrap_ScreenDC_EndDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
18374 PyObject *resultobj;
18375 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
18376 bool result;
18377 PyObject * obj0 = 0 ;
18378 char *kwnames[] = {
18379 (char *) "self", NULL
18380 };
18381
18382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScreenDC_EndDrawingOnTop",kwnames,&obj0)) goto fail;
18383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
18384 if (SWIG_arg_fail(1)) SWIG_fail;
18385 {
18386 PyThreadState* __tstate = wxPyBeginAllowThreads();
18387 result = (bool)(arg1)->EndDrawingOnTop();
18388
18389 wxPyEndAllowThreads(__tstate);
18390 if (PyErr_Occurred()) SWIG_fail;
18391 }
18392 {
18393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18394 }
18395 return resultobj;
18396 fail:
18397 return NULL;
18398 }
18399
18400
18401 static PyObject * ScreenDC_swigregister(PyObject *, PyObject *args) {
18402 PyObject *obj;
18403 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18404 SWIG_TypeClientData(SWIGTYPE_p_wxScreenDC, obj);
18405 Py_INCREF(obj);
18406 return Py_BuildValue((char *)"");
18407 }
18408 static PyObject *_wrap_new_ClientDC(PyObject *, PyObject *args, PyObject *kwargs) {
18409 PyObject *resultobj;
18410 wxWindow *arg1 = (wxWindow *) 0 ;
18411 wxClientDC *result;
18412 PyObject * obj0 = 0 ;
18413 char *kwnames[] = {
18414 (char *) "win", NULL
18415 };
18416
18417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ClientDC",kwnames,&obj0)) goto fail;
18418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18419 if (SWIG_arg_fail(1)) SWIG_fail;
18420 {
18421 if (!wxPyCheckForApp()) SWIG_fail;
18422 PyThreadState* __tstate = wxPyBeginAllowThreads();
18423 result = (wxClientDC *)new wxClientDC(arg1);
18424
18425 wxPyEndAllowThreads(__tstate);
18426 if (PyErr_Occurred()) SWIG_fail;
18427 }
18428 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClientDC, 1);
18429 return resultobj;
18430 fail:
18431 return NULL;
18432 }
18433
18434
18435 static PyObject * ClientDC_swigregister(PyObject *, PyObject *args) {
18436 PyObject *obj;
18437 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18438 SWIG_TypeClientData(SWIGTYPE_p_wxClientDC, obj);
18439 Py_INCREF(obj);
18440 return Py_BuildValue((char *)"");
18441 }
18442 static PyObject *_wrap_new_PaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
18443 PyObject *resultobj;
18444 wxWindow *arg1 = (wxWindow *) 0 ;
18445 wxPaintDC *result;
18446 PyObject * obj0 = 0 ;
18447 char *kwnames[] = {
18448 (char *) "win", NULL
18449 };
18450
18451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PaintDC",kwnames,&obj0)) goto fail;
18452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18453 if (SWIG_arg_fail(1)) SWIG_fail;
18454 {
18455 if (!wxPyCheckForApp()) SWIG_fail;
18456 PyThreadState* __tstate = wxPyBeginAllowThreads();
18457 result = (wxPaintDC *)new wxPaintDC(arg1);
18458
18459 wxPyEndAllowThreads(__tstate);
18460 if (PyErr_Occurred()) SWIG_fail;
18461 }
18462 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintDC, 1);
18463 return resultobj;
18464 fail:
18465 return NULL;
18466 }
18467
18468
18469 static PyObject * PaintDC_swigregister(PyObject *, PyObject *args) {
18470 PyObject *obj;
18471 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18472 SWIG_TypeClientData(SWIGTYPE_p_wxPaintDC, obj);
18473 Py_INCREF(obj);
18474 return Py_BuildValue((char *)"");
18475 }
18476 static PyObject *_wrap_new_WindowDC(PyObject *, PyObject *args, PyObject *kwargs) {
18477 PyObject *resultobj;
18478 wxWindow *arg1 = (wxWindow *) 0 ;
18479 wxWindowDC *result;
18480 PyObject * obj0 = 0 ;
18481 char *kwnames[] = {
18482 (char *) "win", NULL
18483 };
18484
18485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_WindowDC",kwnames,&obj0)) goto fail;
18486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
18487 if (SWIG_arg_fail(1)) SWIG_fail;
18488 {
18489 if (!wxPyCheckForApp()) SWIG_fail;
18490 PyThreadState* __tstate = wxPyBeginAllowThreads();
18491 result = (wxWindowDC *)new wxWindowDC(arg1);
18492
18493 wxPyEndAllowThreads(__tstate);
18494 if (PyErr_Occurred()) SWIG_fail;
18495 }
18496 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDC, 1);
18497 return resultobj;
18498 fail:
18499 return NULL;
18500 }
18501
18502
18503 static PyObject * WindowDC_swigregister(PyObject *, PyObject *args) {
18504 PyObject *obj;
18505 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18506 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDC, obj);
18507 Py_INCREF(obj);
18508 return Py_BuildValue((char *)"");
18509 }
18510 static PyObject *_wrap_new_MirrorDC(PyObject *, PyObject *args, PyObject *kwargs) {
18511 PyObject *resultobj;
18512 wxDC *arg1 = 0 ;
18513 bool arg2 ;
18514 wxMirrorDC *result;
18515 PyObject * obj0 = 0 ;
18516 PyObject * obj1 = 0 ;
18517 char *kwnames[] = {
18518 (char *) "dc",(char *) "mirror", NULL
18519 };
18520
18521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_MirrorDC",kwnames,&obj0,&obj1)) goto fail;
18522 {
18523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
18524 if (SWIG_arg_fail(1)) SWIG_fail;
18525 if (arg1 == NULL) {
18526 SWIG_null_ref("wxDC");
18527 }
18528 if (SWIG_arg_fail(1)) SWIG_fail;
18529 }
18530 {
18531 arg2 = (bool)(SWIG_As_bool(obj1));
18532 if (SWIG_arg_fail(2)) SWIG_fail;
18533 }
18534 {
18535 if (!wxPyCheckForApp()) SWIG_fail;
18536 PyThreadState* __tstate = wxPyBeginAllowThreads();
18537 result = (wxMirrorDC *)new wxMirrorDC(*arg1,arg2);
18538
18539 wxPyEndAllowThreads(__tstate);
18540 if (PyErr_Occurred()) SWIG_fail;
18541 }
18542 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMirrorDC, 1);
18543 return resultobj;
18544 fail:
18545 return NULL;
18546 }
18547
18548
18549 static PyObject * MirrorDC_swigregister(PyObject *, PyObject *args) {
18550 PyObject *obj;
18551 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18552 SWIG_TypeClientData(SWIGTYPE_p_wxMirrorDC, obj);
18553 Py_INCREF(obj);
18554 return Py_BuildValue((char *)"");
18555 }
18556 static PyObject *_wrap_new_PostScriptDC(PyObject *, PyObject *args, PyObject *kwargs) {
18557 PyObject *resultobj;
18558 wxPrintData *arg1 = 0 ;
18559 wxPostScriptDC *result;
18560 PyObject * obj0 = 0 ;
18561 char *kwnames[] = {
18562 (char *) "printData", NULL
18563 };
18564
18565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PostScriptDC",kwnames,&obj0)) goto fail;
18566 {
18567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
18568 if (SWIG_arg_fail(1)) SWIG_fail;
18569 if (arg1 == NULL) {
18570 SWIG_null_ref("wxPrintData");
18571 }
18572 if (SWIG_arg_fail(1)) SWIG_fail;
18573 }
18574 {
18575 if (!wxPyCheckForApp()) SWIG_fail;
18576 PyThreadState* __tstate = wxPyBeginAllowThreads();
18577 result = (wxPostScriptDC *)new wxPostScriptDC((wxPrintData const &)*arg1);
18578
18579 wxPyEndAllowThreads(__tstate);
18580 if (PyErr_Occurred()) SWIG_fail;
18581 }
18582 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPostScriptDC, 1);
18583 return resultobj;
18584 fail:
18585 return NULL;
18586 }
18587
18588
18589 static PyObject *_wrap_PostScriptDC_GetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
18590 PyObject *resultobj;
18591 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
18592 wxPrintData *result;
18593 PyObject * obj0 = 0 ;
18594 char *kwnames[] = {
18595 (char *) "self", NULL
18596 };
18597
18598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_GetPrintData",kwnames,&obj0)) goto fail;
18599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
18600 if (SWIG_arg_fail(1)) SWIG_fail;
18601 {
18602 PyThreadState* __tstate = wxPyBeginAllowThreads();
18603 {
18604 wxPrintData &_result_ref = (arg1)->GetPrintData();
18605 result = (wxPrintData *) &_result_ref;
18606 }
18607
18608 wxPyEndAllowThreads(__tstate);
18609 if (PyErr_Occurred()) SWIG_fail;
18610 }
18611 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 0);
18612 return resultobj;
18613 fail:
18614 return NULL;
18615 }
18616
18617
18618 static PyObject *_wrap_PostScriptDC_SetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
18619 PyObject *resultobj;
18620 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
18621 wxPrintData *arg2 = 0 ;
18622 PyObject * obj0 = 0 ;
18623 PyObject * obj1 = 0 ;
18624 char *kwnames[] = {
18625 (char *) "self",(char *) "data", NULL
18626 };
18627
18628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostScriptDC_SetPrintData",kwnames,&obj0,&obj1)) goto fail;
18629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
18630 if (SWIG_arg_fail(1)) SWIG_fail;
18631 {
18632 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
18633 if (SWIG_arg_fail(2)) SWIG_fail;
18634 if (arg2 == NULL) {
18635 SWIG_null_ref("wxPrintData");
18636 }
18637 if (SWIG_arg_fail(2)) SWIG_fail;
18638 }
18639 {
18640 PyThreadState* __tstate = wxPyBeginAllowThreads();
18641 (arg1)->SetPrintData((wxPrintData const &)*arg2);
18642
18643 wxPyEndAllowThreads(__tstate);
18644 if (PyErr_Occurred()) SWIG_fail;
18645 }
18646 Py_INCREF(Py_None); resultobj = Py_None;
18647 return resultobj;
18648 fail:
18649 return NULL;
18650 }
18651
18652
18653 static PyObject *_wrap_PostScriptDC_SetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
18654 PyObject *resultobj;
18655 int arg1 ;
18656 PyObject * obj0 = 0 ;
18657 char *kwnames[] = {
18658 (char *) "ppi", NULL
18659 };
18660
18661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_SetResolution",kwnames,&obj0)) goto fail;
18662 {
18663 arg1 = (int)(SWIG_As_int(obj0));
18664 if (SWIG_arg_fail(1)) SWIG_fail;
18665 }
18666 {
18667 PyThreadState* __tstate = wxPyBeginAllowThreads();
18668 wxPostScriptDC::SetResolution(arg1);
18669
18670 wxPyEndAllowThreads(__tstate);
18671 if (PyErr_Occurred()) SWIG_fail;
18672 }
18673 Py_INCREF(Py_None); resultobj = Py_None;
18674 return resultobj;
18675 fail:
18676 return NULL;
18677 }
18678
18679
18680 static PyObject *_wrap_PostScriptDC_GetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
18681 PyObject *resultobj;
18682 int result;
18683 char *kwnames[] = {
18684 NULL
18685 };
18686
18687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PostScriptDC_GetResolution",kwnames)) goto fail;
18688 {
18689 PyThreadState* __tstate = wxPyBeginAllowThreads();
18690 result = (int)wxPostScriptDC::GetResolution();
18691
18692 wxPyEndAllowThreads(__tstate);
18693 if (PyErr_Occurred()) SWIG_fail;
18694 }
18695 {
18696 resultobj = SWIG_From_int((int)(result));
18697 }
18698 return resultobj;
18699 fail:
18700 return NULL;
18701 }
18702
18703
18704 static PyObject * PostScriptDC_swigregister(PyObject *, PyObject *args) {
18705 PyObject *obj;
18706 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18707 SWIG_TypeClientData(SWIGTYPE_p_wxPostScriptDC, obj);
18708 Py_INCREF(obj);
18709 return Py_BuildValue((char *)"");
18710 }
18711 static PyObject *_wrap_new_MetaFile(PyObject *, PyObject *args, PyObject *kwargs) {
18712 PyObject *resultobj;
18713 wxString const &arg1_defvalue = wxPyEmptyString ;
18714 wxString *arg1 = (wxString *) &arg1_defvalue ;
18715 wxMetaFile *result;
18716 bool temp1 = false ;
18717 PyObject * obj0 = 0 ;
18718 char *kwnames[] = {
18719 (char *) "filename", NULL
18720 };
18721
18722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MetaFile",kwnames,&obj0)) goto fail;
18723 if (obj0) {
18724 {
18725 arg1 = wxString_in_helper(obj0);
18726 if (arg1 == NULL) SWIG_fail;
18727 temp1 = true;
18728 }
18729 }
18730 {
18731 if (!wxPyCheckForApp()) SWIG_fail;
18732 PyThreadState* __tstate = wxPyBeginAllowThreads();
18733 result = (wxMetaFile *)new wxMetaFile((wxString const &)*arg1);
18734
18735 wxPyEndAllowThreads(__tstate);
18736 if (PyErr_Occurred()) SWIG_fail;
18737 }
18738 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFile, 1);
18739 {
18740 if (temp1)
18741 delete arg1;
18742 }
18743 return resultobj;
18744 fail:
18745 {
18746 if (temp1)
18747 delete arg1;
18748 }
18749 return NULL;
18750 }
18751
18752
18753 static PyObject *_wrap_delete_MetaFile(PyObject *, PyObject *args, PyObject *kwargs) {
18754 PyObject *resultobj;
18755 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18756 PyObject * obj0 = 0 ;
18757 char *kwnames[] = {
18758 (char *) "self", NULL
18759 };
18760
18761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MetaFile",kwnames,&obj0)) goto fail;
18762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18763 if (SWIG_arg_fail(1)) SWIG_fail;
18764 {
18765 PyThreadState* __tstate = wxPyBeginAllowThreads();
18766 delete arg1;
18767
18768 wxPyEndAllowThreads(__tstate);
18769 if (PyErr_Occurred()) SWIG_fail;
18770 }
18771 Py_INCREF(Py_None); resultobj = Py_None;
18772 return resultobj;
18773 fail:
18774 return NULL;
18775 }
18776
18777
18778 static PyObject *_wrap_MetaFile_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
18779 PyObject *resultobj;
18780 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18781 bool result;
18782 PyObject * obj0 = 0 ;
18783 char *kwnames[] = {
18784 (char *) "self", NULL
18785 };
18786
18787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_Ok",kwnames,&obj0)) goto fail;
18788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18789 if (SWIG_arg_fail(1)) SWIG_fail;
18790 {
18791 PyThreadState* __tstate = wxPyBeginAllowThreads();
18792 result = (bool)(arg1)->Ok();
18793
18794 wxPyEndAllowThreads(__tstate);
18795 if (PyErr_Occurred()) SWIG_fail;
18796 }
18797 {
18798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18799 }
18800 return resultobj;
18801 fail:
18802 return NULL;
18803 }
18804
18805
18806 static PyObject *_wrap_MetaFile_SetClipboard(PyObject *, PyObject *args, PyObject *kwargs) {
18807 PyObject *resultobj;
18808 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18809 int arg2 = (int) 0 ;
18810 int arg3 = (int) 0 ;
18811 bool result;
18812 PyObject * obj0 = 0 ;
18813 PyObject * obj1 = 0 ;
18814 PyObject * obj2 = 0 ;
18815 char *kwnames[] = {
18816 (char *) "self",(char *) "width",(char *) "height", NULL
18817 };
18818
18819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MetaFile_SetClipboard",kwnames,&obj0,&obj1,&obj2)) goto fail;
18820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18821 if (SWIG_arg_fail(1)) SWIG_fail;
18822 if (obj1) {
18823 {
18824 arg2 = (int)(SWIG_As_int(obj1));
18825 if (SWIG_arg_fail(2)) SWIG_fail;
18826 }
18827 }
18828 if (obj2) {
18829 {
18830 arg3 = (int)(SWIG_As_int(obj2));
18831 if (SWIG_arg_fail(3)) SWIG_fail;
18832 }
18833 }
18834 {
18835 PyThreadState* __tstate = wxPyBeginAllowThreads();
18836 result = (bool)(arg1)->SetClipboard(arg2,arg3);
18837
18838 wxPyEndAllowThreads(__tstate);
18839 if (PyErr_Occurred()) SWIG_fail;
18840 }
18841 {
18842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18843 }
18844 return resultobj;
18845 fail:
18846 return NULL;
18847 }
18848
18849
18850 static PyObject *_wrap_MetaFile_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18851 PyObject *resultobj;
18852 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18853 wxSize result;
18854 PyObject * obj0 = 0 ;
18855 char *kwnames[] = {
18856 (char *) "self", NULL
18857 };
18858
18859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetSize",kwnames,&obj0)) goto fail;
18860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18861 if (SWIG_arg_fail(1)) SWIG_fail;
18862 {
18863 PyThreadState* __tstate = wxPyBeginAllowThreads();
18864 result = (arg1)->GetSize();
18865
18866 wxPyEndAllowThreads(__tstate);
18867 if (PyErr_Occurred()) SWIG_fail;
18868 }
18869 {
18870 wxSize * resultptr;
18871 resultptr = new wxSize((wxSize &)(result));
18872 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18873 }
18874 return resultobj;
18875 fail:
18876 return NULL;
18877 }
18878
18879
18880 static PyObject *_wrap_MetaFile_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
18881 PyObject *resultobj;
18882 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18883 int result;
18884 PyObject * obj0 = 0 ;
18885 char *kwnames[] = {
18886 (char *) "self", NULL
18887 };
18888
18889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetWidth",kwnames,&obj0)) goto fail;
18890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18891 if (SWIG_arg_fail(1)) SWIG_fail;
18892 {
18893 PyThreadState* __tstate = wxPyBeginAllowThreads();
18894 result = (int)(arg1)->GetWidth();
18895
18896 wxPyEndAllowThreads(__tstate);
18897 if (PyErr_Occurred()) SWIG_fail;
18898 }
18899 {
18900 resultobj = SWIG_From_int((int)(result));
18901 }
18902 return resultobj;
18903 fail:
18904 return NULL;
18905 }
18906
18907
18908 static PyObject *_wrap_MetaFile_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
18909 PyObject *resultobj;
18910 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18911 int result;
18912 PyObject * obj0 = 0 ;
18913 char *kwnames[] = {
18914 (char *) "self", NULL
18915 };
18916
18917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetHeight",kwnames,&obj0)) goto fail;
18918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18919 if (SWIG_arg_fail(1)) SWIG_fail;
18920 {
18921 PyThreadState* __tstate = wxPyBeginAllowThreads();
18922 result = (int)(arg1)->GetHeight();
18923
18924 wxPyEndAllowThreads(__tstate);
18925 if (PyErr_Occurred()) SWIG_fail;
18926 }
18927 {
18928 resultobj = SWIG_From_int((int)(result));
18929 }
18930 return resultobj;
18931 fail:
18932 return NULL;
18933 }
18934
18935
18936 static PyObject *_wrap_MetaFile_GetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
18937 PyObject *resultobj;
18938 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18939 wxString *result;
18940 PyObject * obj0 = 0 ;
18941 char *kwnames[] = {
18942 (char *) "self", NULL
18943 };
18944
18945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetFileName",kwnames,&obj0)) goto fail;
18946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18947 if (SWIG_arg_fail(1)) SWIG_fail;
18948 {
18949 PyThreadState* __tstate = wxPyBeginAllowThreads();
18950 {
18951 wxString const &_result_ref = ((wxMetaFile const *)arg1)->GetFileName();
18952 result = (wxString *) &_result_ref;
18953 }
18954
18955 wxPyEndAllowThreads(__tstate);
18956 if (PyErr_Occurred()) SWIG_fail;
18957 }
18958 {
18959 #if wxUSE_UNICODE
18960 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18961 #else
18962 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18963 #endif
18964 }
18965 return resultobj;
18966 fail:
18967 return NULL;
18968 }
18969
18970
18971 static PyObject * MetaFile_swigregister(PyObject *, PyObject *args) {
18972 PyObject *obj;
18973 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18974 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFile, obj);
18975 Py_INCREF(obj);
18976 return Py_BuildValue((char *)"");
18977 }
18978 static PyObject *_wrap_new_MetaFileDC(PyObject *, PyObject *args, PyObject *kwargs) {
18979 PyObject *resultobj;
18980 wxString const &arg1_defvalue = wxPyEmptyString ;
18981 wxString *arg1 = (wxString *) &arg1_defvalue ;
18982 int arg2 = (int) 0 ;
18983 int arg3 = (int) 0 ;
18984 wxString const &arg4_defvalue = wxPyEmptyString ;
18985 wxString *arg4 = (wxString *) &arg4_defvalue ;
18986 wxMetaFileDC *result;
18987 bool temp1 = false ;
18988 bool temp4 = false ;
18989 PyObject * obj0 = 0 ;
18990 PyObject * obj1 = 0 ;
18991 PyObject * obj2 = 0 ;
18992 PyObject * obj3 = 0 ;
18993 char *kwnames[] = {
18994 (char *) "filename",(char *) "width",(char *) "height",(char *) "description", NULL
18995 };
18996
18997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_MetaFileDC",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
18998 if (obj0) {
18999 {
19000 arg1 = wxString_in_helper(obj0);
19001 if (arg1 == NULL) SWIG_fail;
19002 temp1 = true;
19003 }
19004 }
19005 if (obj1) {
19006 {
19007 arg2 = (int)(SWIG_As_int(obj1));
19008 if (SWIG_arg_fail(2)) SWIG_fail;
19009 }
19010 }
19011 if (obj2) {
19012 {
19013 arg3 = (int)(SWIG_As_int(obj2));
19014 if (SWIG_arg_fail(3)) SWIG_fail;
19015 }
19016 }
19017 if (obj3) {
19018 {
19019 arg4 = wxString_in_helper(obj3);
19020 if (arg4 == NULL) SWIG_fail;
19021 temp4 = true;
19022 }
19023 }
19024 {
19025 if (!wxPyCheckForApp()) SWIG_fail;
19026 PyThreadState* __tstate = wxPyBeginAllowThreads();
19027 result = (wxMetaFileDC *)new wxMetaFileDC((wxString const &)*arg1,arg2,arg3,(wxString const &)*arg4);
19028
19029 wxPyEndAllowThreads(__tstate);
19030 if (PyErr_Occurred()) SWIG_fail;
19031 }
19032 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFileDC, 1);
19033 {
19034 if (temp1)
19035 delete arg1;
19036 }
19037 {
19038 if (temp4)
19039 delete arg4;
19040 }
19041 return resultobj;
19042 fail:
19043 {
19044 if (temp1)
19045 delete arg1;
19046 }
19047 {
19048 if (temp4)
19049 delete arg4;
19050 }
19051 return NULL;
19052 }
19053
19054
19055 static PyObject *_wrap_MetaFileDC_Close(PyObject *, PyObject *args, PyObject *kwargs) {
19056 PyObject *resultobj;
19057 wxMetaFileDC *arg1 = (wxMetaFileDC *) 0 ;
19058 wxMetaFile *result;
19059 PyObject * obj0 = 0 ;
19060 char *kwnames[] = {
19061 (char *) "self", NULL
19062 };
19063
19064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFileDC_Close",kwnames,&obj0)) goto fail;
19065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFileDC, SWIG_POINTER_EXCEPTION | 0);
19066 if (SWIG_arg_fail(1)) SWIG_fail;
19067 {
19068 PyThreadState* __tstate = wxPyBeginAllowThreads();
19069 result = (wxMetaFile *)(arg1)->Close();
19070
19071 wxPyEndAllowThreads(__tstate);
19072 if (PyErr_Occurred()) SWIG_fail;
19073 }
19074 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFile, 0);
19075 return resultobj;
19076 fail:
19077 return NULL;
19078 }
19079
19080
19081 static PyObject * MetaFileDC_swigregister(PyObject *, PyObject *args) {
19082 PyObject *obj;
19083 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19084 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFileDC, obj);
19085 Py_INCREF(obj);
19086 return Py_BuildValue((char *)"");
19087 }
19088 static PyObject *_wrap_new_PrinterDC(PyObject *, PyObject *args, PyObject *kwargs) {
19089 PyObject *resultobj;
19090 wxPrintData *arg1 = 0 ;
19091 wxPrinterDC *result;
19092 PyObject * obj0 = 0 ;
19093 char *kwnames[] = {
19094 (char *) "printData", NULL
19095 };
19096
19097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PrinterDC",kwnames,&obj0)) goto fail;
19098 {
19099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
19100 if (SWIG_arg_fail(1)) SWIG_fail;
19101 if (arg1 == NULL) {
19102 SWIG_null_ref("wxPrintData");
19103 }
19104 if (SWIG_arg_fail(1)) SWIG_fail;
19105 }
19106 {
19107 if (!wxPyCheckForApp()) SWIG_fail;
19108 PyThreadState* __tstate = wxPyBeginAllowThreads();
19109 result = (wxPrinterDC *)new wxPrinterDC((wxPrintData const &)*arg1);
19110
19111 wxPyEndAllowThreads(__tstate);
19112 if (PyErr_Occurred()) SWIG_fail;
19113 }
19114 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrinterDC, 1);
19115 return resultobj;
19116 fail:
19117 return NULL;
19118 }
19119
19120
19121 static PyObject * PrinterDC_swigregister(PyObject *, PyObject *args) {
19122 PyObject *obj;
19123 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19124 SWIG_TypeClientData(SWIGTYPE_p_wxPrinterDC, obj);
19125 Py_INCREF(obj);
19126 return Py_BuildValue((char *)"");
19127 }
19128 static PyObject *_wrap_new_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
19129 PyObject *resultobj;
19130 int arg1 ;
19131 int arg2 ;
19132 int arg3 = (int) true ;
19133 int arg4 = (int) 1 ;
19134 wxImageList *result;
19135 PyObject * obj0 = 0 ;
19136 PyObject * obj1 = 0 ;
19137 PyObject * obj2 = 0 ;
19138 PyObject * obj3 = 0 ;
19139 char *kwnames[] = {
19140 (char *) "width",(char *) "height",(char *) "mask",(char *) "initialCount", NULL
19141 };
19142
19143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_ImageList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19144 {
19145 arg1 = (int)(SWIG_As_int(obj0));
19146 if (SWIG_arg_fail(1)) SWIG_fail;
19147 }
19148 {
19149 arg2 = (int)(SWIG_As_int(obj1));
19150 if (SWIG_arg_fail(2)) SWIG_fail;
19151 }
19152 if (obj2) {
19153 {
19154 arg3 = (int)(SWIG_As_int(obj2));
19155 if (SWIG_arg_fail(3)) SWIG_fail;
19156 }
19157 }
19158 if (obj3) {
19159 {
19160 arg4 = (int)(SWIG_As_int(obj3));
19161 if (SWIG_arg_fail(4)) SWIG_fail;
19162 }
19163 }
19164 {
19165 if (!wxPyCheckForApp()) SWIG_fail;
19166 PyThreadState* __tstate = wxPyBeginAllowThreads();
19167 result = (wxImageList *)new wxImageList(arg1,arg2,arg3,arg4);
19168
19169 wxPyEndAllowThreads(__tstate);
19170 if (PyErr_Occurred()) SWIG_fail;
19171 }
19172 {
19173 resultobj = wxPyMake_wxObject(result, 1);
19174 }
19175 return resultobj;
19176 fail:
19177 return NULL;
19178 }
19179
19180
19181 static PyObject *_wrap_delete_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
19182 PyObject *resultobj;
19183 wxImageList *arg1 = (wxImageList *) 0 ;
19184 PyObject * obj0 = 0 ;
19185 char *kwnames[] = {
19186 (char *) "self", NULL
19187 };
19188
19189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ImageList",kwnames,&obj0)) goto fail;
19190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19191 if (SWIG_arg_fail(1)) SWIG_fail;
19192 {
19193 PyThreadState* __tstate = wxPyBeginAllowThreads();
19194 delete arg1;
19195
19196 wxPyEndAllowThreads(__tstate);
19197 if (PyErr_Occurred()) SWIG_fail;
19198 }
19199 Py_INCREF(Py_None); resultobj = Py_None;
19200 return resultobj;
19201 fail:
19202 return NULL;
19203 }
19204
19205
19206 static PyObject *_wrap_ImageList_Add(PyObject *, PyObject *args, PyObject *kwargs) {
19207 PyObject *resultobj;
19208 wxImageList *arg1 = (wxImageList *) 0 ;
19209 wxBitmap *arg2 = 0 ;
19210 wxBitmap const &arg3_defvalue = wxNullBitmap ;
19211 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
19212 int result;
19213 PyObject * obj0 = 0 ;
19214 PyObject * obj1 = 0 ;
19215 PyObject * obj2 = 0 ;
19216 char *kwnames[] = {
19217 (char *) "self",(char *) "bitmap",(char *) "mask", NULL
19218 };
19219
19220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ImageList_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
19221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19222 if (SWIG_arg_fail(1)) SWIG_fail;
19223 {
19224 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19225 if (SWIG_arg_fail(2)) SWIG_fail;
19226 if (arg2 == NULL) {
19227 SWIG_null_ref("wxBitmap");
19228 }
19229 if (SWIG_arg_fail(2)) SWIG_fail;
19230 }
19231 if (obj2) {
19232 {
19233 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19234 if (SWIG_arg_fail(3)) SWIG_fail;
19235 if (arg3 == NULL) {
19236 SWIG_null_ref("wxBitmap");
19237 }
19238 if (SWIG_arg_fail(3)) SWIG_fail;
19239 }
19240 }
19241 {
19242 PyThreadState* __tstate = wxPyBeginAllowThreads();
19243 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
19244
19245 wxPyEndAllowThreads(__tstate);
19246 if (PyErr_Occurred()) SWIG_fail;
19247 }
19248 {
19249 resultobj = SWIG_From_int((int)(result));
19250 }
19251 return resultobj;
19252 fail:
19253 return NULL;
19254 }
19255
19256
19257 static PyObject *_wrap_ImageList_AddWithColourMask(PyObject *, PyObject *args, PyObject *kwargs) {
19258 PyObject *resultobj;
19259 wxImageList *arg1 = (wxImageList *) 0 ;
19260 wxBitmap *arg2 = 0 ;
19261 wxColour *arg3 = 0 ;
19262 int result;
19263 wxColour temp3 ;
19264 PyObject * obj0 = 0 ;
19265 PyObject * obj1 = 0 ;
19266 PyObject * obj2 = 0 ;
19267 char *kwnames[] = {
19268 (char *) "self",(char *) "bitmap",(char *) "maskColour", NULL
19269 };
19270
19271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_AddWithColourMask",kwnames,&obj0,&obj1,&obj2)) goto fail;
19272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19273 if (SWIG_arg_fail(1)) SWIG_fail;
19274 {
19275 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19276 if (SWIG_arg_fail(2)) SWIG_fail;
19277 if (arg2 == NULL) {
19278 SWIG_null_ref("wxBitmap");
19279 }
19280 if (SWIG_arg_fail(2)) SWIG_fail;
19281 }
19282 {
19283 arg3 = &temp3;
19284 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
19285 }
19286 {
19287 PyThreadState* __tstate = wxPyBeginAllowThreads();
19288 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxColour const &)*arg3);
19289
19290 wxPyEndAllowThreads(__tstate);
19291 if (PyErr_Occurred()) SWIG_fail;
19292 }
19293 {
19294 resultobj = SWIG_From_int((int)(result));
19295 }
19296 return resultobj;
19297 fail:
19298 return NULL;
19299 }
19300
19301
19302 static PyObject *_wrap_ImageList_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
19303 PyObject *resultobj;
19304 wxImageList *arg1 = (wxImageList *) 0 ;
19305 wxIcon *arg2 = 0 ;
19306 int result;
19307 PyObject * obj0 = 0 ;
19308 PyObject * obj1 = 0 ;
19309 char *kwnames[] = {
19310 (char *) "self",(char *) "icon", NULL
19311 };
19312
19313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_AddIcon",kwnames,&obj0,&obj1)) goto fail;
19314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19315 if (SWIG_arg_fail(1)) SWIG_fail;
19316 {
19317 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
19318 if (SWIG_arg_fail(2)) SWIG_fail;
19319 if (arg2 == NULL) {
19320 SWIG_null_ref("wxIcon");
19321 }
19322 if (SWIG_arg_fail(2)) SWIG_fail;
19323 }
19324 {
19325 PyThreadState* __tstate = wxPyBeginAllowThreads();
19326 result = (int)(arg1)->Add((wxIcon const &)*arg2);
19327
19328 wxPyEndAllowThreads(__tstate);
19329 if (PyErr_Occurred()) SWIG_fail;
19330 }
19331 {
19332 resultobj = SWIG_From_int((int)(result));
19333 }
19334 return resultobj;
19335 fail:
19336 return NULL;
19337 }
19338
19339
19340 static PyObject *_wrap_ImageList_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
19341 PyObject *resultobj;
19342 wxImageList *arg1 = (wxImageList *) 0 ;
19343 int arg2 ;
19344 SwigValueWrapper<wxBitmap > result;
19345 PyObject * obj0 = 0 ;
19346 PyObject * obj1 = 0 ;
19347 char *kwnames[] = {
19348 (char *) "self",(char *) "index", NULL
19349 };
19350
19351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetBitmap",kwnames,&obj0,&obj1)) goto fail;
19352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19353 if (SWIG_arg_fail(1)) SWIG_fail;
19354 {
19355 arg2 = (int)(SWIG_As_int(obj1));
19356 if (SWIG_arg_fail(2)) SWIG_fail;
19357 }
19358 {
19359 PyThreadState* __tstate = wxPyBeginAllowThreads();
19360 result = ((wxImageList const *)arg1)->GetBitmap(arg2);
19361
19362 wxPyEndAllowThreads(__tstate);
19363 if (PyErr_Occurred()) SWIG_fail;
19364 }
19365 {
19366 wxBitmap * resultptr;
19367 resultptr = new wxBitmap((wxBitmap &)(result));
19368 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
19369 }
19370 return resultobj;
19371 fail:
19372 return NULL;
19373 }
19374
19375
19376 static PyObject *_wrap_ImageList_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
19377 PyObject *resultobj;
19378 wxImageList *arg1 = (wxImageList *) 0 ;
19379 int arg2 ;
19380 wxIcon result;
19381 PyObject * obj0 = 0 ;
19382 PyObject * obj1 = 0 ;
19383 char *kwnames[] = {
19384 (char *) "self",(char *) "index", NULL
19385 };
19386
19387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetIcon",kwnames,&obj0,&obj1)) goto fail;
19388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19389 if (SWIG_arg_fail(1)) SWIG_fail;
19390 {
19391 arg2 = (int)(SWIG_As_int(obj1));
19392 if (SWIG_arg_fail(2)) SWIG_fail;
19393 }
19394 {
19395 PyThreadState* __tstate = wxPyBeginAllowThreads();
19396 result = ((wxImageList const *)arg1)->GetIcon(arg2);
19397
19398 wxPyEndAllowThreads(__tstate);
19399 if (PyErr_Occurred()) SWIG_fail;
19400 }
19401 {
19402 wxIcon * resultptr;
19403 resultptr = new wxIcon((wxIcon &)(result));
19404 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
19405 }
19406 return resultobj;
19407 fail:
19408 return NULL;
19409 }
19410
19411
19412 static PyObject *_wrap_ImageList_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
19413 PyObject *resultobj;
19414 wxImageList *arg1 = (wxImageList *) 0 ;
19415 int arg2 ;
19416 wxBitmap *arg3 = 0 ;
19417 wxBitmap const &arg4_defvalue = wxNullBitmap ;
19418 wxBitmap *arg4 = (wxBitmap *) &arg4_defvalue ;
19419 bool result;
19420 PyObject * obj0 = 0 ;
19421 PyObject * obj1 = 0 ;
19422 PyObject * obj2 = 0 ;
19423 PyObject * obj3 = 0 ;
19424 char *kwnames[] = {
19425 (char *) "self",(char *) "index",(char *) "bitmap",(char *) "mask", NULL
19426 };
19427
19428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ImageList_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19430 if (SWIG_arg_fail(1)) SWIG_fail;
19431 {
19432 arg2 = (int)(SWIG_As_int(obj1));
19433 if (SWIG_arg_fail(2)) SWIG_fail;
19434 }
19435 {
19436 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19437 if (SWIG_arg_fail(3)) SWIG_fail;
19438 if (arg3 == NULL) {
19439 SWIG_null_ref("wxBitmap");
19440 }
19441 if (SWIG_arg_fail(3)) SWIG_fail;
19442 }
19443 if (obj3) {
19444 {
19445 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
19446 if (SWIG_arg_fail(4)) SWIG_fail;
19447 if (arg4 == NULL) {
19448 SWIG_null_ref("wxBitmap");
19449 }
19450 if (SWIG_arg_fail(4)) SWIG_fail;
19451 }
19452 }
19453 {
19454 PyThreadState* __tstate = wxPyBeginAllowThreads();
19455 result = (bool)(arg1)->Replace(arg2,(wxBitmap const &)*arg3,(wxBitmap const &)*arg4);
19456
19457 wxPyEndAllowThreads(__tstate);
19458 if (PyErr_Occurred()) SWIG_fail;
19459 }
19460 {
19461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19462 }
19463 return resultobj;
19464 fail:
19465 return NULL;
19466 }
19467
19468
19469 static PyObject *_wrap_ImageList_Draw(PyObject *, PyObject *args, PyObject *kwargs) {
19470 PyObject *resultobj;
19471 wxImageList *arg1 = (wxImageList *) 0 ;
19472 int arg2 ;
19473 wxDC *arg3 = 0 ;
19474 int arg4 ;
19475 int arg5 ;
19476 int arg6 = (int) wxIMAGELIST_DRAW_NORMAL ;
19477 bool arg7 = (bool) (bool)false ;
19478 bool result;
19479 PyObject * obj0 = 0 ;
19480 PyObject * obj1 = 0 ;
19481 PyObject * obj2 = 0 ;
19482 PyObject * obj3 = 0 ;
19483 PyObject * obj4 = 0 ;
19484 PyObject * obj5 = 0 ;
19485 PyObject * obj6 = 0 ;
19486 char *kwnames[] = {
19487 (char *) "self",(char *) "index",(char *) "dc",(char *) "x",(char *) "x",(char *) "flags",(char *) "solidBackground", NULL
19488 };
19489
19490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OO:ImageList_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19492 if (SWIG_arg_fail(1)) SWIG_fail;
19493 {
19494 arg2 = (int)(SWIG_As_int(obj1));
19495 if (SWIG_arg_fail(2)) SWIG_fail;
19496 }
19497 {
19498 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19499 if (SWIG_arg_fail(3)) SWIG_fail;
19500 if (arg3 == NULL) {
19501 SWIG_null_ref("wxDC");
19502 }
19503 if (SWIG_arg_fail(3)) SWIG_fail;
19504 }
19505 {
19506 arg4 = (int)(SWIG_As_int(obj3));
19507 if (SWIG_arg_fail(4)) SWIG_fail;
19508 }
19509 {
19510 arg5 = (int)(SWIG_As_int(obj4));
19511 if (SWIG_arg_fail(5)) SWIG_fail;
19512 }
19513 if (obj5) {
19514 {
19515 arg6 = (int)(SWIG_As_int(obj5));
19516 if (SWIG_arg_fail(6)) SWIG_fail;
19517 }
19518 }
19519 if (obj6) {
19520 {
19521 arg7 = (bool const)(SWIG_As_bool(obj6));
19522 if (SWIG_arg_fail(7)) SWIG_fail;
19523 }
19524 }
19525 {
19526 PyThreadState* __tstate = wxPyBeginAllowThreads();
19527 result = (bool)(arg1)->Draw(arg2,*arg3,arg4,arg5,arg6,arg7);
19528
19529 wxPyEndAllowThreads(__tstate);
19530 if (PyErr_Occurred()) SWIG_fail;
19531 }
19532 {
19533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19534 }
19535 return resultobj;
19536 fail:
19537 return NULL;
19538 }
19539
19540
19541 static PyObject *_wrap_ImageList_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
19542 PyObject *resultobj;
19543 wxImageList *arg1 = (wxImageList *) 0 ;
19544 int result;
19545 PyObject * obj0 = 0 ;
19546 char *kwnames[] = {
19547 (char *) "self", NULL
19548 };
19549
19550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_GetImageCount",kwnames,&obj0)) goto fail;
19551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19552 if (SWIG_arg_fail(1)) SWIG_fail;
19553 {
19554 PyThreadState* __tstate = wxPyBeginAllowThreads();
19555 result = (int)(arg1)->GetImageCount();
19556
19557 wxPyEndAllowThreads(__tstate);
19558 if (PyErr_Occurred()) SWIG_fail;
19559 }
19560 {
19561 resultobj = SWIG_From_int((int)(result));
19562 }
19563 return resultobj;
19564 fail:
19565 return NULL;
19566 }
19567
19568
19569 static PyObject *_wrap_ImageList_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
19570 PyObject *resultobj;
19571 wxImageList *arg1 = (wxImageList *) 0 ;
19572 int arg2 ;
19573 bool result;
19574 PyObject * obj0 = 0 ;
19575 PyObject * obj1 = 0 ;
19576 char *kwnames[] = {
19577 (char *) "self",(char *) "index", NULL
19578 };
19579
19580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_Remove",kwnames,&obj0,&obj1)) goto fail;
19581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19582 if (SWIG_arg_fail(1)) SWIG_fail;
19583 {
19584 arg2 = (int)(SWIG_As_int(obj1));
19585 if (SWIG_arg_fail(2)) SWIG_fail;
19586 }
19587 {
19588 PyThreadState* __tstate = wxPyBeginAllowThreads();
19589 result = (bool)(arg1)->Remove(arg2);
19590
19591 wxPyEndAllowThreads(__tstate);
19592 if (PyErr_Occurred()) SWIG_fail;
19593 }
19594 {
19595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19596 }
19597 return resultobj;
19598 fail:
19599 return NULL;
19600 }
19601
19602
19603 static PyObject *_wrap_ImageList_RemoveAll(PyObject *, PyObject *args, PyObject *kwargs) {
19604 PyObject *resultobj;
19605 wxImageList *arg1 = (wxImageList *) 0 ;
19606 bool result;
19607 PyObject * obj0 = 0 ;
19608 char *kwnames[] = {
19609 (char *) "self", NULL
19610 };
19611
19612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_RemoveAll",kwnames,&obj0)) goto fail;
19613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19614 if (SWIG_arg_fail(1)) SWIG_fail;
19615 {
19616 PyThreadState* __tstate = wxPyBeginAllowThreads();
19617 result = (bool)(arg1)->RemoveAll();
19618
19619 wxPyEndAllowThreads(__tstate);
19620 if (PyErr_Occurred()) SWIG_fail;
19621 }
19622 {
19623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19624 }
19625 return resultobj;
19626 fail:
19627 return NULL;
19628 }
19629
19630
19631 static PyObject *_wrap_ImageList_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19632 PyObject *resultobj;
19633 wxImageList *arg1 = (wxImageList *) 0 ;
19634 int arg2 ;
19635 int *arg3 = 0 ;
19636 int *arg4 = 0 ;
19637 int temp3 ;
19638 int res3 = 0 ;
19639 int temp4 ;
19640 int res4 = 0 ;
19641 PyObject * obj0 = 0 ;
19642 PyObject * obj1 = 0 ;
19643 char *kwnames[] = {
19644 (char *) "self",(char *) "index", NULL
19645 };
19646
19647 arg3 = &temp3; res3 = SWIG_NEWOBJ;
19648 arg4 = &temp4; res4 = SWIG_NEWOBJ;
19649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetSize",kwnames,&obj0,&obj1)) goto fail;
19650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
19651 if (SWIG_arg_fail(1)) SWIG_fail;
19652 {
19653 arg2 = (int)(SWIG_As_int(obj1));
19654 if (SWIG_arg_fail(2)) SWIG_fail;
19655 }
19656 {
19657 PyThreadState* __tstate = wxPyBeginAllowThreads();
19658 (arg1)->GetSize(arg2,*arg3,*arg4);
19659
19660 wxPyEndAllowThreads(__tstate);
19661 if (PyErr_Occurred()) SWIG_fail;
19662 }
19663 Py_INCREF(Py_None); resultobj = Py_None;
19664 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
19665 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
19666 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
19667 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
19668 return resultobj;
19669 fail:
19670 return NULL;
19671 }
19672
19673
19674 static PyObject * ImageList_swigregister(PyObject *, PyObject *args) {
19675 PyObject *obj;
19676 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19677 SWIG_TypeClientData(SWIGTYPE_p_wxImageList, obj);
19678 Py_INCREF(obj);
19679 return Py_BuildValue((char *)"");
19680 }
19681 static int _wrap_NORMAL_FONT_set(PyObject *) {
19682 PyErr_SetString(PyExc_TypeError,"Variable NORMAL_FONT is read-only.");
19683 return 1;
19684 }
19685
19686
19687 static PyObject *_wrap_NORMAL_FONT_get(void) {
19688 PyObject *pyobj;
19689
19690 pyobj = SWIG_NewPointerObj((void *)(wxNORMAL_FONT), SWIGTYPE_p_wxFont, 0);
19691 return pyobj;
19692 }
19693
19694
19695 static int _wrap_SMALL_FONT_set(PyObject *) {
19696 PyErr_SetString(PyExc_TypeError,"Variable SMALL_FONT is read-only.");
19697 return 1;
19698 }
19699
19700
19701 static PyObject *_wrap_SMALL_FONT_get(void) {
19702 PyObject *pyobj;
19703
19704 pyobj = SWIG_NewPointerObj((void *)(wxSMALL_FONT), SWIGTYPE_p_wxFont, 0);
19705 return pyobj;
19706 }
19707
19708
19709 static int _wrap_ITALIC_FONT_set(PyObject *) {
19710 PyErr_SetString(PyExc_TypeError,"Variable ITALIC_FONT is read-only.");
19711 return 1;
19712 }
19713
19714
19715 static PyObject *_wrap_ITALIC_FONT_get(void) {
19716 PyObject *pyobj;
19717
19718 pyobj = SWIG_NewPointerObj((void *)(wxITALIC_FONT), SWIGTYPE_p_wxFont, 0);
19719 return pyobj;
19720 }
19721
19722
19723 static int _wrap_SWISS_FONT_set(PyObject *) {
19724 PyErr_SetString(PyExc_TypeError,"Variable SWISS_FONT is read-only.");
19725 return 1;
19726 }
19727
19728
19729 static PyObject *_wrap_SWISS_FONT_get(void) {
19730 PyObject *pyobj;
19731
19732 pyobj = SWIG_NewPointerObj((void *)(wxSWISS_FONT), SWIGTYPE_p_wxFont, 0);
19733 return pyobj;
19734 }
19735
19736
19737 static int _wrap_RED_PEN_set(PyObject *) {
19738 PyErr_SetString(PyExc_TypeError,"Variable RED_PEN is read-only.");
19739 return 1;
19740 }
19741
19742
19743 static PyObject *_wrap_RED_PEN_get(void) {
19744 PyObject *pyobj;
19745
19746 pyobj = SWIG_NewPointerObj((void *)(wxRED_PEN), SWIGTYPE_p_wxPen, 0);
19747 return pyobj;
19748 }
19749
19750
19751 static int _wrap_CYAN_PEN_set(PyObject *) {
19752 PyErr_SetString(PyExc_TypeError,"Variable CYAN_PEN is read-only.");
19753 return 1;
19754 }
19755
19756
19757 static PyObject *_wrap_CYAN_PEN_get(void) {
19758 PyObject *pyobj;
19759
19760 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_PEN), SWIGTYPE_p_wxPen, 0);
19761 return pyobj;
19762 }
19763
19764
19765 static int _wrap_GREEN_PEN_set(PyObject *) {
19766 PyErr_SetString(PyExc_TypeError,"Variable GREEN_PEN is read-only.");
19767 return 1;
19768 }
19769
19770
19771 static PyObject *_wrap_GREEN_PEN_get(void) {
19772 PyObject *pyobj;
19773
19774 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_PEN), SWIGTYPE_p_wxPen, 0);
19775 return pyobj;
19776 }
19777
19778
19779 static int _wrap_BLACK_PEN_set(PyObject *) {
19780 PyErr_SetString(PyExc_TypeError,"Variable BLACK_PEN is read-only.");
19781 return 1;
19782 }
19783
19784
19785 static PyObject *_wrap_BLACK_PEN_get(void) {
19786 PyObject *pyobj;
19787
19788 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_PEN), SWIGTYPE_p_wxPen, 0);
19789 return pyobj;
19790 }
19791
19792
19793 static int _wrap_WHITE_PEN_set(PyObject *) {
19794 PyErr_SetString(PyExc_TypeError,"Variable WHITE_PEN is read-only.");
19795 return 1;
19796 }
19797
19798
19799 static PyObject *_wrap_WHITE_PEN_get(void) {
19800 PyObject *pyobj;
19801
19802 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_PEN), SWIGTYPE_p_wxPen, 0);
19803 return pyobj;
19804 }
19805
19806
19807 static int _wrap_TRANSPARENT_PEN_set(PyObject *) {
19808 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_PEN is read-only.");
19809 return 1;
19810 }
19811
19812
19813 static PyObject *_wrap_TRANSPARENT_PEN_get(void) {
19814 PyObject *pyobj;
19815
19816 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_PEN), SWIGTYPE_p_wxPen, 0);
19817 return pyobj;
19818 }
19819
19820
19821 static int _wrap_BLACK_DASHED_PEN_set(PyObject *) {
19822 PyErr_SetString(PyExc_TypeError,"Variable BLACK_DASHED_PEN is read-only.");
19823 return 1;
19824 }
19825
19826
19827 static PyObject *_wrap_BLACK_DASHED_PEN_get(void) {
19828 PyObject *pyobj;
19829
19830 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_DASHED_PEN), SWIGTYPE_p_wxPen, 0);
19831 return pyobj;
19832 }
19833
19834
19835 static int _wrap_GREY_PEN_set(PyObject *) {
19836 PyErr_SetString(PyExc_TypeError,"Variable GREY_PEN is read-only.");
19837 return 1;
19838 }
19839
19840
19841 static PyObject *_wrap_GREY_PEN_get(void) {
19842 PyObject *pyobj;
19843
19844 pyobj = SWIG_NewPointerObj((void *)(wxGREY_PEN), SWIGTYPE_p_wxPen, 0);
19845 return pyobj;
19846 }
19847
19848
19849 static int _wrap_MEDIUM_GREY_PEN_set(PyObject *) {
19850 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_PEN is read-only.");
19851 return 1;
19852 }
19853
19854
19855 static PyObject *_wrap_MEDIUM_GREY_PEN_get(void) {
19856 PyObject *pyobj;
19857
19858 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_PEN), SWIGTYPE_p_wxPen, 0);
19859 return pyobj;
19860 }
19861
19862
19863 static int _wrap_LIGHT_GREY_PEN_set(PyObject *) {
19864 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_PEN is read-only.");
19865 return 1;
19866 }
19867
19868
19869 static PyObject *_wrap_LIGHT_GREY_PEN_get(void) {
19870 PyObject *pyobj;
19871
19872 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_PEN), SWIGTYPE_p_wxPen, 0);
19873 return pyobj;
19874 }
19875
19876
19877 static int _wrap_BLUE_BRUSH_set(PyObject *) {
19878 PyErr_SetString(PyExc_TypeError,"Variable BLUE_BRUSH is read-only.");
19879 return 1;
19880 }
19881
19882
19883 static PyObject *_wrap_BLUE_BRUSH_get(void) {
19884 PyObject *pyobj;
19885
19886 pyobj = SWIG_NewPointerObj((void *)(wxBLUE_BRUSH), SWIGTYPE_p_wxBrush, 0);
19887 return pyobj;
19888 }
19889
19890
19891 static int _wrap_GREEN_BRUSH_set(PyObject *) {
19892 PyErr_SetString(PyExc_TypeError,"Variable GREEN_BRUSH is read-only.");
19893 return 1;
19894 }
19895
19896
19897 static PyObject *_wrap_GREEN_BRUSH_get(void) {
19898 PyObject *pyobj;
19899
19900 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_BRUSH), SWIGTYPE_p_wxBrush, 0);
19901 return pyobj;
19902 }
19903
19904
19905 static int _wrap_WHITE_BRUSH_set(PyObject *) {
19906 PyErr_SetString(PyExc_TypeError,"Variable WHITE_BRUSH is read-only.");
19907 return 1;
19908 }
19909
19910
19911 static PyObject *_wrap_WHITE_BRUSH_get(void) {
19912 PyObject *pyobj;
19913
19914 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_BRUSH), SWIGTYPE_p_wxBrush, 0);
19915 return pyobj;
19916 }
19917
19918
19919 static int _wrap_BLACK_BRUSH_set(PyObject *) {
19920 PyErr_SetString(PyExc_TypeError,"Variable BLACK_BRUSH is read-only.");
19921 return 1;
19922 }
19923
19924
19925 static PyObject *_wrap_BLACK_BRUSH_get(void) {
19926 PyObject *pyobj;
19927
19928 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_BRUSH), SWIGTYPE_p_wxBrush, 0);
19929 return pyobj;
19930 }
19931
19932
19933 static int _wrap_TRANSPARENT_BRUSH_set(PyObject *) {
19934 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_BRUSH is read-only.");
19935 return 1;
19936 }
19937
19938
19939 static PyObject *_wrap_TRANSPARENT_BRUSH_get(void) {
19940 PyObject *pyobj;
19941
19942 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_BRUSH), SWIGTYPE_p_wxBrush, 0);
19943 return pyobj;
19944 }
19945
19946
19947 static int _wrap_CYAN_BRUSH_set(PyObject *) {
19948 PyErr_SetString(PyExc_TypeError,"Variable CYAN_BRUSH is read-only.");
19949 return 1;
19950 }
19951
19952
19953 static PyObject *_wrap_CYAN_BRUSH_get(void) {
19954 PyObject *pyobj;
19955
19956 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_BRUSH), SWIGTYPE_p_wxBrush, 0);
19957 return pyobj;
19958 }
19959
19960
19961 static int _wrap_RED_BRUSH_set(PyObject *) {
19962 PyErr_SetString(PyExc_TypeError,"Variable RED_BRUSH is read-only.");
19963 return 1;
19964 }
19965
19966
19967 static PyObject *_wrap_RED_BRUSH_get(void) {
19968 PyObject *pyobj;
19969
19970 pyobj = SWIG_NewPointerObj((void *)(wxRED_BRUSH), SWIGTYPE_p_wxBrush, 0);
19971 return pyobj;
19972 }
19973
19974
19975 static int _wrap_GREY_BRUSH_set(PyObject *) {
19976 PyErr_SetString(PyExc_TypeError,"Variable GREY_BRUSH is read-only.");
19977 return 1;
19978 }
19979
19980
19981 static PyObject *_wrap_GREY_BRUSH_get(void) {
19982 PyObject *pyobj;
19983
19984 pyobj = SWIG_NewPointerObj((void *)(wxGREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19985 return pyobj;
19986 }
19987
19988
19989 static int _wrap_MEDIUM_GREY_BRUSH_set(PyObject *) {
19990 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_BRUSH is read-only.");
19991 return 1;
19992 }
19993
19994
19995 static PyObject *_wrap_MEDIUM_GREY_BRUSH_get(void) {
19996 PyObject *pyobj;
19997
19998 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19999 return pyobj;
20000 }
20001
20002
20003 static int _wrap_LIGHT_GREY_BRUSH_set(PyObject *) {
20004 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_BRUSH is read-only.");
20005 return 1;
20006 }
20007
20008
20009 static PyObject *_wrap_LIGHT_GREY_BRUSH_get(void) {
20010 PyObject *pyobj;
20011
20012 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
20013 return pyobj;
20014 }
20015
20016
20017 static int _wrap_BLACK_set(PyObject *) {
20018 PyErr_SetString(PyExc_TypeError,"Variable BLACK is read-only.");
20019 return 1;
20020 }
20021
20022
20023 static PyObject *_wrap_BLACK_get(void) {
20024 PyObject *pyobj;
20025
20026 pyobj = SWIG_NewPointerObj((void *)(wxBLACK), SWIGTYPE_p_wxColour, 0);
20027 return pyobj;
20028 }
20029
20030
20031 static int _wrap_WHITE_set(PyObject *) {
20032 PyErr_SetString(PyExc_TypeError,"Variable WHITE is read-only.");
20033 return 1;
20034 }
20035
20036
20037 static PyObject *_wrap_WHITE_get(void) {
20038 PyObject *pyobj;
20039
20040 pyobj = SWIG_NewPointerObj((void *)(wxWHITE), SWIGTYPE_p_wxColour, 0);
20041 return pyobj;
20042 }
20043
20044
20045 static int _wrap_RED_set(PyObject *) {
20046 PyErr_SetString(PyExc_TypeError,"Variable RED is read-only.");
20047 return 1;
20048 }
20049
20050
20051 static PyObject *_wrap_RED_get(void) {
20052 PyObject *pyobj;
20053
20054 pyobj = SWIG_NewPointerObj((void *)(wxRED), SWIGTYPE_p_wxColour, 0);
20055 return pyobj;
20056 }
20057
20058
20059 static int _wrap_BLUE_set(PyObject *) {
20060 PyErr_SetString(PyExc_TypeError,"Variable BLUE is read-only.");
20061 return 1;
20062 }
20063
20064
20065 static PyObject *_wrap_BLUE_get(void) {
20066 PyObject *pyobj;
20067
20068 pyobj = SWIG_NewPointerObj((void *)(wxBLUE), SWIGTYPE_p_wxColour, 0);
20069 return pyobj;
20070 }
20071
20072
20073 static int _wrap_GREEN_set(PyObject *) {
20074 PyErr_SetString(PyExc_TypeError,"Variable GREEN is read-only.");
20075 return 1;
20076 }
20077
20078
20079 static PyObject *_wrap_GREEN_get(void) {
20080 PyObject *pyobj;
20081
20082 pyobj = SWIG_NewPointerObj((void *)(wxGREEN), SWIGTYPE_p_wxColour, 0);
20083 return pyobj;
20084 }
20085
20086
20087 static int _wrap_CYAN_set(PyObject *) {
20088 PyErr_SetString(PyExc_TypeError,"Variable CYAN is read-only.");
20089 return 1;
20090 }
20091
20092
20093 static PyObject *_wrap_CYAN_get(void) {
20094 PyObject *pyobj;
20095
20096 pyobj = SWIG_NewPointerObj((void *)(wxCYAN), SWIGTYPE_p_wxColour, 0);
20097 return pyobj;
20098 }
20099
20100
20101 static int _wrap_LIGHT_GREY_set(PyObject *) {
20102 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY is read-only.");
20103 return 1;
20104 }
20105
20106
20107 static PyObject *_wrap_LIGHT_GREY_get(void) {
20108 PyObject *pyobj;
20109
20110 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY), SWIGTYPE_p_wxColour, 0);
20111 return pyobj;
20112 }
20113
20114
20115 static int _wrap_STANDARD_CURSOR_set(PyObject *) {
20116 PyErr_SetString(PyExc_TypeError,"Variable STANDARD_CURSOR is read-only.");
20117 return 1;
20118 }
20119
20120
20121 static PyObject *_wrap_STANDARD_CURSOR_get(void) {
20122 PyObject *pyobj;
20123
20124 pyobj = SWIG_NewPointerObj((void *)(wxSTANDARD_CURSOR), SWIGTYPE_p_wxCursor, 0);
20125 return pyobj;
20126 }
20127
20128
20129 static int _wrap_HOURGLASS_CURSOR_set(PyObject *) {
20130 PyErr_SetString(PyExc_TypeError,"Variable HOURGLASS_CURSOR is read-only.");
20131 return 1;
20132 }
20133
20134
20135 static PyObject *_wrap_HOURGLASS_CURSOR_get(void) {
20136 PyObject *pyobj;
20137
20138 pyobj = SWIG_NewPointerObj((void *)(wxHOURGLASS_CURSOR), SWIGTYPE_p_wxCursor, 0);
20139 return pyobj;
20140 }
20141
20142
20143 static int _wrap_CROSS_CURSOR_set(PyObject *) {
20144 PyErr_SetString(PyExc_TypeError,"Variable CROSS_CURSOR is read-only.");
20145 return 1;
20146 }
20147
20148
20149 static PyObject *_wrap_CROSS_CURSOR_get(void) {
20150 PyObject *pyobj;
20151
20152 pyobj = SWIG_NewPointerObj((void *)(wxCROSS_CURSOR), SWIGTYPE_p_wxCursor, 0);
20153 return pyobj;
20154 }
20155
20156
20157 static int _wrap_NullBitmap_set(PyObject *) {
20158 PyErr_SetString(PyExc_TypeError,"Variable NullBitmap is read-only.");
20159 return 1;
20160 }
20161
20162
20163 static PyObject *_wrap_NullBitmap_get(void) {
20164 PyObject *pyobj;
20165
20166 pyobj = SWIG_NewPointerObj((void *)(&wxNullBitmap), SWIGTYPE_p_wxBitmap, 0);
20167 return pyobj;
20168 }
20169
20170
20171 static int _wrap_NullIcon_set(PyObject *) {
20172 PyErr_SetString(PyExc_TypeError,"Variable NullIcon is read-only.");
20173 return 1;
20174 }
20175
20176
20177 static PyObject *_wrap_NullIcon_get(void) {
20178 PyObject *pyobj;
20179
20180 pyobj = SWIG_NewPointerObj((void *)(&wxNullIcon), SWIGTYPE_p_wxIcon, 0);
20181 return pyobj;
20182 }
20183
20184
20185 static int _wrap_NullCursor_set(PyObject *) {
20186 PyErr_SetString(PyExc_TypeError,"Variable NullCursor is read-only.");
20187 return 1;
20188 }
20189
20190
20191 static PyObject *_wrap_NullCursor_get(void) {
20192 PyObject *pyobj;
20193
20194 pyobj = SWIG_NewPointerObj((void *)(&wxNullCursor), SWIGTYPE_p_wxCursor, 0);
20195 return pyobj;
20196 }
20197
20198
20199 static int _wrap_NullPen_set(PyObject *) {
20200 PyErr_SetString(PyExc_TypeError,"Variable NullPen is read-only.");
20201 return 1;
20202 }
20203
20204
20205 static PyObject *_wrap_NullPen_get(void) {
20206 PyObject *pyobj;
20207
20208 pyobj = SWIG_NewPointerObj((void *)(&wxNullPen), SWIGTYPE_p_wxPen, 0);
20209 return pyobj;
20210 }
20211
20212
20213 static int _wrap_NullBrush_set(PyObject *) {
20214 PyErr_SetString(PyExc_TypeError,"Variable NullBrush is read-only.");
20215 return 1;
20216 }
20217
20218
20219 static PyObject *_wrap_NullBrush_get(void) {
20220 PyObject *pyobj;
20221
20222 pyobj = SWIG_NewPointerObj((void *)(&wxNullBrush), SWIGTYPE_p_wxBrush, 0);
20223 return pyobj;
20224 }
20225
20226
20227 static int _wrap_NullPalette_set(PyObject *) {
20228 PyErr_SetString(PyExc_TypeError,"Variable NullPalette is read-only.");
20229 return 1;
20230 }
20231
20232
20233 static PyObject *_wrap_NullPalette_get(void) {
20234 PyObject *pyobj;
20235
20236 pyobj = SWIG_NewPointerObj((void *)(&wxNullPalette), SWIGTYPE_p_wxPalette, 0);
20237 return pyobj;
20238 }
20239
20240
20241 static int _wrap_NullFont_set(PyObject *) {
20242 PyErr_SetString(PyExc_TypeError,"Variable NullFont is read-only.");
20243 return 1;
20244 }
20245
20246
20247 static PyObject *_wrap_NullFont_get(void) {
20248 PyObject *pyobj;
20249
20250 pyobj = SWIG_NewPointerObj((void *)(&wxNullFont), SWIGTYPE_p_wxFont, 0);
20251 return pyobj;
20252 }
20253
20254
20255 static int _wrap_NullColour_set(PyObject *) {
20256 PyErr_SetString(PyExc_TypeError,"Variable NullColour is read-only.");
20257 return 1;
20258 }
20259
20260
20261 static PyObject *_wrap_NullColour_get(void) {
20262 PyObject *pyobj;
20263
20264 pyobj = SWIG_NewPointerObj((void *)(&wxNullColour), SWIGTYPE_p_wxColour, 0);
20265 return pyobj;
20266 }
20267
20268
20269 static PyObject *_wrap_PenList_AddPen(PyObject *, PyObject *args, PyObject *kwargs) {
20270 PyObject *resultobj;
20271 wxPenList *arg1 = (wxPenList *) 0 ;
20272 wxPen *arg2 = (wxPen *) 0 ;
20273 PyObject * obj0 = 0 ;
20274 PyObject * obj1 = 0 ;
20275 char *kwnames[] = {
20276 (char *) "self",(char *) "pen", NULL
20277 };
20278
20279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_AddPen",kwnames,&obj0,&obj1)) goto fail;
20280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
20281 if (SWIG_arg_fail(1)) SWIG_fail;
20282 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
20283 if (SWIG_arg_fail(2)) SWIG_fail;
20284 {
20285 PyThreadState* __tstate = wxPyBeginAllowThreads();
20286 (arg1)->AddPen(arg2);
20287
20288 wxPyEndAllowThreads(__tstate);
20289 if (PyErr_Occurred()) SWIG_fail;
20290 }
20291 Py_INCREF(Py_None); resultobj = Py_None;
20292 return resultobj;
20293 fail:
20294 return NULL;
20295 }
20296
20297
20298 static PyObject *_wrap_PenList_FindOrCreatePen(PyObject *, PyObject *args, PyObject *kwargs) {
20299 PyObject *resultobj;
20300 wxPenList *arg1 = (wxPenList *) 0 ;
20301 wxColour *arg2 = 0 ;
20302 int arg3 ;
20303 int arg4 ;
20304 wxPen *result;
20305 wxColour temp2 ;
20306 PyObject * obj0 = 0 ;
20307 PyObject * obj1 = 0 ;
20308 PyObject * obj2 = 0 ;
20309 PyObject * obj3 = 0 ;
20310 char *kwnames[] = {
20311 (char *) "self",(char *) "colour",(char *) "width",(char *) "style", NULL
20312 };
20313
20314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PenList_FindOrCreatePen",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
20316 if (SWIG_arg_fail(1)) SWIG_fail;
20317 {
20318 arg2 = &temp2;
20319 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20320 }
20321 {
20322 arg3 = (int)(SWIG_As_int(obj2));
20323 if (SWIG_arg_fail(3)) SWIG_fail;
20324 }
20325 {
20326 arg4 = (int)(SWIG_As_int(obj3));
20327 if (SWIG_arg_fail(4)) SWIG_fail;
20328 }
20329 {
20330 PyThreadState* __tstate = wxPyBeginAllowThreads();
20331 result = (wxPen *)(arg1)->FindOrCreatePen((wxColour const &)*arg2,arg3,arg4);
20332
20333 wxPyEndAllowThreads(__tstate);
20334 if (PyErr_Occurred()) SWIG_fail;
20335 }
20336 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 0);
20337 return resultobj;
20338 fail:
20339 return NULL;
20340 }
20341
20342
20343 static PyObject *_wrap_PenList_RemovePen(PyObject *, PyObject *args, PyObject *kwargs) {
20344 PyObject *resultobj;
20345 wxPenList *arg1 = (wxPenList *) 0 ;
20346 wxPen *arg2 = (wxPen *) 0 ;
20347 PyObject * obj0 = 0 ;
20348 PyObject * obj1 = 0 ;
20349 char *kwnames[] = {
20350 (char *) "self",(char *) "pen", NULL
20351 };
20352
20353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_RemovePen",kwnames,&obj0,&obj1)) goto fail;
20354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
20355 if (SWIG_arg_fail(1)) SWIG_fail;
20356 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
20357 if (SWIG_arg_fail(2)) SWIG_fail;
20358 {
20359 PyThreadState* __tstate = wxPyBeginAllowThreads();
20360 (arg1)->RemovePen(arg2);
20361
20362 wxPyEndAllowThreads(__tstate);
20363 if (PyErr_Occurred()) SWIG_fail;
20364 }
20365 Py_INCREF(Py_None); resultobj = Py_None;
20366 return resultobj;
20367 fail:
20368 return NULL;
20369 }
20370
20371
20372 static PyObject *_wrap_PenList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
20373 PyObject *resultobj;
20374 wxPenList *arg1 = (wxPenList *) 0 ;
20375 int result;
20376 PyObject * obj0 = 0 ;
20377 char *kwnames[] = {
20378 (char *) "self", NULL
20379 };
20380
20381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PenList_GetCount",kwnames,&obj0)) goto fail;
20382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
20383 if (SWIG_arg_fail(1)) SWIG_fail;
20384 {
20385 PyThreadState* __tstate = wxPyBeginAllowThreads();
20386 result = (int)(arg1)->GetCount();
20387
20388 wxPyEndAllowThreads(__tstate);
20389 if (PyErr_Occurred()) SWIG_fail;
20390 }
20391 {
20392 resultobj = SWIG_From_int((int)(result));
20393 }
20394 return resultobj;
20395 fail:
20396 return NULL;
20397 }
20398
20399
20400 static PyObject * PenList_swigregister(PyObject *, PyObject *args) {
20401 PyObject *obj;
20402 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20403 SWIG_TypeClientData(SWIGTYPE_p_wxPenList, obj);
20404 Py_INCREF(obj);
20405 return Py_BuildValue((char *)"");
20406 }
20407 static PyObject *_wrap_BrushList_AddBrush(PyObject *, PyObject *args, PyObject *kwargs) {
20408 PyObject *resultobj;
20409 wxBrushList *arg1 = (wxBrushList *) 0 ;
20410 wxBrush *arg2 = (wxBrush *) 0 ;
20411 PyObject * obj0 = 0 ;
20412 PyObject * obj1 = 0 ;
20413 char *kwnames[] = {
20414 (char *) "self",(char *) "brush", NULL
20415 };
20416
20417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_AddBrush",kwnames,&obj0,&obj1)) goto fail;
20418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
20419 if (SWIG_arg_fail(1)) SWIG_fail;
20420 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
20421 if (SWIG_arg_fail(2)) SWIG_fail;
20422 {
20423 PyThreadState* __tstate = wxPyBeginAllowThreads();
20424 (arg1)->AddBrush(arg2);
20425
20426 wxPyEndAllowThreads(__tstate);
20427 if (PyErr_Occurred()) SWIG_fail;
20428 }
20429 Py_INCREF(Py_None); resultobj = Py_None;
20430 return resultobj;
20431 fail:
20432 return NULL;
20433 }
20434
20435
20436 static PyObject *_wrap_BrushList_FindOrCreateBrush(PyObject *, PyObject *args, PyObject *kwargs) {
20437 PyObject *resultobj;
20438 wxBrushList *arg1 = (wxBrushList *) 0 ;
20439 wxColour *arg2 = 0 ;
20440 int arg3 = (int) wxSOLID ;
20441 wxBrush *result;
20442 wxColour temp2 ;
20443 PyObject * obj0 = 0 ;
20444 PyObject * obj1 = 0 ;
20445 PyObject * obj2 = 0 ;
20446 char *kwnames[] = {
20447 (char *) "self",(char *) "colour",(char *) "style", NULL
20448 };
20449
20450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:BrushList_FindOrCreateBrush",kwnames,&obj0,&obj1,&obj2)) goto fail;
20451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
20452 if (SWIG_arg_fail(1)) SWIG_fail;
20453 {
20454 arg2 = &temp2;
20455 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20456 }
20457 if (obj2) {
20458 {
20459 arg3 = (int)(SWIG_As_int(obj2));
20460 if (SWIG_arg_fail(3)) SWIG_fail;
20461 }
20462 }
20463 {
20464 PyThreadState* __tstate = wxPyBeginAllowThreads();
20465 result = (wxBrush *)(arg1)->FindOrCreateBrush((wxColour const &)*arg2,arg3);
20466
20467 wxPyEndAllowThreads(__tstate);
20468 if (PyErr_Occurred()) SWIG_fail;
20469 }
20470 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 0);
20471 return resultobj;
20472 fail:
20473 return NULL;
20474 }
20475
20476
20477 static PyObject *_wrap_BrushList_RemoveBrush(PyObject *, PyObject *args, PyObject *kwargs) {
20478 PyObject *resultobj;
20479 wxBrushList *arg1 = (wxBrushList *) 0 ;
20480 wxBrush *arg2 = (wxBrush *) 0 ;
20481 PyObject * obj0 = 0 ;
20482 PyObject * obj1 = 0 ;
20483 char *kwnames[] = {
20484 (char *) "self",(char *) "brush", NULL
20485 };
20486
20487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_RemoveBrush",kwnames,&obj0,&obj1)) goto fail;
20488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
20489 if (SWIG_arg_fail(1)) SWIG_fail;
20490 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
20491 if (SWIG_arg_fail(2)) SWIG_fail;
20492 {
20493 PyThreadState* __tstate = wxPyBeginAllowThreads();
20494 (arg1)->RemoveBrush(arg2);
20495
20496 wxPyEndAllowThreads(__tstate);
20497 if (PyErr_Occurred()) SWIG_fail;
20498 }
20499 Py_INCREF(Py_None); resultobj = Py_None;
20500 return resultobj;
20501 fail:
20502 return NULL;
20503 }
20504
20505
20506 static PyObject *_wrap_BrushList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
20507 PyObject *resultobj;
20508 wxBrushList *arg1 = (wxBrushList *) 0 ;
20509 int result;
20510 PyObject * obj0 = 0 ;
20511 char *kwnames[] = {
20512 (char *) "self", NULL
20513 };
20514
20515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BrushList_GetCount",kwnames,&obj0)) goto fail;
20516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
20517 if (SWIG_arg_fail(1)) SWIG_fail;
20518 {
20519 PyThreadState* __tstate = wxPyBeginAllowThreads();
20520 result = (int)(arg1)->GetCount();
20521
20522 wxPyEndAllowThreads(__tstate);
20523 if (PyErr_Occurred()) SWIG_fail;
20524 }
20525 {
20526 resultobj = SWIG_From_int((int)(result));
20527 }
20528 return resultobj;
20529 fail:
20530 return NULL;
20531 }
20532
20533
20534 static PyObject * BrushList_swigregister(PyObject *, PyObject *args) {
20535 PyObject *obj;
20536 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20537 SWIG_TypeClientData(SWIGTYPE_p_wxBrushList, obj);
20538 Py_INCREF(obj);
20539 return Py_BuildValue((char *)"");
20540 }
20541 static PyObject *_wrap_new_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
20542 PyObject *resultobj;
20543 wxColourDatabase *result;
20544 char *kwnames[] = {
20545 NULL
20546 };
20547
20548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ColourDatabase",kwnames)) goto fail;
20549 {
20550 if (!wxPyCheckForApp()) SWIG_fail;
20551 PyThreadState* __tstate = wxPyBeginAllowThreads();
20552 result = (wxColourDatabase *)new wxColourDatabase();
20553
20554 wxPyEndAllowThreads(__tstate);
20555 if (PyErr_Occurred()) SWIG_fail;
20556 }
20557 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColourDatabase, 1);
20558 return resultobj;
20559 fail:
20560 return NULL;
20561 }
20562
20563
20564 static PyObject *_wrap_delete_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
20565 PyObject *resultobj;
20566 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20567 PyObject * obj0 = 0 ;
20568 char *kwnames[] = {
20569 (char *) "self", NULL
20570 };
20571
20572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ColourDatabase",kwnames,&obj0)) goto fail;
20573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20574 if (SWIG_arg_fail(1)) SWIG_fail;
20575 {
20576 PyThreadState* __tstate = wxPyBeginAllowThreads();
20577 delete arg1;
20578
20579 wxPyEndAllowThreads(__tstate);
20580 if (PyErr_Occurred()) SWIG_fail;
20581 }
20582 Py_INCREF(Py_None); resultobj = Py_None;
20583 return resultobj;
20584 fail:
20585 return NULL;
20586 }
20587
20588
20589 static PyObject *_wrap_ColourDatabase_Find(PyObject *, PyObject *args, PyObject *kwargs) {
20590 PyObject *resultobj;
20591 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20592 wxString *arg2 = 0 ;
20593 wxColour result;
20594 bool temp2 = false ;
20595 PyObject * obj0 = 0 ;
20596 PyObject * obj1 = 0 ;
20597 char *kwnames[] = {
20598 (char *) "self",(char *) "name", NULL
20599 };
20600
20601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_Find",kwnames,&obj0,&obj1)) goto fail;
20602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20603 if (SWIG_arg_fail(1)) SWIG_fail;
20604 {
20605 arg2 = wxString_in_helper(obj1);
20606 if (arg2 == NULL) SWIG_fail;
20607 temp2 = true;
20608 }
20609 {
20610 PyThreadState* __tstate = wxPyBeginAllowThreads();
20611 result = ((wxColourDatabase const *)arg1)->Find((wxString const &)*arg2);
20612
20613 wxPyEndAllowThreads(__tstate);
20614 if (PyErr_Occurred()) SWIG_fail;
20615 }
20616 {
20617 wxColour * resultptr;
20618 resultptr = new wxColour((wxColour &)(result));
20619 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20620 }
20621 {
20622 if (temp2)
20623 delete arg2;
20624 }
20625 return resultobj;
20626 fail:
20627 {
20628 if (temp2)
20629 delete arg2;
20630 }
20631 return NULL;
20632 }
20633
20634
20635 static PyObject *_wrap_ColourDatabase_FindName(PyObject *, PyObject *args, PyObject *kwargs) {
20636 PyObject *resultobj;
20637 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20638 wxColour *arg2 = 0 ;
20639 wxString result;
20640 wxColour temp2 ;
20641 PyObject * obj0 = 0 ;
20642 PyObject * obj1 = 0 ;
20643 char *kwnames[] = {
20644 (char *) "self",(char *) "colour", NULL
20645 };
20646
20647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_FindName",kwnames,&obj0,&obj1)) goto fail;
20648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20649 if (SWIG_arg_fail(1)) SWIG_fail;
20650 {
20651 arg2 = &temp2;
20652 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20653 }
20654 {
20655 PyThreadState* __tstate = wxPyBeginAllowThreads();
20656 result = ((wxColourDatabase const *)arg1)->FindName((wxColour const &)*arg2);
20657
20658 wxPyEndAllowThreads(__tstate);
20659 if (PyErr_Occurred()) SWIG_fail;
20660 }
20661 {
20662 #if wxUSE_UNICODE
20663 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20664 #else
20665 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20666 #endif
20667 }
20668 return resultobj;
20669 fail:
20670 return NULL;
20671 }
20672
20673
20674 static PyObject *_wrap_ColourDatabase_AddColour(PyObject *, PyObject *args, PyObject *kwargs) {
20675 PyObject *resultobj;
20676 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20677 wxString *arg2 = 0 ;
20678 wxColour *arg3 = 0 ;
20679 bool temp2 = false ;
20680 wxColour temp3 ;
20681 PyObject * obj0 = 0 ;
20682 PyObject * obj1 = 0 ;
20683 PyObject * obj2 = 0 ;
20684 char *kwnames[] = {
20685 (char *) "self",(char *) "name",(char *) "colour", NULL
20686 };
20687
20688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ColourDatabase_AddColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
20689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20690 if (SWIG_arg_fail(1)) SWIG_fail;
20691 {
20692 arg2 = wxString_in_helper(obj1);
20693 if (arg2 == NULL) SWIG_fail;
20694 temp2 = true;
20695 }
20696 {
20697 arg3 = &temp3;
20698 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
20699 }
20700 {
20701 PyThreadState* __tstate = wxPyBeginAllowThreads();
20702 (arg1)->AddColour((wxString const &)*arg2,(wxColour const &)*arg3);
20703
20704 wxPyEndAllowThreads(__tstate);
20705 if (PyErr_Occurred()) SWIG_fail;
20706 }
20707 Py_INCREF(Py_None); resultobj = Py_None;
20708 {
20709 if (temp2)
20710 delete arg2;
20711 }
20712 return resultobj;
20713 fail:
20714 {
20715 if (temp2)
20716 delete arg2;
20717 }
20718 return NULL;
20719 }
20720
20721
20722 static PyObject *_wrap_ColourDatabase_Append(PyObject *, PyObject *args, PyObject *kwargs) {
20723 PyObject *resultobj;
20724 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
20725 wxString *arg2 = 0 ;
20726 int arg3 ;
20727 int arg4 ;
20728 int arg5 ;
20729 bool temp2 = false ;
20730 PyObject * obj0 = 0 ;
20731 PyObject * obj1 = 0 ;
20732 PyObject * obj2 = 0 ;
20733 PyObject * obj3 = 0 ;
20734 PyObject * obj4 = 0 ;
20735 char *kwnames[] = {
20736 (char *) "self",(char *) "name",(char *) "red",(char *) "green",(char *) "blue", NULL
20737 };
20738
20739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:ColourDatabase_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
20741 if (SWIG_arg_fail(1)) SWIG_fail;
20742 {
20743 arg2 = wxString_in_helper(obj1);
20744 if (arg2 == NULL) SWIG_fail;
20745 temp2 = true;
20746 }
20747 {
20748 arg3 = (int)(SWIG_As_int(obj2));
20749 if (SWIG_arg_fail(3)) SWIG_fail;
20750 }
20751 {
20752 arg4 = (int)(SWIG_As_int(obj3));
20753 if (SWIG_arg_fail(4)) SWIG_fail;
20754 }
20755 {
20756 arg5 = (int)(SWIG_As_int(obj4));
20757 if (SWIG_arg_fail(5)) SWIG_fail;
20758 }
20759 {
20760 PyThreadState* __tstate = wxPyBeginAllowThreads();
20761 wxColourDatabase_Append(arg1,(wxString const &)*arg2,arg3,arg4,arg5);
20762
20763 wxPyEndAllowThreads(__tstate);
20764 if (PyErr_Occurred()) SWIG_fail;
20765 }
20766 Py_INCREF(Py_None); resultobj = Py_None;
20767 {
20768 if (temp2)
20769 delete arg2;
20770 }
20771 return resultobj;
20772 fail:
20773 {
20774 if (temp2)
20775 delete arg2;
20776 }
20777 return NULL;
20778 }
20779
20780
20781 static PyObject * ColourDatabase_swigregister(PyObject *, PyObject *args) {
20782 PyObject *obj;
20783 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20784 SWIG_TypeClientData(SWIGTYPE_p_wxColourDatabase, obj);
20785 Py_INCREF(obj);
20786 return Py_BuildValue((char *)"");
20787 }
20788 static PyObject *_wrap_FontList_AddFont(PyObject *, PyObject *args, PyObject *kwargs) {
20789 PyObject *resultobj;
20790 wxFontList *arg1 = (wxFontList *) 0 ;
20791 wxFont *arg2 = (wxFont *) 0 ;
20792 PyObject * obj0 = 0 ;
20793 PyObject * obj1 = 0 ;
20794 char *kwnames[] = {
20795 (char *) "self",(char *) "font", NULL
20796 };
20797
20798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_AddFont",kwnames,&obj0,&obj1)) goto fail;
20799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20800 if (SWIG_arg_fail(1)) SWIG_fail;
20801 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
20802 if (SWIG_arg_fail(2)) SWIG_fail;
20803 {
20804 PyThreadState* __tstate = wxPyBeginAllowThreads();
20805 (arg1)->AddFont(arg2);
20806
20807 wxPyEndAllowThreads(__tstate);
20808 if (PyErr_Occurred()) SWIG_fail;
20809 }
20810 Py_INCREF(Py_None); resultobj = Py_None;
20811 return resultobj;
20812 fail:
20813 return NULL;
20814 }
20815
20816
20817 static PyObject *_wrap_FontList_FindOrCreateFont(PyObject *, PyObject *args, PyObject *kwargs) {
20818 PyObject *resultobj;
20819 wxFontList *arg1 = (wxFontList *) 0 ;
20820 int arg2 ;
20821 int arg3 ;
20822 int arg4 ;
20823 int arg5 ;
20824 bool arg6 = (bool) false ;
20825 wxString const &arg7_defvalue = wxPyEmptyString ;
20826 wxString *arg7 = (wxString *) &arg7_defvalue ;
20827 wxFontEncoding arg8 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
20828 wxFont *result;
20829 bool temp7 = false ;
20830 PyObject * obj0 = 0 ;
20831 PyObject * obj1 = 0 ;
20832 PyObject * obj2 = 0 ;
20833 PyObject * obj3 = 0 ;
20834 PyObject * obj4 = 0 ;
20835 PyObject * obj5 = 0 ;
20836 PyObject * obj6 = 0 ;
20837 PyObject * obj7 = 0 ;
20838 char *kwnames[] = {
20839 (char *) "self",(char *) "point_size",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "facename",(char *) "encoding", NULL
20840 };
20841
20842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:FontList_FindOrCreateFont",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
20843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20844 if (SWIG_arg_fail(1)) SWIG_fail;
20845 {
20846 arg2 = (int)(SWIG_As_int(obj1));
20847 if (SWIG_arg_fail(2)) SWIG_fail;
20848 }
20849 {
20850 arg3 = (int)(SWIG_As_int(obj2));
20851 if (SWIG_arg_fail(3)) SWIG_fail;
20852 }
20853 {
20854 arg4 = (int)(SWIG_As_int(obj3));
20855 if (SWIG_arg_fail(4)) SWIG_fail;
20856 }
20857 {
20858 arg5 = (int)(SWIG_As_int(obj4));
20859 if (SWIG_arg_fail(5)) SWIG_fail;
20860 }
20861 if (obj5) {
20862 {
20863 arg6 = (bool)(SWIG_As_bool(obj5));
20864 if (SWIG_arg_fail(6)) SWIG_fail;
20865 }
20866 }
20867 if (obj6) {
20868 {
20869 arg7 = wxString_in_helper(obj6);
20870 if (arg7 == NULL) SWIG_fail;
20871 temp7 = true;
20872 }
20873 }
20874 if (obj7) {
20875 {
20876 arg8 = (wxFontEncoding)(SWIG_As_int(obj7));
20877 if (SWIG_arg_fail(8)) SWIG_fail;
20878 }
20879 }
20880 {
20881 PyThreadState* __tstate = wxPyBeginAllowThreads();
20882 result = (wxFont *)(arg1)->FindOrCreateFont(arg2,arg3,arg4,arg5,arg6,(wxString const &)*arg7,(wxFontEncoding )arg8);
20883
20884 wxPyEndAllowThreads(__tstate);
20885 if (PyErr_Occurred()) SWIG_fail;
20886 }
20887 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
20888 {
20889 if (temp7)
20890 delete arg7;
20891 }
20892 return resultobj;
20893 fail:
20894 {
20895 if (temp7)
20896 delete arg7;
20897 }
20898 return NULL;
20899 }
20900
20901
20902 static PyObject *_wrap_FontList_RemoveFont(PyObject *, PyObject *args, PyObject *kwargs) {
20903 PyObject *resultobj;
20904 wxFontList *arg1 = (wxFontList *) 0 ;
20905 wxFont *arg2 = (wxFont *) 0 ;
20906 PyObject * obj0 = 0 ;
20907 PyObject * obj1 = 0 ;
20908 char *kwnames[] = {
20909 (char *) "self",(char *) "font", NULL
20910 };
20911
20912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_RemoveFont",kwnames,&obj0,&obj1)) goto fail;
20913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20914 if (SWIG_arg_fail(1)) SWIG_fail;
20915 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
20916 if (SWIG_arg_fail(2)) SWIG_fail;
20917 {
20918 PyThreadState* __tstate = wxPyBeginAllowThreads();
20919 (arg1)->RemoveFont(arg2);
20920
20921 wxPyEndAllowThreads(__tstate);
20922 if (PyErr_Occurred()) SWIG_fail;
20923 }
20924 Py_INCREF(Py_None); resultobj = Py_None;
20925 return resultobj;
20926 fail:
20927 return NULL;
20928 }
20929
20930
20931 static PyObject *_wrap_FontList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
20932 PyObject *resultobj;
20933 wxFontList *arg1 = (wxFontList *) 0 ;
20934 int result;
20935 PyObject * obj0 = 0 ;
20936 char *kwnames[] = {
20937 (char *) "self", NULL
20938 };
20939
20940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontList_GetCount",kwnames,&obj0)) goto fail;
20941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20942 if (SWIG_arg_fail(1)) SWIG_fail;
20943 {
20944 PyThreadState* __tstate = wxPyBeginAllowThreads();
20945 result = (int)(arg1)->GetCount();
20946
20947 wxPyEndAllowThreads(__tstate);
20948 if (PyErr_Occurred()) SWIG_fail;
20949 }
20950 {
20951 resultobj = SWIG_From_int((int)(result));
20952 }
20953 return resultobj;
20954 fail:
20955 return NULL;
20956 }
20957
20958
20959 static PyObject * FontList_swigregister(PyObject *, PyObject *args) {
20960 PyObject *obj;
20961 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20962 SWIG_TypeClientData(SWIGTYPE_p_wxFontList, obj);
20963 Py_INCREF(obj);
20964 return Py_BuildValue((char *)"");
20965 }
20966 static int _wrap_TheFontList_set(PyObject *) {
20967 PyErr_SetString(PyExc_TypeError,"Variable TheFontList is read-only.");
20968 return 1;
20969 }
20970
20971
20972 static PyObject *_wrap_TheFontList_get(void) {
20973 PyObject *pyobj;
20974
20975 pyobj = SWIG_NewPointerObj((void *)(wxTheFontList), SWIGTYPE_p_wxFontList, 0);
20976 return pyobj;
20977 }
20978
20979
20980 static int _wrap_ThePenList_set(PyObject *) {
20981 PyErr_SetString(PyExc_TypeError,"Variable ThePenList is read-only.");
20982 return 1;
20983 }
20984
20985
20986 static PyObject *_wrap_ThePenList_get(void) {
20987 PyObject *pyobj;
20988
20989 pyobj = SWIG_NewPointerObj((void *)(wxThePenList), SWIGTYPE_p_wxPenList, 0);
20990 return pyobj;
20991 }
20992
20993
20994 static int _wrap_TheBrushList_set(PyObject *) {
20995 PyErr_SetString(PyExc_TypeError,"Variable TheBrushList is read-only.");
20996 return 1;
20997 }
20998
20999
21000 static PyObject *_wrap_TheBrushList_get(void) {
21001 PyObject *pyobj;
21002
21003 pyobj = SWIG_NewPointerObj((void *)(wxTheBrushList), SWIGTYPE_p_wxBrushList, 0);
21004 return pyobj;
21005 }
21006
21007
21008 static int _wrap_TheColourDatabase_set(PyObject *) {
21009 PyErr_SetString(PyExc_TypeError,"Variable TheColourDatabase is read-only.");
21010 return 1;
21011 }
21012
21013
21014 static PyObject *_wrap_TheColourDatabase_get(void) {
21015 PyObject *pyobj;
21016
21017 pyobj = SWIG_NewPointerObj((void *)(wxTheColourDatabase), SWIGTYPE_p_wxColourDatabase, 0);
21018 return pyobj;
21019 }
21020
21021
21022 static PyObject *_wrap_new_Effects(PyObject *, PyObject *args, PyObject *kwargs) {
21023 PyObject *resultobj;
21024 wxEffects *result;
21025 char *kwnames[] = {
21026 NULL
21027 };
21028
21029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Effects",kwnames)) goto fail;
21030 {
21031 PyThreadState* __tstate = wxPyBeginAllowThreads();
21032 result = (wxEffects *)new wxEffects();
21033
21034 wxPyEndAllowThreads(__tstate);
21035 if (PyErr_Occurred()) SWIG_fail;
21036 }
21037 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEffects, 1);
21038 return resultobj;
21039 fail:
21040 return NULL;
21041 }
21042
21043
21044 static PyObject *_wrap_Effects_GetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
21045 PyObject *resultobj;
21046 wxEffects *arg1 = (wxEffects *) 0 ;
21047 wxColour result;
21048 PyObject * obj0 = 0 ;
21049 char *kwnames[] = {
21050 (char *) "self", NULL
21051 };
21052
21053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetHighlightColour",kwnames,&obj0)) goto fail;
21054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21055 if (SWIG_arg_fail(1)) SWIG_fail;
21056 {
21057 PyThreadState* __tstate = wxPyBeginAllowThreads();
21058 result = ((wxEffects const *)arg1)->GetHighlightColour();
21059
21060 wxPyEndAllowThreads(__tstate);
21061 if (PyErr_Occurred()) SWIG_fail;
21062 }
21063 {
21064 wxColour * resultptr;
21065 resultptr = new wxColour((wxColour &)(result));
21066 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
21067 }
21068 return resultobj;
21069 fail:
21070 return NULL;
21071 }
21072
21073
21074 static PyObject *_wrap_Effects_GetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21075 PyObject *resultobj;
21076 wxEffects *arg1 = (wxEffects *) 0 ;
21077 wxColour result;
21078 PyObject * obj0 = 0 ;
21079 char *kwnames[] = {
21080 (char *) "self", NULL
21081 };
21082
21083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetLightShadow",kwnames,&obj0)) goto fail;
21084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21085 if (SWIG_arg_fail(1)) SWIG_fail;
21086 {
21087 PyThreadState* __tstate = wxPyBeginAllowThreads();
21088 result = ((wxEffects const *)arg1)->GetLightShadow();
21089
21090 wxPyEndAllowThreads(__tstate);
21091 if (PyErr_Occurred()) SWIG_fail;
21092 }
21093 {
21094 wxColour * resultptr;
21095 resultptr = new wxColour((wxColour &)(result));
21096 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
21097 }
21098 return resultobj;
21099 fail:
21100 return NULL;
21101 }
21102
21103
21104 static PyObject *_wrap_Effects_GetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
21105 PyObject *resultobj;
21106 wxEffects *arg1 = (wxEffects *) 0 ;
21107 wxColour result;
21108 PyObject * obj0 = 0 ;
21109 char *kwnames[] = {
21110 (char *) "self", NULL
21111 };
21112
21113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetFaceColour",kwnames,&obj0)) goto fail;
21114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21115 if (SWIG_arg_fail(1)) SWIG_fail;
21116 {
21117 PyThreadState* __tstate = wxPyBeginAllowThreads();
21118 result = ((wxEffects const *)arg1)->GetFaceColour();
21119
21120 wxPyEndAllowThreads(__tstate);
21121 if (PyErr_Occurred()) SWIG_fail;
21122 }
21123 {
21124 wxColour * resultptr;
21125 resultptr = new wxColour((wxColour &)(result));
21126 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
21127 }
21128 return resultobj;
21129 fail:
21130 return NULL;
21131 }
21132
21133
21134 static PyObject *_wrap_Effects_GetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21135 PyObject *resultobj;
21136 wxEffects *arg1 = (wxEffects *) 0 ;
21137 wxColour result;
21138 PyObject * obj0 = 0 ;
21139 char *kwnames[] = {
21140 (char *) "self", NULL
21141 };
21142
21143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetMediumShadow",kwnames,&obj0)) goto fail;
21144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21145 if (SWIG_arg_fail(1)) SWIG_fail;
21146 {
21147 PyThreadState* __tstate = wxPyBeginAllowThreads();
21148 result = ((wxEffects const *)arg1)->GetMediumShadow();
21149
21150 wxPyEndAllowThreads(__tstate);
21151 if (PyErr_Occurred()) SWIG_fail;
21152 }
21153 {
21154 wxColour * resultptr;
21155 resultptr = new wxColour((wxColour &)(result));
21156 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
21157 }
21158 return resultobj;
21159 fail:
21160 return NULL;
21161 }
21162
21163
21164 static PyObject *_wrap_Effects_GetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21165 PyObject *resultobj;
21166 wxEffects *arg1 = (wxEffects *) 0 ;
21167 wxColour result;
21168 PyObject * obj0 = 0 ;
21169 char *kwnames[] = {
21170 (char *) "self", NULL
21171 };
21172
21173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetDarkShadow",kwnames,&obj0)) goto fail;
21174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21175 if (SWIG_arg_fail(1)) SWIG_fail;
21176 {
21177 PyThreadState* __tstate = wxPyBeginAllowThreads();
21178 result = ((wxEffects const *)arg1)->GetDarkShadow();
21179
21180 wxPyEndAllowThreads(__tstate);
21181 if (PyErr_Occurred()) SWIG_fail;
21182 }
21183 {
21184 wxColour * resultptr;
21185 resultptr = new wxColour((wxColour &)(result));
21186 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
21187 }
21188 return resultobj;
21189 fail:
21190 return NULL;
21191 }
21192
21193
21194 static PyObject *_wrap_Effects_SetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
21195 PyObject *resultobj;
21196 wxEffects *arg1 = (wxEffects *) 0 ;
21197 wxColour *arg2 = 0 ;
21198 wxColour temp2 ;
21199 PyObject * obj0 = 0 ;
21200 PyObject * obj1 = 0 ;
21201 char *kwnames[] = {
21202 (char *) "self",(char *) "c", NULL
21203 };
21204
21205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetHighlightColour",kwnames,&obj0,&obj1)) goto fail;
21206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21207 if (SWIG_arg_fail(1)) SWIG_fail;
21208 {
21209 arg2 = &temp2;
21210 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21211 }
21212 {
21213 PyThreadState* __tstate = wxPyBeginAllowThreads();
21214 (arg1)->SetHighlightColour((wxColour const &)*arg2);
21215
21216 wxPyEndAllowThreads(__tstate);
21217 if (PyErr_Occurred()) SWIG_fail;
21218 }
21219 Py_INCREF(Py_None); resultobj = Py_None;
21220 return resultobj;
21221 fail:
21222 return NULL;
21223 }
21224
21225
21226 static PyObject *_wrap_Effects_SetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21227 PyObject *resultobj;
21228 wxEffects *arg1 = (wxEffects *) 0 ;
21229 wxColour *arg2 = 0 ;
21230 wxColour temp2 ;
21231 PyObject * obj0 = 0 ;
21232 PyObject * obj1 = 0 ;
21233 char *kwnames[] = {
21234 (char *) "self",(char *) "c", NULL
21235 };
21236
21237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetLightShadow",kwnames,&obj0,&obj1)) goto fail;
21238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21239 if (SWIG_arg_fail(1)) SWIG_fail;
21240 {
21241 arg2 = &temp2;
21242 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21243 }
21244 {
21245 PyThreadState* __tstate = wxPyBeginAllowThreads();
21246 (arg1)->SetLightShadow((wxColour const &)*arg2);
21247
21248 wxPyEndAllowThreads(__tstate);
21249 if (PyErr_Occurred()) SWIG_fail;
21250 }
21251 Py_INCREF(Py_None); resultobj = Py_None;
21252 return resultobj;
21253 fail:
21254 return NULL;
21255 }
21256
21257
21258 static PyObject *_wrap_Effects_SetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
21259 PyObject *resultobj;
21260 wxEffects *arg1 = (wxEffects *) 0 ;
21261 wxColour *arg2 = 0 ;
21262 wxColour temp2 ;
21263 PyObject * obj0 = 0 ;
21264 PyObject * obj1 = 0 ;
21265 char *kwnames[] = {
21266 (char *) "self",(char *) "c", NULL
21267 };
21268
21269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetFaceColour",kwnames,&obj0,&obj1)) goto fail;
21270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21271 if (SWIG_arg_fail(1)) SWIG_fail;
21272 {
21273 arg2 = &temp2;
21274 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21275 }
21276 {
21277 PyThreadState* __tstate = wxPyBeginAllowThreads();
21278 (arg1)->SetFaceColour((wxColour const &)*arg2);
21279
21280 wxPyEndAllowThreads(__tstate);
21281 if (PyErr_Occurred()) SWIG_fail;
21282 }
21283 Py_INCREF(Py_None); resultobj = Py_None;
21284 return resultobj;
21285 fail:
21286 return NULL;
21287 }
21288
21289
21290 static PyObject *_wrap_Effects_SetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21291 PyObject *resultobj;
21292 wxEffects *arg1 = (wxEffects *) 0 ;
21293 wxColour *arg2 = 0 ;
21294 wxColour temp2 ;
21295 PyObject * obj0 = 0 ;
21296 PyObject * obj1 = 0 ;
21297 char *kwnames[] = {
21298 (char *) "self",(char *) "c", NULL
21299 };
21300
21301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetMediumShadow",kwnames,&obj0,&obj1)) goto fail;
21302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21303 if (SWIG_arg_fail(1)) SWIG_fail;
21304 {
21305 arg2 = &temp2;
21306 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21307 }
21308 {
21309 PyThreadState* __tstate = wxPyBeginAllowThreads();
21310 (arg1)->SetMediumShadow((wxColour const &)*arg2);
21311
21312 wxPyEndAllowThreads(__tstate);
21313 if (PyErr_Occurred()) SWIG_fail;
21314 }
21315 Py_INCREF(Py_None); resultobj = Py_None;
21316 return resultobj;
21317 fail:
21318 return NULL;
21319 }
21320
21321
21322 static PyObject *_wrap_Effects_SetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
21323 PyObject *resultobj;
21324 wxEffects *arg1 = (wxEffects *) 0 ;
21325 wxColour *arg2 = 0 ;
21326 wxColour temp2 ;
21327 PyObject * obj0 = 0 ;
21328 PyObject * obj1 = 0 ;
21329 char *kwnames[] = {
21330 (char *) "self",(char *) "c", NULL
21331 };
21332
21333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetDarkShadow",kwnames,&obj0,&obj1)) goto fail;
21334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21335 if (SWIG_arg_fail(1)) SWIG_fail;
21336 {
21337 arg2 = &temp2;
21338 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21339 }
21340 {
21341 PyThreadState* __tstate = wxPyBeginAllowThreads();
21342 (arg1)->SetDarkShadow((wxColour const &)*arg2);
21343
21344 wxPyEndAllowThreads(__tstate);
21345 if (PyErr_Occurred()) SWIG_fail;
21346 }
21347 Py_INCREF(Py_None); resultobj = Py_None;
21348 return resultobj;
21349 fail:
21350 return NULL;
21351 }
21352
21353
21354 static PyObject *_wrap_Effects_Set(PyObject *, PyObject *args, PyObject *kwargs) {
21355 PyObject *resultobj;
21356 wxEffects *arg1 = (wxEffects *) 0 ;
21357 wxColour *arg2 = 0 ;
21358 wxColour *arg3 = 0 ;
21359 wxColour *arg4 = 0 ;
21360 wxColour *arg5 = 0 ;
21361 wxColour *arg6 = 0 ;
21362 wxColour temp2 ;
21363 wxColour temp3 ;
21364 wxColour temp4 ;
21365 wxColour temp5 ;
21366 wxColour temp6 ;
21367 PyObject * obj0 = 0 ;
21368 PyObject * obj1 = 0 ;
21369 PyObject * obj2 = 0 ;
21370 PyObject * obj3 = 0 ;
21371 PyObject * obj4 = 0 ;
21372 PyObject * obj5 = 0 ;
21373 char *kwnames[] = {
21374 (char *) "self",(char *) "highlightColour",(char *) "lightShadow",(char *) "faceColour",(char *) "mediumShadow",(char *) "darkShadow", NULL
21375 };
21376
21377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Effects_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
21378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21379 if (SWIG_arg_fail(1)) SWIG_fail;
21380 {
21381 arg2 = &temp2;
21382 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
21383 }
21384 {
21385 arg3 = &temp3;
21386 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
21387 }
21388 {
21389 arg4 = &temp4;
21390 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
21391 }
21392 {
21393 arg5 = &temp5;
21394 if ( ! wxColour_helper(obj4, &arg5)) SWIG_fail;
21395 }
21396 {
21397 arg6 = &temp6;
21398 if ( ! wxColour_helper(obj5, &arg6)) SWIG_fail;
21399 }
21400 {
21401 PyThreadState* __tstate = wxPyBeginAllowThreads();
21402 (arg1)->Set((wxColour const &)*arg2,(wxColour const &)*arg3,(wxColour const &)*arg4,(wxColour const &)*arg5,(wxColour const &)*arg6);
21403
21404 wxPyEndAllowThreads(__tstate);
21405 if (PyErr_Occurred()) SWIG_fail;
21406 }
21407 Py_INCREF(Py_None); resultobj = Py_None;
21408 return resultobj;
21409 fail:
21410 return NULL;
21411 }
21412
21413
21414 static PyObject *_wrap_Effects_DrawSunkenEdge(PyObject *, PyObject *args, PyObject *kwargs) {
21415 PyObject *resultobj;
21416 wxEffects *arg1 = (wxEffects *) 0 ;
21417 wxDC *arg2 = 0 ;
21418 wxRect *arg3 = 0 ;
21419 int arg4 = (int) 1 ;
21420 wxRect temp3 ;
21421 PyObject * obj0 = 0 ;
21422 PyObject * obj1 = 0 ;
21423 PyObject * obj2 = 0 ;
21424 PyObject * obj3 = 0 ;
21425 char *kwnames[] = {
21426 (char *) "self",(char *) "dc",(char *) "rect",(char *) "borderSize", NULL
21427 };
21428
21429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Effects_DrawSunkenEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
21430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21431 if (SWIG_arg_fail(1)) SWIG_fail;
21432 {
21433 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21434 if (SWIG_arg_fail(2)) SWIG_fail;
21435 if (arg2 == NULL) {
21436 SWIG_null_ref("wxDC");
21437 }
21438 if (SWIG_arg_fail(2)) SWIG_fail;
21439 }
21440 {
21441 arg3 = &temp3;
21442 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
21443 }
21444 if (obj3) {
21445 {
21446 arg4 = (int)(SWIG_As_int(obj3));
21447 if (SWIG_arg_fail(4)) SWIG_fail;
21448 }
21449 }
21450 {
21451 PyThreadState* __tstate = wxPyBeginAllowThreads();
21452 (arg1)->DrawSunkenEdge(*arg2,(wxRect const &)*arg3,arg4);
21453
21454 wxPyEndAllowThreads(__tstate);
21455 if (PyErr_Occurred()) SWIG_fail;
21456 }
21457 Py_INCREF(Py_None); resultobj = Py_None;
21458 return resultobj;
21459 fail:
21460 return NULL;
21461 }
21462
21463
21464 static PyObject *_wrap_Effects_TileBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
21465 PyObject *resultobj;
21466 wxEffects *arg1 = (wxEffects *) 0 ;
21467 wxRect *arg2 = 0 ;
21468 wxDC *arg3 = 0 ;
21469 wxBitmap *arg4 = 0 ;
21470 bool result;
21471 wxRect temp2 ;
21472 PyObject * obj0 = 0 ;
21473 PyObject * obj1 = 0 ;
21474 PyObject * obj2 = 0 ;
21475 PyObject * obj3 = 0 ;
21476 char *kwnames[] = {
21477 (char *) "self",(char *) "rect",(char *) "dc",(char *) "bitmap", NULL
21478 };
21479
21480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Effects_TileBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
21481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
21482 if (SWIG_arg_fail(1)) SWIG_fail;
21483 {
21484 arg2 = &temp2;
21485 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
21486 }
21487 {
21488 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
21489 if (SWIG_arg_fail(3)) SWIG_fail;
21490 if (arg3 == NULL) {
21491 SWIG_null_ref("wxDC");
21492 }
21493 if (SWIG_arg_fail(3)) SWIG_fail;
21494 }
21495 {
21496 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
21497 if (SWIG_arg_fail(4)) SWIG_fail;
21498 if (arg4 == NULL) {
21499 SWIG_null_ref("wxBitmap");
21500 }
21501 if (SWIG_arg_fail(4)) SWIG_fail;
21502 }
21503 {
21504 PyThreadState* __tstate = wxPyBeginAllowThreads();
21505 result = (bool)(arg1)->TileBitmap((wxRect const &)*arg2,*arg3,*arg4);
21506
21507 wxPyEndAllowThreads(__tstate);
21508 if (PyErr_Occurred()) SWIG_fail;
21509 }
21510 {
21511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21512 }
21513 return resultobj;
21514 fail:
21515 return NULL;
21516 }
21517
21518
21519 static PyObject * Effects_swigregister(PyObject *, PyObject *args) {
21520 PyObject *obj;
21521 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21522 SWIG_TypeClientData(SWIGTYPE_p_wxEffects, obj);
21523 Py_INCREF(obj);
21524 return Py_BuildValue((char *)"");
21525 }
21526 static PyMethodDef SwigMethods[] = {
21527 { (char *)"new_GDIObject", (PyCFunction) _wrap_new_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
21528 { (char *)"delete_GDIObject", (PyCFunction) _wrap_delete_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
21529 { (char *)"GDIObject_GetVisible", (PyCFunction) _wrap_GDIObject_GetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
21530 { (char *)"GDIObject_SetVisible", (PyCFunction) _wrap_GDIObject_SetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
21531 { (char *)"GDIObject_IsNull", (PyCFunction) _wrap_GDIObject_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
21532 { (char *)"GDIObject_swigregister", GDIObject_swigregister, METH_VARARGS, NULL},
21533 { (char *)"new_Colour", (PyCFunction) _wrap_new_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
21534 { (char *)"new_NamedColour", (PyCFunction) _wrap_new_NamedColour, METH_VARARGS | METH_KEYWORDS, NULL},
21535 { (char *)"new_ColourRGB", (PyCFunction) _wrap_new_ColourRGB, METH_VARARGS | METH_KEYWORDS, NULL},
21536 { (char *)"delete_Colour", (PyCFunction) _wrap_delete_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
21537 { (char *)"Colour_Red", (PyCFunction) _wrap_Colour_Red, METH_VARARGS | METH_KEYWORDS, NULL},
21538 { (char *)"Colour_Green", (PyCFunction) _wrap_Colour_Green, METH_VARARGS | METH_KEYWORDS, NULL},
21539 { (char *)"Colour_Blue", (PyCFunction) _wrap_Colour_Blue, METH_VARARGS | METH_KEYWORDS, NULL},
21540 { (char *)"Colour_Ok", (PyCFunction) _wrap_Colour_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21541 { (char *)"Colour_Set", (PyCFunction) _wrap_Colour_Set, METH_VARARGS | METH_KEYWORDS, NULL},
21542 { (char *)"Colour_SetRGB", (PyCFunction) _wrap_Colour_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
21543 { (char *)"Colour_SetFromName", (PyCFunction) _wrap_Colour_SetFromName, METH_VARARGS | METH_KEYWORDS, NULL},
21544 { (char *)"Colour_GetPixel", (PyCFunction) _wrap_Colour_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
21545 { (char *)"Colour___eq__", (PyCFunction) _wrap_Colour___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
21546 { (char *)"Colour___ne__", (PyCFunction) _wrap_Colour___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
21547 { (char *)"Colour_Get", (PyCFunction) _wrap_Colour_Get, METH_VARARGS | METH_KEYWORDS, NULL},
21548 { (char *)"Colour_GetRGB", (PyCFunction) _wrap_Colour_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
21549 { (char *)"Colour_swigregister", Colour_swigregister, METH_VARARGS, NULL},
21550 { (char *)"new_Palette", (PyCFunction) _wrap_new_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
21551 { (char *)"delete_Palette", (PyCFunction) _wrap_delete_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
21552 { (char *)"Palette_GetPixel", (PyCFunction) _wrap_Palette_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
21553 { (char *)"Palette_GetRGB", (PyCFunction) _wrap_Palette_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
21554 { (char *)"Palette_GetColoursCount", (PyCFunction) _wrap_Palette_GetColoursCount, METH_VARARGS | METH_KEYWORDS, NULL},
21555 { (char *)"Palette_Ok", (PyCFunction) _wrap_Palette_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21556 { (char *)"Palette_swigregister", Palette_swigregister, METH_VARARGS, NULL},
21557 { (char *)"new_Pen", (PyCFunction) _wrap_new_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
21558 { (char *)"delete_Pen", (PyCFunction) _wrap_delete_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
21559 { (char *)"Pen_GetCap", (PyCFunction) _wrap_Pen_GetCap, METH_VARARGS | METH_KEYWORDS, NULL},
21560 { (char *)"Pen_GetColour", (PyCFunction) _wrap_Pen_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
21561 { (char *)"Pen_GetJoin", (PyCFunction) _wrap_Pen_GetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
21562 { (char *)"Pen_GetStyle", (PyCFunction) _wrap_Pen_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21563 { (char *)"Pen_GetWidth", (PyCFunction) _wrap_Pen_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21564 { (char *)"Pen_Ok", (PyCFunction) _wrap_Pen_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21565 { (char *)"Pen_SetCap", (PyCFunction) _wrap_Pen_SetCap, METH_VARARGS | METH_KEYWORDS, NULL},
21566 { (char *)"Pen_SetColour", (PyCFunction) _wrap_Pen_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
21567 { (char *)"Pen_SetJoin", (PyCFunction) _wrap_Pen_SetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
21568 { (char *)"Pen_SetStyle", (PyCFunction) _wrap_Pen_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21569 { (char *)"Pen_SetWidth", (PyCFunction) _wrap_Pen_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21570 { (char *)"Pen_SetDashes", (PyCFunction) _wrap_Pen_SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
21571 { (char *)"Pen_GetDashes", (PyCFunction) _wrap_Pen_GetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
21572 { (char *)"Pen__SetDashes", (PyCFunction) _wrap_Pen__SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
21573 { (char *)"Pen_GetDashCount", (PyCFunction) _wrap_Pen_GetDashCount, METH_VARARGS | METH_KEYWORDS, NULL},
21574 { (char *)"Pen_GetStipple", (PyCFunction) _wrap_Pen_GetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
21575 { (char *)"Pen_SetStipple", (PyCFunction) _wrap_Pen_SetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
21576 { (char *)"Pen___eq__", (PyCFunction) _wrap_Pen___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
21577 { (char *)"Pen___ne__", (PyCFunction) _wrap_Pen___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
21578 { (char *)"Pen_swigregister", Pen_swigregister, METH_VARARGS, NULL},
21579 { (char *)"new_Brush", (PyCFunction) _wrap_new_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
21580 { (char *)"new_BrushFromBitmap", (PyCFunction) _wrap_new_BrushFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21581 { (char *)"delete_Brush", (PyCFunction) _wrap_delete_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
21582 { (char *)"Brush_SetColour", (PyCFunction) _wrap_Brush_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
21583 { (char *)"Brush_SetStyle", (PyCFunction) _wrap_Brush_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21584 { (char *)"Brush_SetStipple", (PyCFunction) _wrap_Brush_SetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
21585 { (char *)"Brush_GetColour", (PyCFunction) _wrap_Brush_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
21586 { (char *)"Brush_GetStyle", (PyCFunction) _wrap_Brush_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21587 { (char *)"Brush_GetStipple", (PyCFunction) _wrap_Brush_GetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
21588 { (char *)"Brush_IsHatch", (PyCFunction) _wrap_Brush_IsHatch, METH_VARARGS | METH_KEYWORDS, NULL},
21589 { (char *)"Brush_Ok", (PyCFunction) _wrap_Brush_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21590 { (char *)"Brush_swigregister", Brush_swigregister, METH_VARARGS, NULL},
21591 { (char *)"new_Bitmap", (PyCFunction) _wrap_new_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21592 { (char *)"delete_Bitmap", (PyCFunction) _wrap_delete_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21593 { (char *)"new_EmptyBitmap", (PyCFunction) _wrap_new_EmptyBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21594 { (char *)"new_BitmapFromIcon", (PyCFunction) _wrap_new_BitmapFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21595 { (char *)"new_BitmapFromImage", (PyCFunction) _wrap_new_BitmapFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
21596 { (char *)"new_BitmapFromXPMData", (PyCFunction) _wrap_new_BitmapFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
21597 { (char *)"new_BitmapFromBits", (PyCFunction) _wrap_new_BitmapFromBits, METH_VARARGS | METH_KEYWORDS, NULL},
21598 { (char *)"Bitmap_GetHandle", (PyCFunction) _wrap_Bitmap_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
21599 { (char *)"Bitmap_SetHandle", (PyCFunction) _wrap_Bitmap_SetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
21600 { (char *)"Bitmap_Ok", (PyCFunction) _wrap_Bitmap_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21601 { (char *)"Bitmap_GetWidth", (PyCFunction) _wrap_Bitmap_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21602 { (char *)"Bitmap_GetHeight", (PyCFunction) _wrap_Bitmap_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21603 { (char *)"Bitmap_GetDepth", (PyCFunction) _wrap_Bitmap_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21604 { (char *)"Bitmap_GetSize", (PyCFunction) _wrap_Bitmap_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21605 { (char *)"Bitmap_ConvertToImage", (PyCFunction) _wrap_Bitmap_ConvertToImage, METH_VARARGS | METH_KEYWORDS, NULL},
21606 { (char *)"Bitmap_GetMask", (PyCFunction) _wrap_Bitmap_GetMask, METH_VARARGS | METH_KEYWORDS, NULL},
21607 { (char *)"Bitmap_SetMask", (PyCFunction) _wrap_Bitmap_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
21608 { (char *)"Bitmap_SetMaskColour", (PyCFunction) _wrap_Bitmap_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
21609 { (char *)"Bitmap_GetSubBitmap", (PyCFunction) _wrap_Bitmap_GetSubBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21610 { (char *)"Bitmap_SaveFile", (PyCFunction) _wrap_Bitmap_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
21611 { (char *)"Bitmap_LoadFile", (PyCFunction) _wrap_Bitmap_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
21612 { (char *)"Bitmap_GetPalette", (PyCFunction) _wrap_Bitmap_GetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
21613 { (char *)"Bitmap_SetPalette", (PyCFunction) _wrap_Bitmap_SetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
21614 { (char *)"Bitmap_CopyFromIcon", (PyCFunction) _wrap_Bitmap_CopyFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21615 { (char *)"Bitmap_SetHeight", (PyCFunction) _wrap_Bitmap_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21616 { (char *)"Bitmap_SetWidth", (PyCFunction) _wrap_Bitmap_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21617 { (char *)"Bitmap_SetDepth", (PyCFunction) _wrap_Bitmap_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21618 { (char *)"Bitmap_SetSize", (PyCFunction) _wrap_Bitmap_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21619 { (char *)"Bitmap_CopyFromCursor", (PyCFunction) _wrap_Bitmap_CopyFromCursor, METH_VARARGS | METH_KEYWORDS, NULL},
21620 { (char *)"Bitmap_GetQuality", (PyCFunction) _wrap_Bitmap_GetQuality, METH_VARARGS | METH_KEYWORDS, NULL},
21621 { (char *)"Bitmap_SetQuality", (PyCFunction) _wrap_Bitmap_SetQuality, METH_VARARGS | METH_KEYWORDS, NULL},
21622 { (char *)"Bitmap___eq__", (PyCFunction) _wrap_Bitmap___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
21623 { (char *)"Bitmap___ne__", (PyCFunction) _wrap_Bitmap___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
21624 { (char *)"Bitmap_swigregister", Bitmap_swigregister, METH_VARARGS, NULL},
21625 { (char *)"new_Mask", (PyCFunction) _wrap_new_Mask, METH_VARARGS | METH_KEYWORDS, NULL},
21626 { (char *)"Mask_swigregister", Mask_swigregister, METH_VARARGS, NULL},
21627 { (char *)"new_Icon", (PyCFunction) _wrap_new_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
21628 { (char *)"delete_Icon", (PyCFunction) _wrap_delete_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
21629 { (char *)"new_EmptyIcon", (PyCFunction) _wrap_new_EmptyIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21630 { (char *)"new_IconFromLocation", (PyCFunction) _wrap_new_IconFromLocation, METH_VARARGS | METH_KEYWORDS, NULL},
21631 { (char *)"new_IconFromBitmap", (PyCFunction) _wrap_new_IconFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21632 { (char *)"new_IconFromXPMData", (PyCFunction) _wrap_new_IconFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
21633 { (char *)"Icon_LoadFile", (PyCFunction) _wrap_Icon_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
21634 { (char *)"Icon_GetHandle", (PyCFunction) _wrap_Icon_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
21635 { (char *)"Icon_SetHandle", (PyCFunction) _wrap_Icon_SetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
21636 { (char *)"Icon_Ok", (PyCFunction) _wrap_Icon_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21637 { (char *)"Icon_GetWidth", (PyCFunction) _wrap_Icon_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21638 { (char *)"Icon_GetHeight", (PyCFunction) _wrap_Icon_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21639 { (char *)"Icon_GetDepth", (PyCFunction) _wrap_Icon_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21640 { (char *)"Icon_SetWidth", (PyCFunction) _wrap_Icon_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21641 { (char *)"Icon_SetHeight", (PyCFunction) _wrap_Icon_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21642 { (char *)"Icon_SetDepth", (PyCFunction) _wrap_Icon_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21643 { (char *)"Icon_SetSize", (PyCFunction) _wrap_Icon_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21644 { (char *)"Icon_CopyFromBitmap", (PyCFunction) _wrap_Icon_CopyFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21645 { (char *)"Icon_swigregister", Icon_swigregister, METH_VARARGS, NULL},
21646 { (char *)"new_IconLocation", (PyCFunction) _wrap_new_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
21647 { (char *)"delete_IconLocation", (PyCFunction) _wrap_delete_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
21648 { (char *)"IconLocation_IsOk", (PyCFunction) _wrap_IconLocation_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
21649 { (char *)"IconLocation_SetFileName", (PyCFunction) _wrap_IconLocation_SetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
21650 { (char *)"IconLocation_GetFileName", (PyCFunction) _wrap_IconLocation_GetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
21651 { (char *)"IconLocation_SetIndex", (PyCFunction) _wrap_IconLocation_SetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
21652 { (char *)"IconLocation_GetIndex", (PyCFunction) _wrap_IconLocation_GetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
21653 { (char *)"IconLocation_swigregister", IconLocation_swigregister, METH_VARARGS, NULL},
21654 { (char *)"new_IconBundle", (PyCFunction) _wrap_new_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
21655 { (char *)"new_IconBundleFromFile", (PyCFunction) _wrap_new_IconBundleFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
21656 { (char *)"new_IconBundleFromIcon", (PyCFunction) _wrap_new_IconBundleFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21657 { (char *)"delete_IconBundle", (PyCFunction) _wrap_delete_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
21658 { (char *)"IconBundle_AddIcon", (PyCFunction) _wrap_IconBundle_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21659 { (char *)"IconBundle_AddIconFromFile", (PyCFunction) _wrap_IconBundle_AddIconFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
21660 { (char *)"IconBundle_GetIcon", (PyCFunction) _wrap_IconBundle_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21661 { (char *)"IconBundle_swigregister", IconBundle_swigregister, METH_VARARGS, NULL},
21662 { (char *)"new_Cursor", (PyCFunction) _wrap_new_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
21663 { (char *)"delete_Cursor", (PyCFunction) _wrap_delete_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
21664 { (char *)"new_StockCursor", (PyCFunction) _wrap_new_StockCursor, METH_VARARGS | METH_KEYWORDS, NULL},
21665 { (char *)"new_CursorFromImage", (PyCFunction) _wrap_new_CursorFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
21666 { (char *)"Cursor_GetHandle", (PyCFunction) _wrap_Cursor_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
21667 { (char *)"Cursor_SetHandle", (PyCFunction) _wrap_Cursor_SetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
21668 { (char *)"Cursor_Ok", (PyCFunction) _wrap_Cursor_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21669 { (char *)"Cursor_GetWidth", (PyCFunction) _wrap_Cursor_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21670 { (char *)"Cursor_GetHeight", (PyCFunction) _wrap_Cursor_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21671 { (char *)"Cursor_GetDepth", (PyCFunction) _wrap_Cursor_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21672 { (char *)"Cursor_SetWidth", (PyCFunction) _wrap_Cursor_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21673 { (char *)"Cursor_SetHeight", (PyCFunction) _wrap_Cursor_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21674 { (char *)"Cursor_SetDepth", (PyCFunction) _wrap_Cursor_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21675 { (char *)"Cursor_SetSize", (PyCFunction) _wrap_Cursor_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21676 { (char *)"Cursor_swigregister", Cursor_swigregister, METH_VARARGS, NULL},
21677 { (char *)"new_Region", (PyCFunction) _wrap_new_Region, METH_VARARGS | METH_KEYWORDS, NULL},
21678 { (char *)"new_RegionFromBitmap", (PyCFunction) _wrap_new_RegionFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21679 { (char *)"new_RegionFromBitmapColour", (PyCFunction) _wrap_new_RegionFromBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
21680 { (char *)"new_RegionFromPoints", (PyCFunction) _wrap_new_RegionFromPoints, METH_VARARGS | METH_KEYWORDS, NULL},
21681 { (char *)"delete_Region", (PyCFunction) _wrap_delete_Region, METH_VARARGS | METH_KEYWORDS, NULL},
21682 { (char *)"Region_Clear", (PyCFunction) _wrap_Region_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
21683 { (char *)"Region_Offset", (PyCFunction) _wrap_Region_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
21684 { (char *)"Region_Contains", (PyCFunction) _wrap_Region_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
21685 { (char *)"Region_ContainsPoint", (PyCFunction) _wrap_Region_ContainsPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21686 { (char *)"Region_ContainsRect", (PyCFunction) _wrap_Region_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
21687 { (char *)"Region_ContainsRectDim", (PyCFunction) _wrap_Region_ContainsRectDim, METH_VARARGS | METH_KEYWORDS, NULL},
21688 { (char *)"Region_GetBox", (PyCFunction) _wrap_Region_GetBox, METH_VARARGS | METH_KEYWORDS, NULL},
21689 { (char *)"Region_Intersect", (PyCFunction) _wrap_Region_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
21690 { (char *)"Region_IntersectRect", (PyCFunction) _wrap_Region_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
21691 { (char *)"Region_IntersectRegion", (PyCFunction) _wrap_Region_IntersectRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21692 { (char *)"Region_IsEmpty", (PyCFunction) _wrap_Region_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
21693 { (char *)"Region_Union", (PyCFunction) _wrap_Region_Union, METH_VARARGS | METH_KEYWORDS, NULL},
21694 { (char *)"Region_UnionRect", (PyCFunction) _wrap_Region_UnionRect, METH_VARARGS | METH_KEYWORDS, NULL},
21695 { (char *)"Region_UnionRegion", (PyCFunction) _wrap_Region_UnionRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21696 { (char *)"Region_Subtract", (PyCFunction) _wrap_Region_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
21697 { (char *)"Region_SubtractRect", (PyCFunction) _wrap_Region_SubtractRect, METH_VARARGS | METH_KEYWORDS, NULL},
21698 { (char *)"Region_SubtractRegion", (PyCFunction) _wrap_Region_SubtractRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21699 { (char *)"Region_Xor", (PyCFunction) _wrap_Region_Xor, METH_VARARGS | METH_KEYWORDS, NULL},
21700 { (char *)"Region_XorRect", (PyCFunction) _wrap_Region_XorRect, METH_VARARGS | METH_KEYWORDS, NULL},
21701 { (char *)"Region_XorRegion", (PyCFunction) _wrap_Region_XorRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21702 { (char *)"Region_ConvertToBitmap", (PyCFunction) _wrap_Region_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21703 { (char *)"Region_UnionBitmap", (PyCFunction) _wrap_Region_UnionBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21704 { (char *)"Region_UnionBitmapColour", (PyCFunction) _wrap_Region_UnionBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
21705 { (char *)"Region_swigregister", Region_swigregister, METH_VARARGS, NULL},
21706 { (char *)"new_RegionIterator", (PyCFunction) _wrap_new_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
21707 { (char *)"delete_RegionIterator", (PyCFunction) _wrap_delete_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
21708 { (char *)"RegionIterator_GetX", (PyCFunction) _wrap_RegionIterator_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
21709 { (char *)"RegionIterator_GetY", (PyCFunction) _wrap_RegionIterator_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
21710 { (char *)"RegionIterator_GetW", (PyCFunction) _wrap_RegionIterator_GetW, METH_VARARGS | METH_KEYWORDS, NULL},
21711 { (char *)"RegionIterator_GetWidth", (PyCFunction) _wrap_RegionIterator_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21712 { (char *)"RegionIterator_GetH", (PyCFunction) _wrap_RegionIterator_GetH, METH_VARARGS | METH_KEYWORDS, NULL},
21713 { (char *)"RegionIterator_GetHeight", (PyCFunction) _wrap_RegionIterator_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21714 { (char *)"RegionIterator_GetRect", (PyCFunction) _wrap_RegionIterator_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
21715 { (char *)"RegionIterator_HaveRects", (PyCFunction) _wrap_RegionIterator_HaveRects, METH_VARARGS | METH_KEYWORDS, NULL},
21716 { (char *)"RegionIterator_Reset", (PyCFunction) _wrap_RegionIterator_Reset, METH_VARARGS | METH_KEYWORDS, NULL},
21717 { (char *)"RegionIterator_Next", (PyCFunction) _wrap_RegionIterator_Next, METH_VARARGS | METH_KEYWORDS, NULL},
21718 { (char *)"RegionIterator___nonzero__", (PyCFunction) _wrap_RegionIterator___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
21719 { (char *)"RegionIterator_swigregister", RegionIterator_swigregister, METH_VARARGS, NULL},
21720 { (char *)"new_NativeFontInfo", (PyCFunction) _wrap_new_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21721 { (char *)"delete_NativeFontInfo", (PyCFunction) _wrap_delete_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21722 { (char *)"NativeFontInfo_Init", (PyCFunction) _wrap_NativeFontInfo_Init, METH_VARARGS | METH_KEYWORDS, NULL},
21723 { (char *)"NativeFontInfo_InitFromFont", (PyCFunction) _wrap_NativeFontInfo_InitFromFont, METH_VARARGS | METH_KEYWORDS, NULL},
21724 { (char *)"NativeFontInfo_GetPointSize", (PyCFunction) _wrap_NativeFontInfo_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21725 { (char *)"NativeFontInfo_GetPixelSize", (PyCFunction) _wrap_NativeFontInfo_GetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21726 { (char *)"NativeFontInfo_GetStyle", (PyCFunction) _wrap_NativeFontInfo_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21727 { (char *)"NativeFontInfo_GetWeight", (PyCFunction) _wrap_NativeFontInfo_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
21728 { (char *)"NativeFontInfo_GetUnderlined", (PyCFunction) _wrap_NativeFontInfo_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
21729 { (char *)"NativeFontInfo_GetFaceName", (PyCFunction) _wrap_NativeFontInfo_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
21730 { (char *)"NativeFontInfo_GetFamily", (PyCFunction) _wrap_NativeFontInfo_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
21731 { (char *)"NativeFontInfo_GetEncoding", (PyCFunction) _wrap_NativeFontInfo_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21732 { (char *)"NativeFontInfo_SetPointSize", (PyCFunction) _wrap_NativeFontInfo_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21733 { (char *)"NativeFontInfo_SetPixelSize", (PyCFunction) _wrap_NativeFontInfo_SetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21734 { (char *)"NativeFontInfo_SetStyle", (PyCFunction) _wrap_NativeFontInfo_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21735 { (char *)"NativeFontInfo_SetWeight", (PyCFunction) _wrap_NativeFontInfo_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
21736 { (char *)"NativeFontInfo_SetUnderlined", (PyCFunction) _wrap_NativeFontInfo_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
21737 { (char *)"NativeFontInfo_SetFaceName", (PyCFunction) _wrap_NativeFontInfo_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
21738 { (char *)"NativeFontInfo_SetFamily", (PyCFunction) _wrap_NativeFontInfo_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
21739 { (char *)"NativeFontInfo_SetEncoding", (PyCFunction) _wrap_NativeFontInfo_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21740 { (char *)"NativeFontInfo_FromString", (PyCFunction) _wrap_NativeFontInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
21741 { (char *)"NativeFontInfo_ToString", (PyCFunction) _wrap_NativeFontInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
21742 { (char *)"NativeFontInfo___str__", (PyCFunction) _wrap_NativeFontInfo___str__, METH_VARARGS | METH_KEYWORDS, NULL},
21743 { (char *)"NativeFontInfo_FromUserString", (PyCFunction) _wrap_NativeFontInfo_FromUserString, METH_VARARGS | METH_KEYWORDS, NULL},
21744 { (char *)"NativeFontInfo_ToUserString", (PyCFunction) _wrap_NativeFontInfo_ToUserString, METH_VARARGS | METH_KEYWORDS, NULL},
21745 { (char *)"NativeFontInfo_swigregister", NativeFontInfo_swigregister, METH_VARARGS, NULL},
21746 { (char *)"NativeEncodingInfo_facename_set", (PyCFunction) _wrap_NativeEncodingInfo_facename_set, METH_VARARGS | METH_KEYWORDS, NULL},
21747 { (char *)"NativeEncodingInfo_facename_get", (PyCFunction) _wrap_NativeEncodingInfo_facename_get, METH_VARARGS | METH_KEYWORDS, NULL},
21748 { (char *)"NativeEncodingInfo_encoding_set", (PyCFunction) _wrap_NativeEncodingInfo_encoding_set, METH_VARARGS | METH_KEYWORDS, NULL},
21749 { (char *)"NativeEncodingInfo_encoding_get", (PyCFunction) _wrap_NativeEncodingInfo_encoding_get, METH_VARARGS | METH_KEYWORDS, NULL},
21750 { (char *)"new_NativeEncodingInfo", (PyCFunction) _wrap_new_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21751 { (char *)"delete_NativeEncodingInfo", (PyCFunction) _wrap_delete_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21752 { (char *)"NativeEncodingInfo_FromString", (PyCFunction) _wrap_NativeEncodingInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
21753 { (char *)"NativeEncodingInfo_ToString", (PyCFunction) _wrap_NativeEncodingInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
21754 { (char *)"NativeEncodingInfo_swigregister", NativeEncodingInfo_swigregister, METH_VARARGS, NULL},
21755 { (char *)"GetNativeFontEncoding", (PyCFunction) _wrap_GetNativeFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21756 { (char *)"TestFontEncoding", (PyCFunction) _wrap_TestFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21757 { (char *)"new_FontMapper", (PyCFunction) _wrap_new_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
21758 { (char *)"delete_FontMapper", (PyCFunction) _wrap_delete_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
21759 { (char *)"FontMapper_Get", (PyCFunction) _wrap_FontMapper_Get, METH_VARARGS | METH_KEYWORDS, NULL},
21760 { (char *)"FontMapper_Set", (PyCFunction) _wrap_FontMapper_Set, METH_VARARGS | METH_KEYWORDS, NULL},
21761 { (char *)"FontMapper_CharsetToEncoding", (PyCFunction) _wrap_FontMapper_CharsetToEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21762 { (char *)"FontMapper_GetSupportedEncodingsCount", (PyCFunction) _wrap_FontMapper_GetSupportedEncodingsCount, METH_VARARGS | METH_KEYWORDS, NULL},
21763 { (char *)"FontMapper_GetEncoding", (PyCFunction) _wrap_FontMapper_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21764 { (char *)"FontMapper_GetEncodingName", (PyCFunction) _wrap_FontMapper_GetEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
21765 { (char *)"FontMapper_GetEncodingDescription", (PyCFunction) _wrap_FontMapper_GetEncodingDescription, METH_VARARGS | METH_KEYWORDS, NULL},
21766 { (char *)"FontMapper_GetEncodingFromName", (PyCFunction) _wrap_FontMapper_GetEncodingFromName, METH_VARARGS | METH_KEYWORDS, NULL},
21767 { (char *)"FontMapper_SetConfig", (PyCFunction) _wrap_FontMapper_SetConfig, METH_VARARGS | METH_KEYWORDS, NULL},
21768 { (char *)"FontMapper_SetConfigPath", (PyCFunction) _wrap_FontMapper_SetConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
21769 { (char *)"FontMapper_GetDefaultConfigPath", (PyCFunction) _wrap_FontMapper_GetDefaultConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
21770 { (char *)"FontMapper_GetAltForEncoding", (PyCFunction) _wrap_FontMapper_GetAltForEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21771 { (char *)"FontMapper_IsEncodingAvailable", (PyCFunction) _wrap_FontMapper_IsEncodingAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
21772 { (char *)"FontMapper_SetDialogParent", (PyCFunction) _wrap_FontMapper_SetDialogParent, METH_VARARGS | METH_KEYWORDS, NULL},
21773 { (char *)"FontMapper_SetDialogTitle", (PyCFunction) _wrap_FontMapper_SetDialogTitle, METH_VARARGS | METH_KEYWORDS, NULL},
21774 { (char *)"FontMapper_swigregister", FontMapper_swigregister, METH_VARARGS, NULL},
21775 { (char *)"new_Font", (PyCFunction) _wrap_new_Font, METH_VARARGS | METH_KEYWORDS, NULL},
21776 { (char *)"delete_Font", (PyCFunction) _wrap_delete_Font, METH_VARARGS | METH_KEYWORDS, NULL},
21777 { (char *)"new_FontFromNativeInfo", (PyCFunction) _wrap_new_FontFromNativeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21778 { (char *)"new_FontFromNativeInfoString", (PyCFunction) _wrap_new_FontFromNativeInfoString, METH_VARARGS | METH_KEYWORDS, NULL},
21779 { (char *)"new_FFont", (PyCFunction) _wrap_new_FFont, METH_VARARGS | METH_KEYWORDS, NULL},
21780 { (char *)"new_FontFromPixelSize", (PyCFunction) _wrap_new_FontFromPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21781 { (char *)"new_FFontFromPixelSize", (PyCFunction) _wrap_new_FFontFromPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21782 { (char *)"Font_Ok", (PyCFunction) _wrap_Font_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21783 { (char *)"Font___eq__", (PyCFunction) _wrap_Font___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
21784 { (char *)"Font___ne__", (PyCFunction) _wrap_Font___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
21785 { (char *)"Font_GetPointSize", (PyCFunction) _wrap_Font_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21786 { (char *)"Font_GetPixelSize", (PyCFunction) _wrap_Font_GetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21787 { (char *)"Font_IsUsingSizeInPixels", (PyCFunction) _wrap_Font_IsUsingSizeInPixels, METH_VARARGS | METH_KEYWORDS, NULL},
21788 { (char *)"Font_GetFamily", (PyCFunction) _wrap_Font_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
21789 { (char *)"Font_GetStyle", (PyCFunction) _wrap_Font_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21790 { (char *)"Font_GetWeight", (PyCFunction) _wrap_Font_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
21791 { (char *)"Font_GetUnderlined", (PyCFunction) _wrap_Font_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
21792 { (char *)"Font_GetFaceName", (PyCFunction) _wrap_Font_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
21793 { (char *)"Font_GetEncoding", (PyCFunction) _wrap_Font_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21794 { (char *)"Font_GetNativeFontInfo", (PyCFunction) _wrap_Font_GetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21795 { (char *)"Font_IsFixedWidth", (PyCFunction) _wrap_Font_IsFixedWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21796 { (char *)"Font_GetNativeFontInfoDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoDesc, METH_VARARGS | METH_KEYWORDS, NULL},
21797 { (char *)"Font_GetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
21798 { (char *)"Font_SetPointSize", (PyCFunction) _wrap_Font_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21799 { (char *)"Font_SetPixelSize", (PyCFunction) _wrap_Font_SetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
21800 { (char *)"Font_SetFamily", (PyCFunction) _wrap_Font_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
21801 { (char *)"Font_SetStyle", (PyCFunction) _wrap_Font_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
21802 { (char *)"Font_SetWeight", (PyCFunction) _wrap_Font_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
21803 { (char *)"Font_SetFaceName", (PyCFunction) _wrap_Font_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
21804 { (char *)"Font_SetUnderlined", (PyCFunction) _wrap_Font_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
21805 { (char *)"Font_SetEncoding", (PyCFunction) _wrap_Font_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21806 { (char *)"Font_SetNativeFontInfo", (PyCFunction) _wrap_Font_SetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21807 { (char *)"Font_SetNativeFontInfoFromString", (PyCFunction) _wrap_Font_SetNativeFontInfoFromString, METH_VARARGS | METH_KEYWORDS, NULL},
21808 { (char *)"Font_SetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_SetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
21809 { (char *)"Font_GetFamilyString", (PyCFunction) _wrap_Font_GetFamilyString, METH_VARARGS | METH_KEYWORDS, NULL},
21810 { (char *)"Font_GetStyleString", (PyCFunction) _wrap_Font_GetStyleString, METH_VARARGS | METH_KEYWORDS, NULL},
21811 { (char *)"Font_GetWeightString", (PyCFunction) _wrap_Font_GetWeightString, METH_VARARGS | METH_KEYWORDS, NULL},
21812 { (char *)"Font_SetNoAntiAliasing", (PyCFunction) _wrap_Font_SetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
21813 { (char *)"Font_GetNoAntiAliasing", (PyCFunction) _wrap_Font_GetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
21814 { (char *)"Font_GetDefaultEncoding", (PyCFunction) _wrap_Font_GetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21815 { (char *)"Font_SetDefaultEncoding", (PyCFunction) _wrap_Font_SetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21816 { (char *)"Font_swigregister", Font_swigregister, METH_VARARGS, NULL},
21817 { (char *)"new_FontEnumerator", (PyCFunction) _wrap_new_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
21818 { (char *)"delete_FontEnumerator", (PyCFunction) _wrap_delete_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
21819 { (char *)"FontEnumerator__setCallbackInfo", (PyCFunction) _wrap_FontEnumerator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21820 { (char *)"FontEnumerator_EnumerateFacenames", (PyCFunction) _wrap_FontEnumerator_EnumerateFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
21821 { (char *)"FontEnumerator_EnumerateEncodings", (PyCFunction) _wrap_FontEnumerator_EnumerateEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
21822 { (char *)"FontEnumerator_GetEncodings", (PyCFunction) _wrap_FontEnumerator_GetEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
21823 { (char *)"FontEnumerator_GetFacenames", (PyCFunction) _wrap_FontEnumerator_GetFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
21824 { (char *)"FontEnumerator_swigregister", FontEnumerator_swigregister, METH_VARARGS, NULL},
21825 { (char *)"LanguageInfo_Language_set", (PyCFunction) _wrap_LanguageInfo_Language_set, METH_VARARGS | METH_KEYWORDS, NULL},
21826 { (char *)"LanguageInfo_Language_get", (PyCFunction) _wrap_LanguageInfo_Language_get, METH_VARARGS | METH_KEYWORDS, NULL},
21827 { (char *)"LanguageInfo_CanonicalName_set", (PyCFunction) _wrap_LanguageInfo_CanonicalName_set, METH_VARARGS | METH_KEYWORDS, NULL},
21828 { (char *)"LanguageInfo_CanonicalName_get", (PyCFunction) _wrap_LanguageInfo_CanonicalName_get, METH_VARARGS | METH_KEYWORDS, NULL},
21829 { (char *)"LanguageInfo_Description_set", (PyCFunction) _wrap_LanguageInfo_Description_set, METH_VARARGS | METH_KEYWORDS, NULL},
21830 { (char *)"LanguageInfo_Description_get", (PyCFunction) _wrap_LanguageInfo_Description_get, METH_VARARGS | METH_KEYWORDS, NULL},
21831 { (char *)"LanguageInfo_swigregister", LanguageInfo_swigregister, METH_VARARGS, NULL},
21832 { (char *)"new_Locale", (PyCFunction) _wrap_new_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
21833 { (char *)"delete_Locale", (PyCFunction) _wrap_delete_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
21834 { (char *)"Locale_Init1", (PyCFunction) _wrap_Locale_Init1, METH_VARARGS | METH_KEYWORDS, NULL},
21835 { (char *)"Locale_Init2", (PyCFunction) _wrap_Locale_Init2, METH_VARARGS | METH_KEYWORDS, NULL},
21836 { (char *)"Locale_GetSystemLanguage", (PyCFunction) _wrap_Locale_GetSystemLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
21837 { (char *)"Locale_GetSystemEncoding", (PyCFunction) _wrap_Locale_GetSystemEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
21838 { (char *)"Locale_GetSystemEncodingName", (PyCFunction) _wrap_Locale_GetSystemEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
21839 { (char *)"Locale_IsOk", (PyCFunction) _wrap_Locale_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
21840 { (char *)"Locale_GetLocale", (PyCFunction) _wrap_Locale_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
21841 { (char *)"Locale_GetLanguage", (PyCFunction) _wrap_Locale_GetLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
21842 { (char *)"Locale_GetSysName", (PyCFunction) _wrap_Locale_GetSysName, METH_VARARGS | METH_KEYWORDS, NULL},
21843 { (char *)"Locale_GetCanonicalName", (PyCFunction) _wrap_Locale_GetCanonicalName, METH_VARARGS | METH_KEYWORDS, NULL},
21844 { (char *)"Locale_AddCatalogLookupPathPrefix", (PyCFunction) _wrap_Locale_AddCatalogLookupPathPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
21845 { (char *)"Locale_AddCatalog", (PyCFunction) _wrap_Locale_AddCatalog, METH_VARARGS | METH_KEYWORDS, NULL},
21846 { (char *)"Locale_IsLoaded", (PyCFunction) _wrap_Locale_IsLoaded, METH_VARARGS | METH_KEYWORDS, NULL},
21847 { (char *)"Locale_GetLanguageInfo", (PyCFunction) _wrap_Locale_GetLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21848 { (char *)"Locale_GetLanguageName", (PyCFunction) _wrap_Locale_GetLanguageName, METH_VARARGS | METH_KEYWORDS, NULL},
21849 { (char *)"Locale_FindLanguageInfo", (PyCFunction) _wrap_Locale_FindLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
21850 { (char *)"Locale_AddLanguage", (PyCFunction) _wrap_Locale_AddLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
21851 { (char *)"Locale_GetString", (PyCFunction) _wrap_Locale_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
21852 { (char *)"Locale_GetName", (PyCFunction) _wrap_Locale_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
21853 { (char *)"Locale_swigregister", Locale_swigregister, METH_VARARGS, NULL},
21854 { (char *)"GetLocale", (PyCFunction) _wrap_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
21855 { (char *)"GetTranslation", _wrap_GetTranslation, METH_VARARGS, NULL},
21856 { (char *)"new_EncodingConverter", (PyCFunction) _wrap_new_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
21857 { (char *)"delete_EncodingConverter", (PyCFunction) _wrap_delete_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
21858 { (char *)"EncodingConverter_Init", (PyCFunction) _wrap_EncodingConverter_Init, METH_VARARGS | METH_KEYWORDS, NULL},
21859 { (char *)"EncodingConverter_Convert", (PyCFunction) _wrap_EncodingConverter_Convert, METH_VARARGS | METH_KEYWORDS, NULL},
21860 { (char *)"EncodingConverter_GetPlatformEquivalents", (PyCFunction) _wrap_EncodingConverter_GetPlatformEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
21861 { (char *)"EncodingConverter_GetAllEquivalents", (PyCFunction) _wrap_EncodingConverter_GetAllEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
21862 { (char *)"EncodingConverter_CanConvert", (PyCFunction) _wrap_EncodingConverter_CanConvert, METH_VARARGS | METH_KEYWORDS, NULL},
21863 { (char *)"EncodingConverter_swigregister", EncodingConverter_swigregister, METH_VARARGS, NULL},
21864 { (char *)"delete_DC", (PyCFunction) _wrap_delete_DC, METH_VARARGS | METH_KEYWORDS, NULL},
21865 { (char *)"DC_BeginDrawing", (PyCFunction) _wrap_DC_BeginDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
21866 { (char *)"DC_EndDrawing", (PyCFunction) _wrap_DC_EndDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
21867 { (char *)"DC_FloodFill", (PyCFunction) _wrap_DC_FloodFill, METH_VARARGS | METH_KEYWORDS, NULL},
21868 { (char *)"DC_FloodFillPoint", (PyCFunction) _wrap_DC_FloodFillPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21869 { (char *)"DC_GetPixel", (PyCFunction) _wrap_DC_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
21870 { (char *)"DC_GetPixelPoint", (PyCFunction) _wrap_DC_GetPixelPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21871 { (char *)"DC_DrawLine", (PyCFunction) _wrap_DC_DrawLine, METH_VARARGS | METH_KEYWORDS, NULL},
21872 { (char *)"DC_DrawLinePoint", (PyCFunction) _wrap_DC_DrawLinePoint, METH_VARARGS | METH_KEYWORDS, NULL},
21873 { (char *)"DC_CrossHair", (PyCFunction) _wrap_DC_CrossHair, METH_VARARGS | METH_KEYWORDS, NULL},
21874 { (char *)"DC_CrossHairPoint", (PyCFunction) _wrap_DC_CrossHairPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21875 { (char *)"DC_DrawArc", (PyCFunction) _wrap_DC_DrawArc, METH_VARARGS | METH_KEYWORDS, NULL},
21876 { (char *)"DC_DrawArcPoint", (PyCFunction) _wrap_DC_DrawArcPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21877 { (char *)"DC_DrawCheckMark", (PyCFunction) _wrap_DC_DrawCheckMark, METH_VARARGS | METH_KEYWORDS, NULL},
21878 { (char *)"DC_DrawCheckMarkRect", (PyCFunction) _wrap_DC_DrawCheckMarkRect, METH_VARARGS | METH_KEYWORDS, NULL},
21879 { (char *)"DC_DrawEllipticArc", (PyCFunction) _wrap_DC_DrawEllipticArc, METH_VARARGS | METH_KEYWORDS, NULL},
21880 { (char *)"DC_DrawEllipticArcPointSize", (PyCFunction) _wrap_DC_DrawEllipticArcPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21881 { (char *)"DC_DrawPoint", (PyCFunction) _wrap_DC_DrawPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21882 { (char *)"DC_DrawPointPoint", (PyCFunction) _wrap_DC_DrawPointPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21883 { (char *)"DC_DrawRectangle", (PyCFunction) _wrap_DC_DrawRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
21884 { (char *)"DC_DrawRectangleRect", (PyCFunction) _wrap_DC_DrawRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
21885 { (char *)"DC_DrawRectanglePointSize", (PyCFunction) _wrap_DC_DrawRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21886 { (char *)"DC_DrawRoundedRectangle", (PyCFunction) _wrap_DC_DrawRoundedRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
21887 { (char *)"DC_DrawRoundedRectangleRect", (PyCFunction) _wrap_DC_DrawRoundedRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
21888 { (char *)"DC_DrawRoundedRectanglePointSize", (PyCFunction) _wrap_DC_DrawRoundedRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21889 { (char *)"DC_DrawCircle", (PyCFunction) _wrap_DC_DrawCircle, METH_VARARGS | METH_KEYWORDS, NULL},
21890 { (char *)"DC_DrawCirclePoint", (PyCFunction) _wrap_DC_DrawCirclePoint, METH_VARARGS | METH_KEYWORDS, NULL},
21891 { (char *)"DC_DrawEllipse", (PyCFunction) _wrap_DC_DrawEllipse, METH_VARARGS | METH_KEYWORDS, NULL},
21892 { (char *)"DC_DrawEllipseRect", (PyCFunction) _wrap_DC_DrawEllipseRect, METH_VARARGS | METH_KEYWORDS, NULL},
21893 { (char *)"DC_DrawEllipsePointSize", (PyCFunction) _wrap_DC_DrawEllipsePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21894 { (char *)"DC_DrawIcon", (PyCFunction) _wrap_DC_DrawIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21895 { (char *)"DC_DrawIconPoint", (PyCFunction) _wrap_DC_DrawIconPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21896 { (char *)"DC_DrawBitmap", (PyCFunction) _wrap_DC_DrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21897 { (char *)"DC_DrawBitmapPoint", (PyCFunction) _wrap_DC_DrawBitmapPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21898 { (char *)"DC_DrawText", (PyCFunction) _wrap_DC_DrawText, METH_VARARGS | METH_KEYWORDS, NULL},
21899 { (char *)"DC_DrawTextPoint", (PyCFunction) _wrap_DC_DrawTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21900 { (char *)"DC_DrawRotatedText", (PyCFunction) _wrap_DC_DrawRotatedText, METH_VARARGS | METH_KEYWORDS, NULL},
21901 { (char *)"DC_DrawRotatedTextPoint", (PyCFunction) _wrap_DC_DrawRotatedTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21902 { (char *)"DC_Blit", (PyCFunction) _wrap_DC_Blit, METH_VARARGS | METH_KEYWORDS, NULL},
21903 { (char *)"DC_BlitPointSize", (PyCFunction) _wrap_DC_BlitPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21904 { (char *)"DC_SetClippingRegion", (PyCFunction) _wrap_DC_SetClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21905 { (char *)"DC_SetClippingRegionPointSize", (PyCFunction) _wrap_DC_SetClippingRegionPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21906 { (char *)"DC_SetClippingRegionAsRegion", (PyCFunction) _wrap_DC_SetClippingRegionAsRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21907 { (char *)"DC_SetClippingRect", (PyCFunction) _wrap_DC_SetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
21908 { (char *)"DC_DrawLines", (PyCFunction) _wrap_DC_DrawLines, METH_VARARGS | METH_KEYWORDS, NULL},
21909 { (char *)"DC_DrawPolygon", (PyCFunction) _wrap_DC_DrawPolygon, METH_VARARGS | METH_KEYWORDS, NULL},
21910 { (char *)"DC_DrawLabel", (PyCFunction) _wrap_DC_DrawLabel, METH_VARARGS | METH_KEYWORDS, NULL},
21911 { (char *)"DC_DrawImageLabel", (PyCFunction) _wrap_DC_DrawImageLabel, METH_VARARGS | METH_KEYWORDS, NULL},
21912 { (char *)"DC_DrawSpline", (PyCFunction) _wrap_DC_DrawSpline, METH_VARARGS | METH_KEYWORDS, NULL},
21913 { (char *)"DC_Clear", (PyCFunction) _wrap_DC_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
21914 { (char *)"DC_StartDoc", (PyCFunction) _wrap_DC_StartDoc, METH_VARARGS | METH_KEYWORDS, NULL},
21915 { (char *)"DC_EndDoc", (PyCFunction) _wrap_DC_EndDoc, METH_VARARGS | METH_KEYWORDS, NULL},
21916 { (char *)"DC_StartPage", (PyCFunction) _wrap_DC_StartPage, METH_VARARGS | METH_KEYWORDS, NULL},
21917 { (char *)"DC_EndPage", (PyCFunction) _wrap_DC_EndPage, METH_VARARGS | METH_KEYWORDS, NULL},
21918 { (char *)"DC_SetFont", (PyCFunction) _wrap_DC_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
21919 { (char *)"DC_SetPen", (PyCFunction) _wrap_DC_SetPen, METH_VARARGS | METH_KEYWORDS, NULL},
21920 { (char *)"DC_SetBrush", (PyCFunction) _wrap_DC_SetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21921 { (char *)"DC_SetBackground", (PyCFunction) _wrap_DC_SetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21922 { (char *)"DC_SetBackgroundMode", (PyCFunction) _wrap_DC_SetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
21923 { (char *)"DC_SetPalette", (PyCFunction) _wrap_DC_SetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
21924 { (char *)"DC_DestroyClippingRegion", (PyCFunction) _wrap_DC_DestroyClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21925 { (char *)"DC_GetClippingBox", (PyCFunction) _wrap_DC_GetClippingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21926 { (char *)"DC_GetClippingRect", (PyCFunction) _wrap_DC_GetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
21927 { (char *)"DC_GetCharHeight", (PyCFunction) _wrap_DC_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21928 { (char *)"DC_GetCharWidth", (PyCFunction) _wrap_DC_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21929 { (char *)"DC_GetTextExtent", (PyCFunction) _wrap_DC_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21930 { (char *)"DC_GetFullTextExtent", (PyCFunction) _wrap_DC_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21931 { (char *)"DC_GetMultiLineTextExtent", (PyCFunction) _wrap_DC_GetMultiLineTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21932 { (char *)"DC_GetPartialTextExtents", (PyCFunction) _wrap_DC_GetPartialTextExtents, METH_VARARGS | METH_KEYWORDS, NULL},
21933 { (char *)"DC_GetSize", (PyCFunction) _wrap_DC_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21934 { (char *)"DC_GetSizeTuple", (PyCFunction) _wrap_DC_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21935 { (char *)"DC_GetSizeMM", (PyCFunction) _wrap_DC_GetSizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
21936 { (char *)"DC_GetSizeMMTuple", (PyCFunction) _wrap_DC_GetSizeMMTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21937 { (char *)"DC_DeviceToLogicalX", (PyCFunction) _wrap_DC_DeviceToLogicalX, METH_VARARGS | METH_KEYWORDS, NULL},
21938 { (char *)"DC_DeviceToLogicalY", (PyCFunction) _wrap_DC_DeviceToLogicalY, METH_VARARGS | METH_KEYWORDS, NULL},
21939 { (char *)"DC_DeviceToLogicalXRel", (PyCFunction) _wrap_DC_DeviceToLogicalXRel, METH_VARARGS | METH_KEYWORDS, NULL},
21940 { (char *)"DC_DeviceToLogicalYRel", (PyCFunction) _wrap_DC_DeviceToLogicalYRel, METH_VARARGS | METH_KEYWORDS, NULL},
21941 { (char *)"DC_LogicalToDeviceX", (PyCFunction) _wrap_DC_LogicalToDeviceX, METH_VARARGS | METH_KEYWORDS, NULL},
21942 { (char *)"DC_LogicalToDeviceY", (PyCFunction) _wrap_DC_LogicalToDeviceY, METH_VARARGS | METH_KEYWORDS, NULL},
21943 { (char *)"DC_LogicalToDeviceXRel", (PyCFunction) _wrap_DC_LogicalToDeviceXRel, METH_VARARGS | METH_KEYWORDS, NULL},
21944 { (char *)"DC_LogicalToDeviceYRel", (PyCFunction) _wrap_DC_LogicalToDeviceYRel, METH_VARARGS | METH_KEYWORDS, NULL},
21945 { (char *)"DC_CanDrawBitmap", (PyCFunction) _wrap_DC_CanDrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21946 { (char *)"DC_CanGetTextExtent", (PyCFunction) _wrap_DC_CanGetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21947 { (char *)"DC_GetDepth", (PyCFunction) _wrap_DC_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21948 { (char *)"DC_GetPPI", (PyCFunction) _wrap_DC_GetPPI, METH_VARARGS | METH_KEYWORDS, NULL},
21949 { (char *)"DC_Ok", (PyCFunction) _wrap_DC_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21950 { (char *)"DC_GetBackgroundMode", (PyCFunction) _wrap_DC_GetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
21951 { (char *)"DC_GetBackground", (PyCFunction) _wrap_DC_GetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21952 { (char *)"DC_GetBrush", (PyCFunction) _wrap_DC_GetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21953 { (char *)"DC_GetFont", (PyCFunction) _wrap_DC_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
21954 { (char *)"DC_GetPen", (PyCFunction) _wrap_DC_GetPen, METH_VARARGS | METH_KEYWORDS, NULL},
21955 { (char *)"DC_GetTextBackground", (PyCFunction) _wrap_DC_GetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21956 { (char *)"DC_GetTextForeground", (PyCFunction) _wrap_DC_GetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
21957 { (char *)"DC_SetTextForeground", (PyCFunction) _wrap_DC_SetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
21958 { (char *)"DC_SetTextBackground", (PyCFunction) _wrap_DC_SetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21959 { (char *)"DC_GetMapMode", (PyCFunction) _wrap_DC_GetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
21960 { (char *)"DC_SetMapMode", (PyCFunction) _wrap_DC_SetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
21961 { (char *)"DC_GetUserScale", (PyCFunction) _wrap_DC_GetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
21962 { (char *)"DC_SetUserScale", (PyCFunction) _wrap_DC_SetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
21963 { (char *)"DC_GetLogicalScale", (PyCFunction) _wrap_DC_GetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
21964 { (char *)"DC_SetLogicalScale", (PyCFunction) _wrap_DC_SetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
21965 { (char *)"DC_GetLogicalOrigin", (PyCFunction) _wrap_DC_GetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21966 { (char *)"DC_GetLogicalOriginTuple", (PyCFunction) _wrap_DC_GetLogicalOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21967 { (char *)"DC_SetLogicalOrigin", (PyCFunction) _wrap_DC_SetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21968 { (char *)"DC_SetLogicalOriginPoint", (PyCFunction) _wrap_DC_SetLogicalOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21969 { (char *)"DC_GetDeviceOrigin", (PyCFunction) _wrap_DC_GetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21970 { (char *)"DC_GetDeviceOriginTuple", (PyCFunction) _wrap_DC_GetDeviceOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21971 { (char *)"DC_SetDeviceOrigin", (PyCFunction) _wrap_DC_SetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21972 { (char *)"DC_SetDeviceOriginPoint", (PyCFunction) _wrap_DC_SetDeviceOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21973 { (char *)"DC_SetAxisOrientation", (PyCFunction) _wrap_DC_SetAxisOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
21974 { (char *)"DC_GetLogicalFunction", (PyCFunction) _wrap_DC_GetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
21975 { (char *)"DC_SetLogicalFunction", (PyCFunction) _wrap_DC_SetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
21976 { (char *)"DC_ComputeScaleAndOrigin", (PyCFunction) _wrap_DC_ComputeScaleAndOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21977 { (char *)"DC_CalcBoundingBox", (PyCFunction) _wrap_DC_CalcBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21978 { (char *)"DC_CalcBoundingBoxPoint", (PyCFunction) _wrap_DC_CalcBoundingBoxPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21979 { (char *)"DC_ResetBoundingBox", (PyCFunction) _wrap_DC_ResetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21980 { (char *)"DC_MinX", (PyCFunction) _wrap_DC_MinX, METH_VARARGS | METH_KEYWORDS, NULL},
21981 { (char *)"DC_MaxX", (PyCFunction) _wrap_DC_MaxX, METH_VARARGS | METH_KEYWORDS, NULL},
21982 { (char *)"DC_MinY", (PyCFunction) _wrap_DC_MinY, METH_VARARGS | METH_KEYWORDS, NULL},
21983 { (char *)"DC_MaxY", (PyCFunction) _wrap_DC_MaxY, METH_VARARGS | METH_KEYWORDS, NULL},
21984 { (char *)"DC_GetBoundingBox", (PyCFunction) _wrap_DC_GetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21985 { (char *)"DC_GetHDC", (PyCFunction) _wrap_DC_GetHDC, METH_VARARGS | METH_KEYWORDS, NULL},
21986 { (char *)"DC__DrawPointList", (PyCFunction) _wrap_DC__DrawPointList, METH_VARARGS | METH_KEYWORDS, NULL},
21987 { (char *)"DC__DrawLineList", (PyCFunction) _wrap_DC__DrawLineList, METH_VARARGS | METH_KEYWORDS, NULL},
21988 { (char *)"DC__DrawRectangleList", (PyCFunction) _wrap_DC__DrawRectangleList, METH_VARARGS | METH_KEYWORDS, NULL},
21989 { (char *)"DC__DrawEllipseList", (PyCFunction) _wrap_DC__DrawEllipseList, METH_VARARGS | METH_KEYWORDS, NULL},
21990 { (char *)"DC__DrawPolygonList", (PyCFunction) _wrap_DC__DrawPolygonList, METH_VARARGS | METH_KEYWORDS, NULL},
21991 { (char *)"DC__DrawTextList", (PyCFunction) _wrap_DC__DrawTextList, METH_VARARGS | METH_KEYWORDS, NULL},
21992 { (char *)"DC_swigregister", DC_swigregister, METH_VARARGS, NULL},
21993 { (char *)"new_MemoryDC", (PyCFunction) _wrap_new_MemoryDC, METH_VARARGS | METH_KEYWORDS, NULL},
21994 { (char *)"new_MemoryDCFromDC", (PyCFunction) _wrap_new_MemoryDCFromDC, METH_VARARGS | METH_KEYWORDS, NULL},
21995 { (char *)"MemoryDC_SelectObject", (PyCFunction) _wrap_MemoryDC_SelectObject, METH_VARARGS | METH_KEYWORDS, NULL},
21996 { (char *)"MemoryDC_swigregister", MemoryDC_swigregister, METH_VARARGS, NULL},
21997 { (char *)"new_BufferedDC", _wrap_new_BufferedDC, METH_VARARGS, NULL},
21998 { (char *)"delete_BufferedDC", (PyCFunction) _wrap_delete_BufferedDC, METH_VARARGS | METH_KEYWORDS, NULL},
21999 { (char *)"BufferedDC_UnMask", (PyCFunction) _wrap_BufferedDC_UnMask, METH_VARARGS | METH_KEYWORDS, NULL},
22000 { (char *)"BufferedDC_swigregister", BufferedDC_swigregister, METH_VARARGS, NULL},
22001 { (char *)"new_BufferedPaintDC", (PyCFunction) _wrap_new_BufferedPaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
22002 { (char *)"BufferedPaintDC_swigregister", BufferedPaintDC_swigregister, METH_VARARGS, NULL},
22003 { (char *)"new_ScreenDC", (PyCFunction) _wrap_new_ScreenDC, METH_VARARGS | METH_KEYWORDS, NULL},
22004 { (char *)"ScreenDC_StartDrawingOnTopWin", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTopWin, METH_VARARGS | METH_KEYWORDS, NULL},
22005 { (char *)"ScreenDC_StartDrawingOnTop", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
22006 { (char *)"ScreenDC_EndDrawingOnTop", (PyCFunction) _wrap_ScreenDC_EndDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
22007 { (char *)"ScreenDC_swigregister", ScreenDC_swigregister, METH_VARARGS, NULL},
22008 { (char *)"new_ClientDC", (PyCFunction) _wrap_new_ClientDC, METH_VARARGS | METH_KEYWORDS, NULL},
22009 { (char *)"ClientDC_swigregister", ClientDC_swigregister, METH_VARARGS, NULL},
22010 { (char *)"new_PaintDC", (PyCFunction) _wrap_new_PaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
22011 { (char *)"PaintDC_swigregister", PaintDC_swigregister, METH_VARARGS, NULL},
22012 { (char *)"new_WindowDC", (PyCFunction) _wrap_new_WindowDC, METH_VARARGS | METH_KEYWORDS, NULL},
22013 { (char *)"WindowDC_swigregister", WindowDC_swigregister, METH_VARARGS, NULL},
22014 { (char *)"new_MirrorDC", (PyCFunction) _wrap_new_MirrorDC, METH_VARARGS | METH_KEYWORDS, NULL},
22015 { (char *)"MirrorDC_swigregister", MirrorDC_swigregister, METH_VARARGS, NULL},
22016 { (char *)"new_PostScriptDC", (PyCFunction) _wrap_new_PostScriptDC, METH_VARARGS | METH_KEYWORDS, NULL},
22017 { (char *)"PostScriptDC_GetPrintData", (PyCFunction) _wrap_PostScriptDC_GetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
22018 { (char *)"PostScriptDC_SetPrintData", (PyCFunction) _wrap_PostScriptDC_SetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
22019 { (char *)"PostScriptDC_SetResolution", (PyCFunction) _wrap_PostScriptDC_SetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
22020 { (char *)"PostScriptDC_GetResolution", (PyCFunction) _wrap_PostScriptDC_GetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
22021 { (char *)"PostScriptDC_swigregister", PostScriptDC_swigregister, METH_VARARGS, NULL},
22022 { (char *)"new_MetaFile", (PyCFunction) _wrap_new_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
22023 { (char *)"delete_MetaFile", (PyCFunction) _wrap_delete_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
22024 { (char *)"MetaFile_Ok", (PyCFunction) _wrap_MetaFile_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
22025 { (char *)"MetaFile_SetClipboard", (PyCFunction) _wrap_MetaFile_SetClipboard, METH_VARARGS | METH_KEYWORDS, NULL},
22026 { (char *)"MetaFile_GetSize", (PyCFunction) _wrap_MetaFile_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
22027 { (char *)"MetaFile_GetWidth", (PyCFunction) _wrap_MetaFile_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
22028 { (char *)"MetaFile_GetHeight", (PyCFunction) _wrap_MetaFile_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
22029 { (char *)"MetaFile_GetFileName", (PyCFunction) _wrap_MetaFile_GetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
22030 { (char *)"MetaFile_swigregister", MetaFile_swigregister, METH_VARARGS, NULL},
22031 { (char *)"new_MetaFileDC", (PyCFunction) _wrap_new_MetaFileDC, METH_VARARGS | METH_KEYWORDS, NULL},
22032 { (char *)"MetaFileDC_Close", (PyCFunction) _wrap_MetaFileDC_Close, METH_VARARGS | METH_KEYWORDS, NULL},
22033 { (char *)"MetaFileDC_swigregister", MetaFileDC_swigregister, METH_VARARGS, NULL},
22034 { (char *)"new_PrinterDC", (PyCFunction) _wrap_new_PrinterDC, METH_VARARGS | METH_KEYWORDS, NULL},
22035 { (char *)"PrinterDC_swigregister", PrinterDC_swigregister, METH_VARARGS, NULL},
22036 { (char *)"new_ImageList", (PyCFunction) _wrap_new_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
22037 { (char *)"delete_ImageList", (PyCFunction) _wrap_delete_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
22038 { (char *)"ImageList_Add", (PyCFunction) _wrap_ImageList_Add, METH_VARARGS | METH_KEYWORDS, NULL},
22039 { (char *)"ImageList_AddWithColourMask", (PyCFunction) _wrap_ImageList_AddWithColourMask, METH_VARARGS | METH_KEYWORDS, NULL},
22040 { (char *)"ImageList_AddIcon", (PyCFunction) _wrap_ImageList_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
22041 { (char *)"ImageList_GetBitmap", (PyCFunction) _wrap_ImageList_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22042 { (char *)"ImageList_GetIcon", (PyCFunction) _wrap_ImageList_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
22043 { (char *)"ImageList_Replace", (PyCFunction) _wrap_ImageList_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
22044 { (char *)"ImageList_Draw", (PyCFunction) _wrap_ImageList_Draw, METH_VARARGS | METH_KEYWORDS, NULL},
22045 { (char *)"ImageList_GetImageCount", (PyCFunction) _wrap_ImageList_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
22046 { (char *)"ImageList_Remove", (PyCFunction) _wrap_ImageList_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
22047 { (char *)"ImageList_RemoveAll", (PyCFunction) _wrap_ImageList_RemoveAll, METH_VARARGS | METH_KEYWORDS, NULL},
22048 { (char *)"ImageList_GetSize", (PyCFunction) _wrap_ImageList_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
22049 { (char *)"ImageList_swigregister", ImageList_swigregister, METH_VARARGS, NULL},
22050 { (char *)"PenList_AddPen", (PyCFunction) _wrap_PenList_AddPen, METH_VARARGS | METH_KEYWORDS, NULL},
22051 { (char *)"PenList_FindOrCreatePen", (PyCFunction) _wrap_PenList_FindOrCreatePen, METH_VARARGS | METH_KEYWORDS, NULL},
22052 { (char *)"PenList_RemovePen", (PyCFunction) _wrap_PenList_RemovePen, METH_VARARGS | METH_KEYWORDS, NULL},
22053 { (char *)"PenList_GetCount", (PyCFunction) _wrap_PenList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
22054 { (char *)"PenList_swigregister", PenList_swigregister, METH_VARARGS, NULL},
22055 { (char *)"BrushList_AddBrush", (PyCFunction) _wrap_BrushList_AddBrush, METH_VARARGS | METH_KEYWORDS, NULL},
22056 { (char *)"BrushList_FindOrCreateBrush", (PyCFunction) _wrap_BrushList_FindOrCreateBrush, METH_VARARGS | METH_KEYWORDS, NULL},
22057 { (char *)"BrushList_RemoveBrush", (PyCFunction) _wrap_BrushList_RemoveBrush, METH_VARARGS | METH_KEYWORDS, NULL},
22058 { (char *)"BrushList_GetCount", (PyCFunction) _wrap_BrushList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
22059 { (char *)"BrushList_swigregister", BrushList_swigregister, METH_VARARGS, NULL},
22060 { (char *)"new_ColourDatabase", (PyCFunction) _wrap_new_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
22061 { (char *)"delete_ColourDatabase", (PyCFunction) _wrap_delete_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
22062 { (char *)"ColourDatabase_Find", (PyCFunction) _wrap_ColourDatabase_Find, METH_VARARGS | METH_KEYWORDS, NULL},
22063 { (char *)"ColourDatabase_FindName", (PyCFunction) _wrap_ColourDatabase_FindName, METH_VARARGS | METH_KEYWORDS, NULL},
22064 { (char *)"ColourDatabase_AddColour", (PyCFunction) _wrap_ColourDatabase_AddColour, METH_VARARGS | METH_KEYWORDS, NULL},
22065 { (char *)"ColourDatabase_Append", (PyCFunction) _wrap_ColourDatabase_Append, METH_VARARGS | METH_KEYWORDS, NULL},
22066 { (char *)"ColourDatabase_swigregister", ColourDatabase_swigregister, METH_VARARGS, NULL},
22067 { (char *)"FontList_AddFont", (PyCFunction) _wrap_FontList_AddFont, METH_VARARGS | METH_KEYWORDS, NULL},
22068 { (char *)"FontList_FindOrCreateFont", (PyCFunction) _wrap_FontList_FindOrCreateFont, METH_VARARGS | METH_KEYWORDS, NULL},
22069 { (char *)"FontList_RemoveFont", (PyCFunction) _wrap_FontList_RemoveFont, METH_VARARGS | METH_KEYWORDS, NULL},
22070 { (char *)"FontList_GetCount", (PyCFunction) _wrap_FontList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
22071 { (char *)"FontList_swigregister", FontList_swigregister, METH_VARARGS, NULL},
22072 { (char *)"new_Effects", (PyCFunction) _wrap_new_Effects, METH_VARARGS | METH_KEYWORDS, NULL},
22073 { (char *)"Effects_GetHighlightColour", (PyCFunction) _wrap_Effects_GetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
22074 { (char *)"Effects_GetLightShadow", (PyCFunction) _wrap_Effects_GetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
22075 { (char *)"Effects_GetFaceColour", (PyCFunction) _wrap_Effects_GetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
22076 { (char *)"Effects_GetMediumShadow", (PyCFunction) _wrap_Effects_GetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
22077 { (char *)"Effects_GetDarkShadow", (PyCFunction) _wrap_Effects_GetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
22078 { (char *)"Effects_SetHighlightColour", (PyCFunction) _wrap_Effects_SetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
22079 { (char *)"Effects_SetLightShadow", (PyCFunction) _wrap_Effects_SetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
22080 { (char *)"Effects_SetFaceColour", (PyCFunction) _wrap_Effects_SetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
22081 { (char *)"Effects_SetMediumShadow", (PyCFunction) _wrap_Effects_SetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
22082 { (char *)"Effects_SetDarkShadow", (PyCFunction) _wrap_Effects_SetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
22083 { (char *)"Effects_Set", (PyCFunction) _wrap_Effects_Set, METH_VARARGS | METH_KEYWORDS, NULL},
22084 { (char *)"Effects_DrawSunkenEdge", (PyCFunction) _wrap_Effects_DrawSunkenEdge, METH_VARARGS | METH_KEYWORDS, NULL},
22085 { (char *)"Effects_TileBitmap", (PyCFunction) _wrap_Effects_TileBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
22086 { (char *)"Effects_swigregister", Effects_swigregister, METH_VARARGS, NULL},
22087 { NULL, NULL, 0, NULL }
22088 };
22089
22090
22091 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
22092
22093 static void *_p_wxBufferedDCTo_p_wxMemoryDC(void *x) {
22094 return (void *)((wxMemoryDC *) ((wxBufferedDC *) x));
22095 }
22096 static void *_p_wxBufferedPaintDCTo_p_wxMemoryDC(void *x) {
22097 return (void *)((wxMemoryDC *) (wxBufferedDC *) ((wxBufferedPaintDC *) x));
22098 }
22099 static void *_p_wxIconTo_p_wxGDIObject(void *x) {
22100 return (void *)((wxGDIObject *) ((wxIcon *) x));
22101 }
22102 static void *_p_wxPaletteTo_p_wxGDIObject(void *x) {
22103 return (void *)((wxGDIObject *) ((wxPalette *) x));
22104 }
22105 static void *_p_wxPenTo_p_wxGDIObject(void *x) {
22106 return (void *)((wxGDIObject *) ((wxPen *) x));
22107 }
22108 static void *_p_wxFontTo_p_wxGDIObject(void *x) {
22109 return (void *)((wxGDIObject *) ((wxFont *) x));
22110 }
22111 static void *_p_wxCursorTo_p_wxGDIObject(void *x) {
22112 return (void *)((wxGDIObject *) ((wxCursor *) x));
22113 }
22114 static void *_p_wxBitmapTo_p_wxGDIObject(void *x) {
22115 return (void *)((wxGDIObject *) ((wxBitmap *) x));
22116 }
22117 static void *_p_wxRegionTo_p_wxGDIObject(void *x) {
22118 return (void *)((wxGDIObject *) ((wxRegion *) x));
22119 }
22120 static void *_p_wxBrushTo_p_wxGDIObject(void *x) {
22121 return (void *)((wxGDIObject *) ((wxBrush *) x));
22122 }
22123 static void *_p_wxBufferedDCTo_p_wxDC(void *x) {
22124 return (void *)((wxDC *) (wxMemoryDC *) ((wxBufferedDC *) x));
22125 }
22126 static void *_p_wxScreenDCTo_p_wxDC(void *x) {
22127 return (void *)((wxDC *) ((wxScreenDC *) x));
22128 }
22129 static void *_p_wxMirrorDCTo_p_wxDC(void *x) {
22130 return (void *)((wxDC *) ((wxMirrorDC *) x));
22131 }
22132 static void *_p_wxMemoryDCTo_p_wxDC(void *x) {
22133 return (void *)((wxDC *) ((wxMemoryDC *) x));
22134 }
22135 static void *_p_wxWindowDCTo_p_wxDC(void *x) {
22136 return (void *)((wxDC *) ((wxWindowDC *) x));
22137 }
22138 static void *_p_wxMetaFileDCTo_p_wxDC(void *x) {
22139 return (void *)((wxDC *) ((wxMetaFileDC *) x));
22140 }
22141 static void *_p_wxBufferedPaintDCTo_p_wxDC(void *x) {
22142 return (void *)((wxDC *) (wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
22143 }
22144 static void *_p_wxClientDCTo_p_wxDC(void *x) {
22145 return (void *)((wxDC *) ((wxClientDC *) x));
22146 }
22147 static void *_p_wxPaintDCTo_p_wxDC(void *x) {
22148 return (void *)((wxDC *) ((wxPaintDC *) x));
22149 }
22150 static void *_p_wxPostScriptDCTo_p_wxDC(void *x) {
22151 return (void *)((wxDC *) ((wxPostScriptDC *) x));
22152 }
22153 static void *_p_wxPrinterDCTo_p_wxDC(void *x) {
22154 return (void *)((wxDC *) ((wxPrinterDC *) x));
22155 }
22156 static void *_p_wxBufferedPaintDCTo_p_wxBufferedDC(void *x) {
22157 return (void *)((wxBufferedDC *) ((wxBufferedPaintDC *) x));
22158 }
22159 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
22160 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
22161 }
22162 static void *_p_wxPenTo_p_wxObject(void *x) {
22163 return (void *)((wxObject *) (wxGDIObject *) ((wxPen *) x));
22164 }
22165 static void *_p_wxRegionIteratorTo_p_wxObject(void *x) {
22166 return (void *)((wxObject *) ((wxRegionIterator *) x));
22167 }
22168 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
22169 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
22170 }
22171 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
22172 return (void *)((wxObject *) ((wxSizerItem *) x));
22173 }
22174 static void *_p_wxColourDatabaseTo_p_wxObject(void *x) {
22175 return (void *)((wxObject *) ((wxColourDatabase *) x));
22176 }
22177 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
22178 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
22179 }
22180 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
22181 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
22182 }
22183 static void *_p_wxIconTo_p_wxObject(void *x) {
22184 return (void *)((wxObject *) (wxGDIObject *) ((wxIcon *) x));
22185 }
22186 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
22187 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
22188 }
22189 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
22190 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
22191 }
22192 static void *_p_wxSizerTo_p_wxObject(void *x) {
22193 return (void *)((wxObject *) ((wxSizer *) x));
22194 }
22195 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
22196 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
22197 }
22198 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
22199 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
22200 }
22201 static void *_p_wxPenListTo_p_wxObject(void *x) {
22202 return (void *)((wxObject *) ((wxPenList *) x));
22203 }
22204 static void *_p_wxEventTo_p_wxObject(void *x) {
22205 return (void *)((wxObject *) ((wxEvent *) x));
22206 }
22207 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
22208 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
22209 }
22210 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
22211 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
22212 }
22213 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
22214 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
22215 }
22216 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
22217 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
22218 }
22219 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
22220 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
22221 }
22222 static void *_p_wxDCTo_p_wxObject(void *x) {
22223 return (void *)((wxObject *) ((wxDC *) x));
22224 }
22225 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
22226 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
22227 }
22228 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
22229 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
22230 }
22231 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
22232 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
22233 }
22234 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
22235 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
22236 }
22237 static void *_p_wxControlTo_p_wxObject(void *x) {
22238 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
22239 }
22240 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
22241 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
22242 }
22243 static void *_p_wxClientDCTo_p_wxObject(void *x) {
22244 return (void *)((wxObject *) (wxDC *) ((wxClientDC *) x));
22245 }
22246 static void *_p_wxFSFileTo_p_wxObject(void *x) {
22247 return (void *)((wxObject *) ((wxFSFile *) x));
22248 }
22249 static void *_p_wxMemoryDCTo_p_wxObject(void *x) {
22250 return (void *)((wxObject *) (wxDC *) ((wxMemoryDC *) x));
22251 }
22252 static void *_p_wxRegionTo_p_wxObject(void *x) {
22253 return (void *)((wxObject *) (wxGDIObject *) ((wxRegion *) x));
22254 }
22255 static void *_p_wxPySizerTo_p_wxObject(void *x) {
22256 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
22257 }
22258 static void *_p_wxWindowDCTo_p_wxObject(void *x) {
22259 return (void *)((wxObject *) (wxDC *) ((wxWindowDC *) x));
22260 }
22261 static void *_p_wxGDIObjectTo_p_wxObject(void *x) {
22262 return (void *)((wxObject *) ((wxGDIObject *) x));
22263 }
22264 static void *_p_wxEffectsTo_p_wxObject(void *x) {
22265 return (void *)((wxObject *) ((wxEffects *) x));
22266 }
22267 static void *_p_wxPyEventTo_p_wxObject(void *x) {
22268 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
22269 }
22270 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
22271 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
22272 }
22273 static void *_p_wxPostScriptDCTo_p_wxObject(void *x) {
22274 return (void *)((wxObject *) (wxDC *) ((wxPostScriptDC *) x));
22275 }
22276 static void *_p_wxShowEventTo_p_wxObject(void *x) {
22277 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
22278 }
22279 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
22280 return (void *)((wxObject *) ((wxMenuItem *) x));
22281 }
22282 static void *_p_wxDateEventTo_p_wxObject(void *x) {
22283 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
22284 }
22285 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
22286 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
22287 }
22288 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
22289 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
22290 }
22291 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
22292 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
22293 }
22294 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
22295 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
22296 }
22297 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
22298 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
22299 }
22300 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
22301 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
22302 }
22303 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
22304 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
22305 }
22306 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
22307 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
22308 }
22309 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
22310 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
22311 }
22312 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
22313 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
22314 }
22315 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
22316 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
22317 }
22318 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
22319 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
22320 }
22321 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
22322 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
22323 }
22324 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
22325 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
22326 }
22327 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
22328 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
22329 }
22330 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
22331 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
22332 }
22333 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
22334 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
22335 }
22336 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
22337 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
22338 }
22339 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
22340 return (void *)((wxObject *) ((wxImageHandler *) x));
22341 }
22342 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
22343 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
22344 }
22345 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
22346 return (void *)((wxObject *) ((wxEvtHandler *) x));
22347 }
22348 static void *_p_wxBufferedPaintDCTo_p_wxObject(void *x) {
22349 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
22350 }
22351 static void *_p_wxPaintDCTo_p_wxObject(void *x) {
22352 return (void *)((wxObject *) (wxDC *) ((wxPaintDC *) x));
22353 }
22354 static void *_p_wxPrinterDCTo_p_wxObject(void *x) {
22355 return (void *)((wxObject *) (wxDC *) ((wxPrinterDC *) x));
22356 }
22357 static void *_p_wxScreenDCTo_p_wxObject(void *x) {
22358 return (void *)((wxObject *) (wxDC *) ((wxScreenDC *) x));
22359 }
22360 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
22361 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
22362 }
22363 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
22364 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
22365 }
22366 static void *_p_wxImageTo_p_wxObject(void *x) {
22367 return (void *)((wxObject *) ((wxImage *) x));
22368 }
22369 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
22370 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
22371 }
22372 static void *_p_wxPaletteTo_p_wxObject(void *x) {
22373 return (void *)((wxObject *) (wxGDIObject *) ((wxPalette *) x));
22374 }
22375 static void *_p_wxBufferedDCTo_p_wxObject(void *x) {
22376 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *) ((wxBufferedDC *) x));
22377 }
22378 static void *_p_wxImageListTo_p_wxObject(void *x) {
22379 return (void *)((wxObject *) ((wxImageList *) x));
22380 }
22381 static void *_p_wxCursorTo_p_wxObject(void *x) {
22382 return (void *)((wxObject *) (wxGDIObject *) ((wxCursor *) x));
22383 }
22384 static void *_p_wxEncodingConverterTo_p_wxObject(void *x) {
22385 return (void *)((wxObject *) ((wxEncodingConverter *) x));
22386 }
22387 static void *_p_wxMirrorDCTo_p_wxObject(void *x) {
22388 return (void *)((wxObject *) (wxDC *) ((wxMirrorDC *) x));
22389 }
22390 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
22391 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
22392 }
22393 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
22394 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
22395 }
22396 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
22397 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
22398 }
22399 static void *_p_wxWindowTo_p_wxObject(void *x) {
22400 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
22401 }
22402 static void *_p_wxMenuTo_p_wxObject(void *x) {
22403 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
22404 }
22405 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
22406 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
22407 }
22408 static void *_p_wxMetaFileDCTo_p_wxObject(void *x) {
22409 return (void *)((wxObject *) (wxDC *) ((wxMetaFileDC *) x));
22410 }
22411 static void *_p_wxBrushListTo_p_wxObject(void *x) {
22412 return (void *)((wxObject *) ((wxBrushList *) x));
22413 }
22414 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
22415 return (void *)((wxObject *) ((wxFileSystem *) x));
22416 }
22417 static void *_p_wxBitmapTo_p_wxObject(void *x) {
22418 return (void *)((wxObject *) (wxGDIObject *) ((wxBitmap *) x));
22419 }
22420 static void *_p_wxMaskTo_p_wxObject(void *x) {
22421 return (void *)((wxObject *) ((wxMask *) x));
22422 }
22423 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
22424 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
22425 }
22426 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
22427 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
22428 }
22429 static void *_p_wxPyAppTo_p_wxObject(void *x) {
22430 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
22431 }
22432 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
22433 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
22434 }
22435 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
22436 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
22437 }
22438 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
22439 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
22440 }
22441 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
22442 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
22443 }
22444 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
22445 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
22446 }
22447 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
22448 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
22449 }
22450 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
22451 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
22452 }
22453 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
22454 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
22455 }
22456 static void *_p_wxFontTo_p_wxObject(void *x) {
22457 return (void *)((wxObject *) (wxGDIObject *) ((wxFont *) x));
22458 }
22459 static void *_p_wxBrushTo_p_wxObject(void *x) {
22460 return (void *)((wxObject *) (wxGDIObject *) ((wxBrush *) x));
22461 }
22462 static void *_p_wxMetaFileTo_p_wxObject(void *x) {
22463 return (void *)((wxObject *) ((wxMetaFile *) x));
22464 }
22465 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
22466 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
22467 }
22468 static void *_p_wxColourTo_p_wxObject(void *x) {
22469 return (void *)((wxObject *) ((wxColour *) x));
22470 }
22471 static void *_p_wxFontListTo_p_wxObject(void *x) {
22472 return (void *)((wxObject *) ((wxFontList *) x));
22473 }
22474 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
22475 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
22476 }
22477 static void *_p_wxValidatorTo_p_wxObject(void *x) {
22478 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
22479 }
22480 static void *_p_wxControlTo_p_wxWindow(void *x) {
22481 return (void *)((wxWindow *) ((wxControl *) x));
22482 }
22483 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
22484 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
22485 }
22486 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
22487 return (void *)((wxWindow *) ((wxMenuBar *) x));
22488 }
22489 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}};
22490 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}};
22491 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}};
22492 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}};
22493 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}};
22494 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}};
22495 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}};
22496 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}};
22497 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}};
22498 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}};
22499 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}};
22500 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}};
22501 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}};
22502 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}};
22503 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}};
22504 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}};
22505 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}};
22506 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}};
22507 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}};
22508 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}};
22509 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}};
22510 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}};
22511 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}};
22512 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}};
22513 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}};
22514 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}};
22515 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}};
22516 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}};
22517 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}};
22518 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}};
22519 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}};
22520 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}};
22521 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}};
22522 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}};
22523 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}};
22524 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}};
22525 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}};
22526 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}};
22527 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}};
22528 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}};
22529 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}};
22530 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}};
22531 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}};
22532 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}};
22533 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}};
22534 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}};
22535 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}};
22536 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}};
22537 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}};
22538 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}};
22539 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}};
22540 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}};
22541 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}};
22542 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}};
22543 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}};
22544 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}};
22545 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}};
22546 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}};
22547 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}};
22548 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}};
22549 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}};
22550 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}};
22551
22552 static swig_type_info *swig_types_initial[] = {
22553 _swigt__p_wxPostScriptDC,
22554 _swigt__p_wxBrush,
22555 _swigt__p_wxColour,
22556 _swigt__p_wxDC,
22557 _swigt__p_wxMirrorDC,
22558 _swigt__p_form_ops_t,
22559 _swigt__p_wxDuplexMode,
22560 _swigt__p_wxPyFontEnumerator,
22561 _swigt__p_char,
22562 _swigt__p_wxIconLocation,
22563 _swigt__p_wxImage,
22564 _swigt__p_wxMetaFileDC,
22565 _swigt__p_wxMask,
22566 _swigt__p_wxSize,
22567 _swigt__p_wxFont,
22568 _swigt__p_wxWindow,
22569 _swigt__p_double,
22570 _swigt__p_wxMemoryDC,
22571 _swigt__p_wxFontMapper,
22572 _swigt__p_wxEffects,
22573 _swigt__p_wxNativeEncodingInfo,
22574 _swigt__p_wxPalette,
22575 _swigt__p_wxBitmap,
22576 _swigt__p_wxObject,
22577 _swigt__p_wxRegionIterator,
22578 _swigt__p_wxRect,
22579 _swigt__p_wxPaperSize,
22580 _swigt__p_wxString,
22581 _swigt__unsigned_int,
22582 _swigt__p_unsigned_int,
22583 _swigt__p_wxPrinterDC,
22584 _swigt__p_wxIconBundle,
22585 _swigt__p_wxPoint,
22586 _swigt__p_wxDash,
22587 _swigt__p_wxScreenDC,
22588 _swigt__p_wxCursor,
22589 _swigt__p_wxClientDC,
22590 _swigt__p_wxBufferedDC,
22591 _swigt__p_wxImageList,
22592 _swigt__p_unsigned_char,
22593 _swigt__p_wxGDIObject,
22594 _swigt__p_wxIcon,
22595 _swigt__p_wxLocale,
22596 _swigt__ptrdiff_t,
22597 _swigt__std__ptrdiff_t,
22598 _swigt__p_wxRegion,
22599 _swigt__p_wxConfigBase,
22600 _swigt__p_wxLanguageInfo,
22601 _swigt__p_wxWindowDC,
22602 _swigt__p_wxPrintData,
22603 _swigt__p_wxBrushList,
22604 _swigt__p_wxFontList,
22605 _swigt__p_wxPen,
22606 _swigt__p_wxBufferedPaintDC,
22607 _swigt__p_wxPaintDC,
22608 _swigt__p_wxPenList,
22609 _swigt__p_int,
22610 _swigt__p_wxMetaFile,
22611 _swigt__p_unsigned_long,
22612 _swigt__p_wxNativeFontInfo,
22613 _swigt__p_wxEncodingConverter,
22614 _swigt__p_wxColourDatabase,
22615 0
22616 };
22617
22618
22619 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
22620
22621 static swig_const_info swig_const_table[] = {
22622 {0, 0, 0, 0.0, 0, 0}};
22623
22624 #ifdef __cplusplus
22625 }
22626 #endif
22627
22628
22629 #ifdef __cplusplus
22630 extern "C" {
22631 #endif
22632
22633 /* Python-specific SWIG API */
22634 #define SWIG_newvarlink() SWIG_Python_newvarlink()
22635 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
22636 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
22637
22638 /* -----------------------------------------------------------------------------
22639 * global variable support code.
22640 * ----------------------------------------------------------------------------- */
22641
22642 typedef struct swig_globalvar {
22643 char *name; /* Name of global variable */
22644 PyObject *(*get_attr)(); /* Return the current value */
22645 int (*set_attr)(PyObject *); /* Set the value */
22646 struct swig_globalvar *next;
22647 } swig_globalvar;
22648
22649 typedef struct swig_varlinkobject {
22650 PyObject_HEAD
22651 swig_globalvar *vars;
22652 } swig_varlinkobject;
22653
22654 static PyObject *
22655 swig_varlink_repr(swig_varlinkobject *v) {
22656 v = v;
22657 return PyString_FromString("<Swig global variables>");
22658 }
22659
22660 static int
22661 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
22662 swig_globalvar *var;
22663 flags = flags;
22664 fprintf(fp,"Swig global variables { ");
22665 for (var = v->vars; var; var=var->next) {
22666 fprintf(fp,"%s", var->name);
22667 if (var->next) fprintf(fp,", ");
22668 }
22669 fprintf(fp," }\n");
22670 return 0;
22671 }
22672
22673 static PyObject *
22674 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
22675 swig_globalvar *var = v->vars;
22676 while (var) {
22677 if (strcmp(var->name,n) == 0) {
22678 return (*var->get_attr)();
22679 }
22680 var = var->next;
22681 }
22682 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
22683 return NULL;
22684 }
22685
22686 static int
22687 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
22688 swig_globalvar *var = v->vars;
22689 while (var) {
22690 if (strcmp(var->name,n) == 0) {
22691 return (*var->set_attr)(p);
22692 }
22693 var = var->next;
22694 }
22695 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
22696 return 1;
22697 }
22698
22699 static PyTypeObject varlinktype = {
22700 PyObject_HEAD_INIT(0)
22701 0, /* Number of items in variable part (ob_size) */
22702 (char *)"swigvarlink", /* Type name (tp_name) */
22703 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
22704 0, /* Itemsize (tp_itemsize) */
22705 0, /* Deallocator (tp_dealloc) */
22706 (printfunc) swig_varlink_print, /* Print (tp_print) */
22707 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
22708 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
22709 0, /* tp_compare */
22710 (reprfunc) swig_varlink_repr, /* tp_repr */
22711 0, /* tp_as_number */
22712 0, /* tp_as_sequence */
22713 0, /* tp_as_mapping */
22714 0, /* tp_hash */
22715 0, /* tp_call */
22716 0, /* tp_str */
22717 0, /* tp_getattro */
22718 0, /* tp_setattro */
22719 0, /* tp_as_buffer */
22720 0, /* tp_flags */
22721 0, /* tp_doc */
22722 #if PY_VERSION_HEX >= 0x02000000
22723 0, /* tp_traverse */
22724 0, /* tp_clear */
22725 #endif
22726 #if PY_VERSION_HEX >= 0x02010000
22727 0, /* tp_richcompare */
22728 0, /* tp_weaklistoffset */
22729 #endif
22730 #if PY_VERSION_HEX >= 0x02020000
22731 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
22732 #endif
22733 #if PY_VERSION_HEX >= 0x02030000
22734 0, /* tp_del */
22735 #endif
22736 #ifdef COUNT_ALLOCS
22737 0,0,0,0 /* tp_alloc -> tp_next */
22738 #endif
22739 };
22740
22741 /* Create a variable linking object for use later */
22742 static PyObject *
22743 SWIG_Python_newvarlink(void) {
22744 swig_varlinkobject *result = 0;
22745 result = PyMem_NEW(swig_varlinkobject,1);
22746 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
22747 result->ob_type = &varlinktype;
22748 result->vars = 0;
22749 result->ob_refcnt = 0;
22750 Py_XINCREF((PyObject *) result);
22751 return ((PyObject*) result);
22752 }
22753
22754 static void
22755 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
22756 swig_varlinkobject *v;
22757 swig_globalvar *gv;
22758 v= (swig_varlinkobject *) p;
22759 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
22760 gv->name = (char *) malloc(strlen(name)+1);
22761 strcpy(gv->name,name);
22762 gv->get_attr = get_attr;
22763 gv->set_attr = set_attr;
22764 gv->next = v->vars;
22765 v->vars = gv;
22766 }
22767
22768 /* -----------------------------------------------------------------------------
22769 * constants/methods manipulation
22770 * ----------------------------------------------------------------------------- */
22771
22772 /* Install Constants */
22773 static void
22774 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
22775 PyObject *obj = 0;
22776 size_t i;
22777 for (i = 0; constants[i].type; i++) {
22778 switch(constants[i].type) {
22779 case SWIG_PY_INT:
22780 obj = PyInt_FromLong(constants[i].lvalue);
22781 break;
22782 case SWIG_PY_FLOAT:
22783 obj = PyFloat_FromDouble(constants[i].dvalue);
22784 break;
22785 case SWIG_PY_STRING:
22786 if (constants[i].pvalue) {
22787 obj = PyString_FromString((char *) constants[i].pvalue);
22788 } else {
22789 Py_INCREF(Py_None);
22790 obj = Py_None;
22791 }
22792 break;
22793 case SWIG_PY_POINTER:
22794 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
22795 break;
22796 case SWIG_PY_BINARY:
22797 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
22798 break;
22799 default:
22800 obj = 0;
22801 break;
22802 }
22803 if (obj) {
22804 PyDict_SetItemString(d,constants[i].name,obj);
22805 Py_DECREF(obj);
22806 }
22807 }
22808 }
22809
22810 /* -----------------------------------------------------------------------------*/
22811 /* Fix SwigMethods to carry the callback ptrs when needed */
22812 /* -----------------------------------------------------------------------------*/
22813
22814 static void
22815 SWIG_Python_FixMethods(PyMethodDef *methods,
22816 swig_const_info *const_table,
22817 swig_type_info **types,
22818 swig_type_info **types_initial) {
22819 size_t i;
22820 for (i = 0; methods[i].ml_name; ++i) {
22821 char *c = methods[i].ml_doc;
22822 if (c && (c = strstr(c, "swig_ptr: "))) {
22823 int j;
22824 swig_const_info *ci = 0;
22825 char *name = c + 10;
22826 for (j = 0; const_table[j].type; j++) {
22827 if (strncmp(const_table[j].name, name,
22828 strlen(const_table[j].name)) == 0) {
22829 ci = &(const_table[j]);
22830 break;
22831 }
22832 }
22833 if (ci) {
22834 size_t shift = (ci->ptype) - types;
22835 swig_type_info *ty = types_initial[shift];
22836 size_t ldoc = (c - methods[i].ml_doc);
22837 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
22838 char *ndoc = (char*)malloc(ldoc + lptr + 10);
22839 char *buff = ndoc;
22840 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
22841 strncpy(buff, methods[i].ml_doc, ldoc);
22842 buff += ldoc;
22843 strncpy(buff, "swig_ptr: ", 10);
22844 buff += 10;
22845 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
22846 methods[i].ml_doc = ndoc;
22847 }
22848 }
22849 }
22850 }
22851
22852 /* -----------------------------------------------------------------------------*
22853 * Initialize type list
22854 * -----------------------------------------------------------------------------*/
22855
22856 #if PY_MAJOR_VERSION < 2
22857 /* PyModule_AddObject function was introduced in Python 2.0. The following function
22858 is copied out of Python/modsupport.c in python version 2.3.4 */
22859 static int
22860 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
22861 {
22862 PyObject *dict;
22863 if (!PyModule_Check(m)) {
22864 PyErr_SetString(PyExc_TypeError,
22865 "PyModule_AddObject() needs module as first arg");
22866 return -1;
22867 }
22868 if (!o) {
22869 PyErr_SetString(PyExc_TypeError,
22870 "PyModule_AddObject() needs non-NULL value");
22871 return -1;
22872 }
22873
22874 dict = PyModule_GetDict(m);
22875 if (dict == NULL) {
22876 /* Internal error -- modules must have a dict! */
22877 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
22878 PyModule_GetName(m));
22879 return -1;
22880 }
22881 if (PyDict_SetItemString(dict, name, o))
22882 return -1;
22883 Py_DECREF(o);
22884 return 0;
22885 }
22886 #endif
22887
22888 static swig_type_info **
22889 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
22890 static PyMethodDef swig_empty_runtime_method_table[] = {
22891 {
22892 NULL, NULL, 0, NULL
22893 }
22894 };/* Sentinel */
22895
22896 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
22897 swig_empty_runtime_method_table);
22898 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
22899 if (pointer && module) {
22900 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
22901 }
22902 return type_list_handle;
22903 }
22904
22905 static swig_type_info **
22906 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
22907 swig_type_info **type_pointer;
22908
22909 /* first check if module already created */
22910 type_pointer = SWIG_Python_GetTypeListHandle();
22911 if (type_pointer) {
22912 return type_pointer;
22913 } else {
22914 /* create a new module and variable */
22915 return SWIG_Python_SetTypeListHandle(type_list_handle);
22916 }
22917 }
22918
22919 #ifdef __cplusplus
22920 }
22921 #endif
22922
22923 /* -----------------------------------------------------------------------------*
22924 * Partial Init method
22925 * -----------------------------------------------------------------------------*/
22926
22927 #ifdef SWIG_LINK_RUNTIME
22928 #ifdef __cplusplus
22929 extern "C"
22930 #endif
22931 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
22932 #endif
22933
22934 #ifdef __cplusplus
22935 extern "C"
22936 #endif
22937 SWIGEXPORT(void) SWIG_init(void) {
22938 static PyObject *SWIG_globals = 0;
22939 static int typeinit = 0;
22940 PyObject *m, *d;
22941 int i;
22942 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
22943
22944 /* Fix SwigMethods to carry the callback ptrs when needed */
22945 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
22946
22947 m = Py_InitModule((char *) SWIG_name, SwigMethods);
22948 d = PyModule_GetDict(m);
22949
22950 if (!typeinit) {
22951 #ifdef SWIG_LINK_RUNTIME
22952 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
22953 #else
22954 # ifndef SWIG_STATIC_RUNTIME
22955 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
22956 # endif
22957 #endif
22958 for (i = 0; swig_types_initial[i]; i++) {
22959 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
22960 }
22961 typeinit = 1;
22962 }
22963 SWIG_InstallConstants(d,swig_const_table);
22964
22965 {
22966 PyDict_SetItemString(d,"OutRegion", SWIG_From_int((int)(wxOutRegion)));
22967 }
22968 {
22969 PyDict_SetItemString(d,"PartRegion", SWIG_From_int((int)(wxPartRegion)));
22970 }
22971 {
22972 PyDict_SetItemString(d,"InRegion", SWIG_From_int((int)(wxInRegion)));
22973 }
22974 {
22975 PyDict_SetItemString(d,"FONTFAMILY_DEFAULT", SWIG_From_int((int)(wxFONTFAMILY_DEFAULT)));
22976 }
22977 {
22978 PyDict_SetItemString(d,"FONTFAMILY_DECORATIVE", SWIG_From_int((int)(wxFONTFAMILY_DECORATIVE)));
22979 }
22980 {
22981 PyDict_SetItemString(d,"FONTFAMILY_ROMAN", SWIG_From_int((int)(wxFONTFAMILY_ROMAN)));
22982 }
22983 {
22984 PyDict_SetItemString(d,"FONTFAMILY_SCRIPT", SWIG_From_int((int)(wxFONTFAMILY_SCRIPT)));
22985 }
22986 {
22987 PyDict_SetItemString(d,"FONTFAMILY_SWISS", SWIG_From_int((int)(wxFONTFAMILY_SWISS)));
22988 }
22989 {
22990 PyDict_SetItemString(d,"FONTFAMILY_MODERN", SWIG_From_int((int)(wxFONTFAMILY_MODERN)));
22991 }
22992 {
22993 PyDict_SetItemString(d,"FONTFAMILY_TELETYPE", SWIG_From_int((int)(wxFONTFAMILY_TELETYPE)));
22994 }
22995 {
22996 PyDict_SetItemString(d,"FONTFAMILY_MAX", SWIG_From_int((int)(wxFONTFAMILY_MAX)));
22997 }
22998 {
22999 PyDict_SetItemString(d,"FONTFAMILY_UNKNOWN", SWIG_From_int((int)(wxFONTFAMILY_UNKNOWN)));
23000 }
23001 {
23002 PyDict_SetItemString(d,"FONTSTYLE_NORMAL", SWIG_From_int((int)(wxFONTSTYLE_NORMAL)));
23003 }
23004 {
23005 PyDict_SetItemString(d,"FONTSTYLE_ITALIC", SWIG_From_int((int)(wxFONTSTYLE_ITALIC)));
23006 }
23007 {
23008 PyDict_SetItemString(d,"FONTSTYLE_SLANT", SWIG_From_int((int)(wxFONTSTYLE_SLANT)));
23009 }
23010 {
23011 PyDict_SetItemString(d,"FONTSTYLE_MAX", SWIG_From_int((int)(wxFONTSTYLE_MAX)));
23012 }
23013 {
23014 PyDict_SetItemString(d,"FONTWEIGHT_NORMAL", SWIG_From_int((int)(wxFONTWEIGHT_NORMAL)));
23015 }
23016 {
23017 PyDict_SetItemString(d,"FONTWEIGHT_LIGHT", SWIG_From_int((int)(wxFONTWEIGHT_LIGHT)));
23018 }
23019 {
23020 PyDict_SetItemString(d,"FONTWEIGHT_BOLD", SWIG_From_int((int)(wxFONTWEIGHT_BOLD)));
23021 }
23022 {
23023 PyDict_SetItemString(d,"FONTWEIGHT_MAX", SWIG_From_int((int)(wxFONTWEIGHT_MAX)));
23024 }
23025 {
23026 PyDict_SetItemString(d,"FONTFLAG_DEFAULT", SWIG_From_int((int)(wxFONTFLAG_DEFAULT)));
23027 }
23028 {
23029 PyDict_SetItemString(d,"FONTFLAG_ITALIC", SWIG_From_int((int)(wxFONTFLAG_ITALIC)));
23030 }
23031 {
23032 PyDict_SetItemString(d,"FONTFLAG_SLANT", SWIG_From_int((int)(wxFONTFLAG_SLANT)));
23033 }
23034 {
23035 PyDict_SetItemString(d,"FONTFLAG_LIGHT", SWIG_From_int((int)(wxFONTFLAG_LIGHT)));
23036 }
23037 {
23038 PyDict_SetItemString(d,"FONTFLAG_BOLD", SWIG_From_int((int)(wxFONTFLAG_BOLD)));
23039 }
23040 {
23041 PyDict_SetItemString(d,"FONTFLAG_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_ANTIALIASED)));
23042 }
23043 {
23044 PyDict_SetItemString(d,"FONTFLAG_NOT_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_NOT_ANTIALIASED)));
23045 }
23046 {
23047 PyDict_SetItemString(d,"FONTFLAG_UNDERLINED", SWIG_From_int((int)(wxFONTFLAG_UNDERLINED)));
23048 }
23049 {
23050 PyDict_SetItemString(d,"FONTFLAG_STRIKETHROUGH", SWIG_From_int((int)(wxFONTFLAG_STRIKETHROUGH)));
23051 }
23052 {
23053 PyDict_SetItemString(d,"FONTFLAG_MASK", SWIG_From_int((int)(wxFONTFLAG_MASK)));
23054 }
23055 {
23056 PyDict_SetItemString(d,"FONTENCODING_SYSTEM", SWIG_From_int((int)(wxFONTENCODING_SYSTEM)));
23057 }
23058 {
23059 PyDict_SetItemString(d,"FONTENCODING_DEFAULT", SWIG_From_int((int)(wxFONTENCODING_DEFAULT)));
23060 }
23061 {
23062 PyDict_SetItemString(d,"FONTENCODING_ISO8859_1", SWIG_From_int((int)(wxFONTENCODING_ISO8859_1)));
23063 }
23064 {
23065 PyDict_SetItemString(d,"FONTENCODING_ISO8859_2", SWIG_From_int((int)(wxFONTENCODING_ISO8859_2)));
23066 }
23067 {
23068 PyDict_SetItemString(d,"FONTENCODING_ISO8859_3", SWIG_From_int((int)(wxFONTENCODING_ISO8859_3)));
23069 }
23070 {
23071 PyDict_SetItemString(d,"FONTENCODING_ISO8859_4", SWIG_From_int((int)(wxFONTENCODING_ISO8859_4)));
23072 }
23073 {
23074 PyDict_SetItemString(d,"FONTENCODING_ISO8859_5", SWIG_From_int((int)(wxFONTENCODING_ISO8859_5)));
23075 }
23076 {
23077 PyDict_SetItemString(d,"FONTENCODING_ISO8859_6", SWIG_From_int((int)(wxFONTENCODING_ISO8859_6)));
23078 }
23079 {
23080 PyDict_SetItemString(d,"FONTENCODING_ISO8859_7", SWIG_From_int((int)(wxFONTENCODING_ISO8859_7)));
23081 }
23082 {
23083 PyDict_SetItemString(d,"FONTENCODING_ISO8859_8", SWIG_From_int((int)(wxFONTENCODING_ISO8859_8)));
23084 }
23085 {
23086 PyDict_SetItemString(d,"FONTENCODING_ISO8859_9", SWIG_From_int((int)(wxFONTENCODING_ISO8859_9)));
23087 }
23088 {
23089 PyDict_SetItemString(d,"FONTENCODING_ISO8859_10", SWIG_From_int((int)(wxFONTENCODING_ISO8859_10)));
23090 }
23091 {
23092 PyDict_SetItemString(d,"FONTENCODING_ISO8859_11", SWIG_From_int((int)(wxFONTENCODING_ISO8859_11)));
23093 }
23094 {
23095 PyDict_SetItemString(d,"FONTENCODING_ISO8859_12", SWIG_From_int((int)(wxFONTENCODING_ISO8859_12)));
23096 }
23097 {
23098 PyDict_SetItemString(d,"FONTENCODING_ISO8859_13", SWIG_From_int((int)(wxFONTENCODING_ISO8859_13)));
23099 }
23100 {
23101 PyDict_SetItemString(d,"FONTENCODING_ISO8859_14", SWIG_From_int((int)(wxFONTENCODING_ISO8859_14)));
23102 }
23103 {
23104 PyDict_SetItemString(d,"FONTENCODING_ISO8859_15", SWIG_From_int((int)(wxFONTENCODING_ISO8859_15)));
23105 }
23106 {
23107 PyDict_SetItemString(d,"FONTENCODING_ISO8859_MAX", SWIG_From_int((int)(wxFONTENCODING_ISO8859_MAX)));
23108 }
23109 {
23110 PyDict_SetItemString(d,"FONTENCODING_KOI8", SWIG_From_int((int)(wxFONTENCODING_KOI8)));
23111 }
23112 {
23113 PyDict_SetItemString(d,"FONTENCODING_KOI8_U", SWIG_From_int((int)(wxFONTENCODING_KOI8_U)));
23114 }
23115 {
23116 PyDict_SetItemString(d,"FONTENCODING_ALTERNATIVE", SWIG_From_int((int)(wxFONTENCODING_ALTERNATIVE)));
23117 }
23118 {
23119 PyDict_SetItemString(d,"FONTENCODING_BULGARIAN", SWIG_From_int((int)(wxFONTENCODING_BULGARIAN)));
23120 }
23121 {
23122 PyDict_SetItemString(d,"FONTENCODING_CP437", SWIG_From_int((int)(wxFONTENCODING_CP437)));
23123 }
23124 {
23125 PyDict_SetItemString(d,"FONTENCODING_CP850", SWIG_From_int((int)(wxFONTENCODING_CP850)));
23126 }
23127 {
23128 PyDict_SetItemString(d,"FONTENCODING_CP852", SWIG_From_int((int)(wxFONTENCODING_CP852)));
23129 }
23130 {
23131 PyDict_SetItemString(d,"FONTENCODING_CP855", SWIG_From_int((int)(wxFONTENCODING_CP855)));
23132 }
23133 {
23134 PyDict_SetItemString(d,"FONTENCODING_CP866", SWIG_From_int((int)(wxFONTENCODING_CP866)));
23135 }
23136 {
23137 PyDict_SetItemString(d,"FONTENCODING_CP874", SWIG_From_int((int)(wxFONTENCODING_CP874)));
23138 }
23139 {
23140 PyDict_SetItemString(d,"FONTENCODING_CP932", SWIG_From_int((int)(wxFONTENCODING_CP932)));
23141 }
23142 {
23143 PyDict_SetItemString(d,"FONTENCODING_CP936", SWIG_From_int((int)(wxFONTENCODING_CP936)));
23144 }
23145 {
23146 PyDict_SetItemString(d,"FONTENCODING_CP949", SWIG_From_int((int)(wxFONTENCODING_CP949)));
23147 }
23148 {
23149 PyDict_SetItemString(d,"FONTENCODING_CP950", SWIG_From_int((int)(wxFONTENCODING_CP950)));
23150 }
23151 {
23152 PyDict_SetItemString(d,"FONTENCODING_CP1250", SWIG_From_int((int)(wxFONTENCODING_CP1250)));
23153 }
23154 {
23155 PyDict_SetItemString(d,"FONTENCODING_CP1251", SWIG_From_int((int)(wxFONTENCODING_CP1251)));
23156 }
23157 {
23158 PyDict_SetItemString(d,"FONTENCODING_CP1252", SWIG_From_int((int)(wxFONTENCODING_CP1252)));
23159 }
23160 {
23161 PyDict_SetItemString(d,"FONTENCODING_CP1253", SWIG_From_int((int)(wxFONTENCODING_CP1253)));
23162 }
23163 {
23164 PyDict_SetItemString(d,"FONTENCODING_CP1254", SWIG_From_int((int)(wxFONTENCODING_CP1254)));
23165 }
23166 {
23167 PyDict_SetItemString(d,"FONTENCODING_CP1255", SWIG_From_int((int)(wxFONTENCODING_CP1255)));
23168 }
23169 {
23170 PyDict_SetItemString(d,"FONTENCODING_CP1256", SWIG_From_int((int)(wxFONTENCODING_CP1256)));
23171 }
23172 {
23173 PyDict_SetItemString(d,"FONTENCODING_CP1257", SWIG_From_int((int)(wxFONTENCODING_CP1257)));
23174 }
23175 {
23176 PyDict_SetItemString(d,"FONTENCODING_CP12_MAX", SWIG_From_int((int)(wxFONTENCODING_CP12_MAX)));
23177 }
23178 {
23179 PyDict_SetItemString(d,"FONTENCODING_UTF7", SWIG_From_int((int)(wxFONTENCODING_UTF7)));
23180 }
23181 {
23182 PyDict_SetItemString(d,"FONTENCODING_UTF8", SWIG_From_int((int)(wxFONTENCODING_UTF8)));
23183 }
23184 {
23185 PyDict_SetItemString(d,"FONTENCODING_EUC_JP", SWIG_From_int((int)(wxFONTENCODING_EUC_JP)));
23186 }
23187 {
23188 PyDict_SetItemString(d,"FONTENCODING_UTF16BE", SWIG_From_int((int)(wxFONTENCODING_UTF16BE)));
23189 }
23190 {
23191 PyDict_SetItemString(d,"FONTENCODING_UTF16LE", SWIG_From_int((int)(wxFONTENCODING_UTF16LE)));
23192 }
23193 {
23194 PyDict_SetItemString(d,"FONTENCODING_UTF32BE", SWIG_From_int((int)(wxFONTENCODING_UTF32BE)));
23195 }
23196 {
23197 PyDict_SetItemString(d,"FONTENCODING_UTF32LE", SWIG_From_int((int)(wxFONTENCODING_UTF32LE)));
23198 }
23199 {
23200 PyDict_SetItemString(d,"FONTENCODING_MACROMAN", SWIG_From_int((int)(wxFONTENCODING_MACROMAN)));
23201 }
23202 {
23203 PyDict_SetItemString(d,"FONTENCODING_MACJAPANESE", SWIG_From_int((int)(wxFONTENCODING_MACJAPANESE)));
23204 }
23205 {
23206 PyDict_SetItemString(d,"FONTENCODING_MACCHINESETRAD", SWIG_From_int((int)(wxFONTENCODING_MACCHINESETRAD)));
23207 }
23208 {
23209 PyDict_SetItemString(d,"FONTENCODING_MACKOREAN", SWIG_From_int((int)(wxFONTENCODING_MACKOREAN)));
23210 }
23211 {
23212 PyDict_SetItemString(d,"FONTENCODING_MACARABIC", SWIG_From_int((int)(wxFONTENCODING_MACARABIC)));
23213 }
23214 {
23215 PyDict_SetItemString(d,"FONTENCODING_MACHEBREW", SWIG_From_int((int)(wxFONTENCODING_MACHEBREW)));
23216 }
23217 {
23218 PyDict_SetItemString(d,"FONTENCODING_MACGREEK", SWIG_From_int((int)(wxFONTENCODING_MACGREEK)));
23219 }
23220 {
23221 PyDict_SetItemString(d,"FONTENCODING_MACCYRILLIC", SWIG_From_int((int)(wxFONTENCODING_MACCYRILLIC)));
23222 }
23223 {
23224 PyDict_SetItemString(d,"FONTENCODING_MACDEVANAGARI", SWIG_From_int((int)(wxFONTENCODING_MACDEVANAGARI)));
23225 }
23226 {
23227 PyDict_SetItemString(d,"FONTENCODING_MACGURMUKHI", SWIG_From_int((int)(wxFONTENCODING_MACGURMUKHI)));
23228 }
23229 {
23230 PyDict_SetItemString(d,"FONTENCODING_MACGUJARATI", SWIG_From_int((int)(wxFONTENCODING_MACGUJARATI)));
23231 }
23232 {
23233 PyDict_SetItemString(d,"FONTENCODING_MACORIYA", SWIG_From_int((int)(wxFONTENCODING_MACORIYA)));
23234 }
23235 {
23236 PyDict_SetItemString(d,"FONTENCODING_MACBENGALI", SWIG_From_int((int)(wxFONTENCODING_MACBENGALI)));
23237 }
23238 {
23239 PyDict_SetItemString(d,"FONTENCODING_MACTAMIL", SWIG_From_int((int)(wxFONTENCODING_MACTAMIL)));
23240 }
23241 {
23242 PyDict_SetItemString(d,"FONTENCODING_MACTELUGU", SWIG_From_int((int)(wxFONTENCODING_MACTELUGU)));
23243 }
23244 {
23245 PyDict_SetItemString(d,"FONTENCODING_MACKANNADA", SWIG_From_int((int)(wxFONTENCODING_MACKANNADA)));
23246 }
23247 {
23248 PyDict_SetItemString(d,"FONTENCODING_MACMALAJALAM", SWIG_From_int((int)(wxFONTENCODING_MACMALAJALAM)));
23249 }
23250 {
23251 PyDict_SetItemString(d,"FONTENCODING_MACSINHALESE", SWIG_From_int((int)(wxFONTENCODING_MACSINHALESE)));
23252 }
23253 {
23254 PyDict_SetItemString(d,"FONTENCODING_MACBURMESE", SWIG_From_int((int)(wxFONTENCODING_MACBURMESE)));
23255 }
23256 {
23257 PyDict_SetItemString(d,"FONTENCODING_MACKHMER", SWIG_From_int((int)(wxFONTENCODING_MACKHMER)));
23258 }
23259 {
23260 PyDict_SetItemString(d,"FONTENCODING_MACTHAI", SWIG_From_int((int)(wxFONTENCODING_MACTHAI)));
23261 }
23262 {
23263 PyDict_SetItemString(d,"FONTENCODING_MACLAOTIAN", SWIG_From_int((int)(wxFONTENCODING_MACLAOTIAN)));
23264 }
23265 {
23266 PyDict_SetItemString(d,"FONTENCODING_MACGEORGIAN", SWIG_From_int((int)(wxFONTENCODING_MACGEORGIAN)));
23267 }
23268 {
23269 PyDict_SetItemString(d,"FONTENCODING_MACARMENIAN", SWIG_From_int((int)(wxFONTENCODING_MACARMENIAN)));
23270 }
23271 {
23272 PyDict_SetItemString(d,"FONTENCODING_MACCHINESESIMP", SWIG_From_int((int)(wxFONTENCODING_MACCHINESESIMP)));
23273 }
23274 {
23275 PyDict_SetItemString(d,"FONTENCODING_MACTIBETAN", SWIG_From_int((int)(wxFONTENCODING_MACTIBETAN)));
23276 }
23277 {
23278 PyDict_SetItemString(d,"FONTENCODING_MACMONGOLIAN", SWIG_From_int((int)(wxFONTENCODING_MACMONGOLIAN)));
23279 }
23280 {
23281 PyDict_SetItemString(d,"FONTENCODING_MACETHIOPIC", SWIG_From_int((int)(wxFONTENCODING_MACETHIOPIC)));
23282 }
23283 {
23284 PyDict_SetItemString(d,"FONTENCODING_MACCENTRALEUR", SWIG_From_int((int)(wxFONTENCODING_MACCENTRALEUR)));
23285 }
23286 {
23287 PyDict_SetItemString(d,"FONTENCODING_MACVIATNAMESE", SWIG_From_int((int)(wxFONTENCODING_MACVIATNAMESE)));
23288 }
23289 {
23290 PyDict_SetItemString(d,"FONTENCODING_MACARABICEXT", SWIG_From_int((int)(wxFONTENCODING_MACARABICEXT)));
23291 }
23292 {
23293 PyDict_SetItemString(d,"FONTENCODING_MACSYMBOL", SWIG_From_int((int)(wxFONTENCODING_MACSYMBOL)));
23294 }
23295 {
23296 PyDict_SetItemString(d,"FONTENCODING_MACDINGBATS", SWIG_From_int((int)(wxFONTENCODING_MACDINGBATS)));
23297 }
23298 {
23299 PyDict_SetItemString(d,"FONTENCODING_MACTURKISH", SWIG_From_int((int)(wxFONTENCODING_MACTURKISH)));
23300 }
23301 {
23302 PyDict_SetItemString(d,"FONTENCODING_MACCROATIAN", SWIG_From_int((int)(wxFONTENCODING_MACCROATIAN)));
23303 }
23304 {
23305 PyDict_SetItemString(d,"FONTENCODING_MACICELANDIC", SWIG_From_int((int)(wxFONTENCODING_MACICELANDIC)));
23306 }
23307 {
23308 PyDict_SetItemString(d,"FONTENCODING_MACROMANIAN", SWIG_From_int((int)(wxFONTENCODING_MACROMANIAN)));
23309 }
23310 {
23311 PyDict_SetItemString(d,"FONTENCODING_MACCELTIC", SWIG_From_int((int)(wxFONTENCODING_MACCELTIC)));
23312 }
23313 {
23314 PyDict_SetItemString(d,"FONTENCODING_MACGAELIC", SWIG_From_int((int)(wxFONTENCODING_MACGAELIC)));
23315 }
23316 {
23317 PyDict_SetItemString(d,"FONTENCODING_MACKEYBOARD", SWIG_From_int((int)(wxFONTENCODING_MACKEYBOARD)));
23318 }
23319 {
23320 PyDict_SetItemString(d,"FONTENCODING_MACMIN", SWIG_From_int((int)(wxFONTENCODING_MACMIN)));
23321 }
23322 {
23323 PyDict_SetItemString(d,"FONTENCODING_MACMAX", SWIG_From_int((int)(wxFONTENCODING_MACMAX)));
23324 }
23325 {
23326 PyDict_SetItemString(d,"FONTENCODING_MAX", SWIG_From_int((int)(wxFONTENCODING_MAX)));
23327 }
23328 {
23329 PyDict_SetItemString(d,"FONTENCODING_UTF16", SWIG_From_int((int)(wxFONTENCODING_UTF16)));
23330 }
23331 {
23332 PyDict_SetItemString(d,"FONTENCODING_UTF32", SWIG_From_int((int)(wxFONTENCODING_UTF32)));
23333 }
23334 {
23335 PyDict_SetItemString(d,"FONTENCODING_UNICODE", SWIG_From_int((int)(wxFONTENCODING_UNICODE)));
23336 }
23337 {
23338 PyDict_SetItemString(d,"FONTENCODING_GB2312", SWIG_From_int((int)(wxFONTENCODING_GB2312)));
23339 }
23340 {
23341 PyDict_SetItemString(d,"FONTENCODING_BIG5", SWIG_From_int((int)(wxFONTENCODING_BIG5)));
23342 }
23343 {
23344 PyDict_SetItemString(d,"FONTENCODING_SHIFT_JIS", SWIG_From_int((int)(wxFONTENCODING_SHIFT_JIS)));
23345 }
23346
23347 wxPyPtrTypeMap_Add("wxFontEnumerator", "wxPyFontEnumerator");
23348
23349 {
23350 PyDict_SetItemString(d,"LANGUAGE_DEFAULT", SWIG_From_int((int)(wxLANGUAGE_DEFAULT)));
23351 }
23352 {
23353 PyDict_SetItemString(d,"LANGUAGE_UNKNOWN", SWIG_From_int((int)(wxLANGUAGE_UNKNOWN)));
23354 }
23355 {
23356 PyDict_SetItemString(d,"LANGUAGE_ABKHAZIAN", SWIG_From_int((int)(wxLANGUAGE_ABKHAZIAN)));
23357 }
23358 {
23359 PyDict_SetItemString(d,"LANGUAGE_AFAR", SWIG_From_int((int)(wxLANGUAGE_AFAR)));
23360 }
23361 {
23362 PyDict_SetItemString(d,"LANGUAGE_AFRIKAANS", SWIG_From_int((int)(wxLANGUAGE_AFRIKAANS)));
23363 }
23364 {
23365 PyDict_SetItemString(d,"LANGUAGE_ALBANIAN", SWIG_From_int((int)(wxLANGUAGE_ALBANIAN)));
23366 }
23367 {
23368 PyDict_SetItemString(d,"LANGUAGE_AMHARIC", SWIG_From_int((int)(wxLANGUAGE_AMHARIC)));
23369 }
23370 {
23371 PyDict_SetItemString(d,"LANGUAGE_ARABIC", SWIG_From_int((int)(wxLANGUAGE_ARABIC)));
23372 }
23373 {
23374 PyDict_SetItemString(d,"LANGUAGE_ARABIC_ALGERIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_ALGERIA)));
23375 }
23376 {
23377 PyDict_SetItemString(d,"LANGUAGE_ARABIC_BAHRAIN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_BAHRAIN)));
23378 }
23379 {
23380 PyDict_SetItemString(d,"LANGUAGE_ARABIC_EGYPT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_EGYPT)));
23381 }
23382 {
23383 PyDict_SetItemString(d,"LANGUAGE_ARABIC_IRAQ", SWIG_From_int((int)(wxLANGUAGE_ARABIC_IRAQ)));
23384 }
23385 {
23386 PyDict_SetItemString(d,"LANGUAGE_ARABIC_JORDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_JORDAN)));
23387 }
23388 {
23389 PyDict_SetItemString(d,"LANGUAGE_ARABIC_KUWAIT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_KUWAIT)));
23390 }
23391 {
23392 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LEBANON", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LEBANON)));
23393 }
23394 {
23395 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LIBYA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LIBYA)));
23396 }
23397 {
23398 PyDict_SetItemString(d,"LANGUAGE_ARABIC_MOROCCO", SWIG_From_int((int)(wxLANGUAGE_ARABIC_MOROCCO)));
23399 }
23400 {
23401 PyDict_SetItemString(d,"LANGUAGE_ARABIC_OMAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_OMAN)));
23402 }
23403 {
23404 PyDict_SetItemString(d,"LANGUAGE_ARABIC_QATAR", SWIG_From_int((int)(wxLANGUAGE_ARABIC_QATAR)));
23405 }
23406 {
23407 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SAUDI_ARABIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SAUDI_ARABIA)));
23408 }
23409 {
23410 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SUDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SUDAN)));
23411 }
23412 {
23413 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SYRIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SYRIA)));
23414 }
23415 {
23416 PyDict_SetItemString(d,"LANGUAGE_ARABIC_TUNISIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_TUNISIA)));
23417 }
23418 {
23419 PyDict_SetItemString(d,"LANGUAGE_ARABIC_UAE", SWIG_From_int((int)(wxLANGUAGE_ARABIC_UAE)));
23420 }
23421 {
23422 PyDict_SetItemString(d,"LANGUAGE_ARABIC_YEMEN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_YEMEN)));
23423 }
23424 {
23425 PyDict_SetItemString(d,"LANGUAGE_ARMENIAN", SWIG_From_int((int)(wxLANGUAGE_ARMENIAN)));
23426 }
23427 {
23428 PyDict_SetItemString(d,"LANGUAGE_ASSAMESE", SWIG_From_int((int)(wxLANGUAGE_ASSAMESE)));
23429 }
23430 {
23431 PyDict_SetItemString(d,"LANGUAGE_AYMARA", SWIG_From_int((int)(wxLANGUAGE_AYMARA)));
23432 }
23433 {
23434 PyDict_SetItemString(d,"LANGUAGE_AZERI", SWIG_From_int((int)(wxLANGUAGE_AZERI)));
23435 }
23436 {
23437 PyDict_SetItemString(d,"LANGUAGE_AZERI_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_AZERI_CYRILLIC)));
23438 }
23439 {
23440 PyDict_SetItemString(d,"LANGUAGE_AZERI_LATIN", SWIG_From_int((int)(wxLANGUAGE_AZERI_LATIN)));
23441 }
23442 {
23443 PyDict_SetItemString(d,"LANGUAGE_BASHKIR", SWIG_From_int((int)(wxLANGUAGE_BASHKIR)));
23444 }
23445 {
23446 PyDict_SetItemString(d,"LANGUAGE_BASQUE", SWIG_From_int((int)(wxLANGUAGE_BASQUE)));
23447 }
23448 {
23449 PyDict_SetItemString(d,"LANGUAGE_BELARUSIAN", SWIG_From_int((int)(wxLANGUAGE_BELARUSIAN)));
23450 }
23451 {
23452 PyDict_SetItemString(d,"LANGUAGE_BENGALI", SWIG_From_int((int)(wxLANGUAGE_BENGALI)));
23453 }
23454 {
23455 PyDict_SetItemString(d,"LANGUAGE_BHUTANI", SWIG_From_int((int)(wxLANGUAGE_BHUTANI)));
23456 }
23457 {
23458 PyDict_SetItemString(d,"LANGUAGE_BIHARI", SWIG_From_int((int)(wxLANGUAGE_BIHARI)));
23459 }
23460 {
23461 PyDict_SetItemString(d,"LANGUAGE_BISLAMA", SWIG_From_int((int)(wxLANGUAGE_BISLAMA)));
23462 }
23463 {
23464 PyDict_SetItemString(d,"LANGUAGE_BRETON", SWIG_From_int((int)(wxLANGUAGE_BRETON)));
23465 }
23466 {
23467 PyDict_SetItemString(d,"LANGUAGE_BULGARIAN", SWIG_From_int((int)(wxLANGUAGE_BULGARIAN)));
23468 }
23469 {
23470 PyDict_SetItemString(d,"LANGUAGE_BURMESE", SWIG_From_int((int)(wxLANGUAGE_BURMESE)));
23471 }
23472 {
23473 PyDict_SetItemString(d,"LANGUAGE_CAMBODIAN", SWIG_From_int((int)(wxLANGUAGE_CAMBODIAN)));
23474 }
23475 {
23476 PyDict_SetItemString(d,"LANGUAGE_CATALAN", SWIG_From_int((int)(wxLANGUAGE_CATALAN)));
23477 }
23478 {
23479 PyDict_SetItemString(d,"LANGUAGE_CHINESE", SWIG_From_int((int)(wxLANGUAGE_CHINESE)));
23480 }
23481 {
23482 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SIMPLIFIED", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SIMPLIFIED)));
23483 }
23484 {
23485 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TRADITIONAL", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TRADITIONAL)));
23486 }
23487 {
23488 PyDict_SetItemString(d,"LANGUAGE_CHINESE_HONGKONG", SWIG_From_int((int)(wxLANGUAGE_CHINESE_HONGKONG)));
23489 }
23490 {
23491 PyDict_SetItemString(d,"LANGUAGE_CHINESE_MACAU", SWIG_From_int((int)(wxLANGUAGE_CHINESE_MACAU)));
23492 }
23493 {
23494 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SINGAPORE", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SINGAPORE)));
23495 }
23496 {
23497 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TAIWAN", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TAIWAN)));
23498 }
23499 {
23500 PyDict_SetItemString(d,"LANGUAGE_CORSICAN", SWIG_From_int((int)(wxLANGUAGE_CORSICAN)));
23501 }
23502 {
23503 PyDict_SetItemString(d,"LANGUAGE_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_CROATIAN)));
23504 }
23505 {
23506 PyDict_SetItemString(d,"LANGUAGE_CZECH", SWIG_From_int((int)(wxLANGUAGE_CZECH)));
23507 }
23508 {
23509 PyDict_SetItemString(d,"LANGUAGE_DANISH", SWIG_From_int((int)(wxLANGUAGE_DANISH)));
23510 }
23511 {
23512 PyDict_SetItemString(d,"LANGUAGE_DUTCH", SWIG_From_int((int)(wxLANGUAGE_DUTCH)));
23513 }
23514 {
23515 PyDict_SetItemString(d,"LANGUAGE_DUTCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_DUTCH_BELGIAN)));
23516 }
23517 {
23518 PyDict_SetItemString(d,"LANGUAGE_ENGLISH", SWIG_From_int((int)(wxLANGUAGE_ENGLISH)));
23519 }
23520 {
23521 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_UK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_UK)));
23522 }
23523 {
23524 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_US", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_US)));
23525 }
23526 {
23527 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_AUSTRALIA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_AUSTRALIA)));
23528 }
23529 {
23530 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BELIZE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BELIZE)));
23531 }
23532 {
23533 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BOTSWANA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BOTSWANA)));
23534 }
23535 {
23536 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CANADA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CANADA)));
23537 }
23538 {
23539 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CARIBBEAN", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CARIBBEAN)));
23540 }
23541 {
23542 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_DENMARK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_DENMARK)));
23543 }
23544 {
23545 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_EIRE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_EIRE)));
23546 }
23547 {
23548 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_JAMAICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_JAMAICA)));
23549 }
23550 {
23551 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_NEW_ZEALAND", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_NEW_ZEALAND)));
23552 }
23553 {
23554 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_PHILIPPINES", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_PHILIPPINES)));
23555 }
23556 {
23557 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_SOUTH_AFRICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_SOUTH_AFRICA)));
23558 }
23559 {
23560 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_TRINIDAD", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_TRINIDAD)));
23561 }
23562 {
23563 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_ZIMBABWE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_ZIMBABWE)));
23564 }
23565 {
23566 PyDict_SetItemString(d,"LANGUAGE_ESPERANTO", SWIG_From_int((int)(wxLANGUAGE_ESPERANTO)));
23567 }
23568 {
23569 PyDict_SetItemString(d,"LANGUAGE_ESTONIAN", SWIG_From_int((int)(wxLANGUAGE_ESTONIAN)));
23570 }
23571 {
23572 PyDict_SetItemString(d,"LANGUAGE_FAEROESE", SWIG_From_int((int)(wxLANGUAGE_FAEROESE)));
23573 }
23574 {
23575 PyDict_SetItemString(d,"LANGUAGE_FARSI", SWIG_From_int((int)(wxLANGUAGE_FARSI)));
23576 }
23577 {
23578 PyDict_SetItemString(d,"LANGUAGE_FIJI", SWIG_From_int((int)(wxLANGUAGE_FIJI)));
23579 }
23580 {
23581 PyDict_SetItemString(d,"LANGUAGE_FINNISH", SWIG_From_int((int)(wxLANGUAGE_FINNISH)));
23582 }
23583 {
23584 PyDict_SetItemString(d,"LANGUAGE_FRENCH", SWIG_From_int((int)(wxLANGUAGE_FRENCH)));
23585 }
23586 {
23587 PyDict_SetItemString(d,"LANGUAGE_FRENCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_BELGIAN)));
23588 }
23589 {
23590 PyDict_SetItemString(d,"LANGUAGE_FRENCH_CANADIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_CANADIAN)));
23591 }
23592 {
23593 PyDict_SetItemString(d,"LANGUAGE_FRENCH_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_FRENCH_LUXEMBOURG)));
23594 }
23595 {
23596 PyDict_SetItemString(d,"LANGUAGE_FRENCH_MONACO", SWIG_From_int((int)(wxLANGUAGE_FRENCH_MONACO)));
23597 }
23598 {
23599 PyDict_SetItemString(d,"LANGUAGE_FRENCH_SWISS", SWIG_From_int((int)(wxLANGUAGE_FRENCH_SWISS)));
23600 }
23601 {
23602 PyDict_SetItemString(d,"LANGUAGE_FRISIAN", SWIG_From_int((int)(wxLANGUAGE_FRISIAN)));
23603 }
23604 {
23605 PyDict_SetItemString(d,"LANGUAGE_GALICIAN", SWIG_From_int((int)(wxLANGUAGE_GALICIAN)));
23606 }
23607 {
23608 PyDict_SetItemString(d,"LANGUAGE_GEORGIAN", SWIG_From_int((int)(wxLANGUAGE_GEORGIAN)));
23609 }
23610 {
23611 PyDict_SetItemString(d,"LANGUAGE_GERMAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN)));
23612 }
23613 {
23614 PyDict_SetItemString(d,"LANGUAGE_GERMAN_AUSTRIAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_AUSTRIAN)));
23615 }
23616 {
23617 PyDict_SetItemString(d,"LANGUAGE_GERMAN_BELGIUM", SWIG_From_int((int)(wxLANGUAGE_GERMAN_BELGIUM)));
23618 }
23619 {
23620 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LIECHTENSTEIN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LIECHTENSTEIN)));
23621 }
23622 {
23623 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LUXEMBOURG)));
23624 }
23625 {
23626 PyDict_SetItemString(d,"LANGUAGE_GERMAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_GERMAN_SWISS)));
23627 }
23628 {
23629 PyDict_SetItemString(d,"LANGUAGE_GREEK", SWIG_From_int((int)(wxLANGUAGE_GREEK)));
23630 }
23631 {
23632 PyDict_SetItemString(d,"LANGUAGE_GREENLANDIC", SWIG_From_int((int)(wxLANGUAGE_GREENLANDIC)));
23633 }
23634 {
23635 PyDict_SetItemString(d,"LANGUAGE_GUARANI", SWIG_From_int((int)(wxLANGUAGE_GUARANI)));
23636 }
23637 {
23638 PyDict_SetItemString(d,"LANGUAGE_GUJARATI", SWIG_From_int((int)(wxLANGUAGE_GUJARATI)));
23639 }
23640 {
23641 PyDict_SetItemString(d,"LANGUAGE_HAUSA", SWIG_From_int((int)(wxLANGUAGE_HAUSA)));
23642 }
23643 {
23644 PyDict_SetItemString(d,"LANGUAGE_HEBREW", SWIG_From_int((int)(wxLANGUAGE_HEBREW)));
23645 }
23646 {
23647 PyDict_SetItemString(d,"LANGUAGE_HINDI", SWIG_From_int((int)(wxLANGUAGE_HINDI)));
23648 }
23649 {
23650 PyDict_SetItemString(d,"LANGUAGE_HUNGARIAN", SWIG_From_int((int)(wxLANGUAGE_HUNGARIAN)));
23651 }
23652 {
23653 PyDict_SetItemString(d,"LANGUAGE_ICELANDIC", SWIG_From_int((int)(wxLANGUAGE_ICELANDIC)));
23654 }
23655 {
23656 PyDict_SetItemString(d,"LANGUAGE_INDONESIAN", SWIG_From_int((int)(wxLANGUAGE_INDONESIAN)));
23657 }
23658 {
23659 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUA", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUA)));
23660 }
23661 {
23662 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUE", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUE)));
23663 }
23664 {
23665 PyDict_SetItemString(d,"LANGUAGE_INUKTITUT", SWIG_From_int((int)(wxLANGUAGE_INUKTITUT)));
23666 }
23667 {
23668 PyDict_SetItemString(d,"LANGUAGE_INUPIAK", SWIG_From_int((int)(wxLANGUAGE_INUPIAK)));
23669 }
23670 {
23671 PyDict_SetItemString(d,"LANGUAGE_IRISH", SWIG_From_int((int)(wxLANGUAGE_IRISH)));
23672 }
23673 {
23674 PyDict_SetItemString(d,"LANGUAGE_ITALIAN", SWIG_From_int((int)(wxLANGUAGE_ITALIAN)));
23675 }
23676 {
23677 PyDict_SetItemString(d,"LANGUAGE_ITALIAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_ITALIAN_SWISS)));
23678 }
23679 {
23680 PyDict_SetItemString(d,"LANGUAGE_JAPANESE", SWIG_From_int((int)(wxLANGUAGE_JAPANESE)));
23681 }
23682 {
23683 PyDict_SetItemString(d,"LANGUAGE_JAVANESE", SWIG_From_int((int)(wxLANGUAGE_JAVANESE)));
23684 }
23685 {
23686 PyDict_SetItemString(d,"LANGUAGE_KANNADA", SWIG_From_int((int)(wxLANGUAGE_KANNADA)));
23687 }
23688 {
23689 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI)));
23690 }
23691 {
23692 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI_INDIA", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI_INDIA)));
23693 }
23694 {
23695 PyDict_SetItemString(d,"LANGUAGE_KAZAKH", SWIG_From_int((int)(wxLANGUAGE_KAZAKH)));
23696 }
23697 {
23698 PyDict_SetItemString(d,"LANGUAGE_KERNEWEK", SWIG_From_int((int)(wxLANGUAGE_KERNEWEK)));
23699 }
23700 {
23701 PyDict_SetItemString(d,"LANGUAGE_KINYARWANDA", SWIG_From_int((int)(wxLANGUAGE_KINYARWANDA)));
23702 }
23703 {
23704 PyDict_SetItemString(d,"LANGUAGE_KIRGHIZ", SWIG_From_int((int)(wxLANGUAGE_KIRGHIZ)));
23705 }
23706 {
23707 PyDict_SetItemString(d,"LANGUAGE_KIRUNDI", SWIG_From_int((int)(wxLANGUAGE_KIRUNDI)));
23708 }
23709 {
23710 PyDict_SetItemString(d,"LANGUAGE_KONKANI", SWIG_From_int((int)(wxLANGUAGE_KONKANI)));
23711 }
23712 {
23713 PyDict_SetItemString(d,"LANGUAGE_KOREAN", SWIG_From_int((int)(wxLANGUAGE_KOREAN)));
23714 }
23715 {
23716 PyDict_SetItemString(d,"LANGUAGE_KURDISH", SWIG_From_int((int)(wxLANGUAGE_KURDISH)));
23717 }
23718 {
23719 PyDict_SetItemString(d,"LANGUAGE_LAOTHIAN", SWIG_From_int((int)(wxLANGUAGE_LAOTHIAN)));
23720 }
23721 {
23722 PyDict_SetItemString(d,"LANGUAGE_LATIN", SWIG_From_int((int)(wxLANGUAGE_LATIN)));
23723 }
23724 {
23725 PyDict_SetItemString(d,"LANGUAGE_LATVIAN", SWIG_From_int((int)(wxLANGUAGE_LATVIAN)));
23726 }
23727 {
23728 PyDict_SetItemString(d,"LANGUAGE_LINGALA", SWIG_From_int((int)(wxLANGUAGE_LINGALA)));
23729 }
23730 {
23731 PyDict_SetItemString(d,"LANGUAGE_LITHUANIAN", SWIG_From_int((int)(wxLANGUAGE_LITHUANIAN)));
23732 }
23733 {
23734 PyDict_SetItemString(d,"LANGUAGE_MACEDONIAN", SWIG_From_int((int)(wxLANGUAGE_MACEDONIAN)));
23735 }
23736 {
23737 PyDict_SetItemString(d,"LANGUAGE_MALAGASY", SWIG_From_int((int)(wxLANGUAGE_MALAGASY)));
23738 }
23739 {
23740 PyDict_SetItemString(d,"LANGUAGE_MALAY", SWIG_From_int((int)(wxLANGUAGE_MALAY)));
23741 }
23742 {
23743 PyDict_SetItemString(d,"LANGUAGE_MALAYALAM", SWIG_From_int((int)(wxLANGUAGE_MALAYALAM)));
23744 }
23745 {
23746 PyDict_SetItemString(d,"LANGUAGE_MALAY_BRUNEI_DARUSSALAM", SWIG_From_int((int)(wxLANGUAGE_MALAY_BRUNEI_DARUSSALAM)));
23747 }
23748 {
23749 PyDict_SetItemString(d,"LANGUAGE_MALAY_MALAYSIA", SWIG_From_int((int)(wxLANGUAGE_MALAY_MALAYSIA)));
23750 }
23751 {
23752 PyDict_SetItemString(d,"LANGUAGE_MALTESE", SWIG_From_int((int)(wxLANGUAGE_MALTESE)));
23753 }
23754 {
23755 PyDict_SetItemString(d,"LANGUAGE_MANIPURI", SWIG_From_int((int)(wxLANGUAGE_MANIPURI)));
23756 }
23757 {
23758 PyDict_SetItemString(d,"LANGUAGE_MAORI", SWIG_From_int((int)(wxLANGUAGE_MAORI)));
23759 }
23760 {
23761 PyDict_SetItemString(d,"LANGUAGE_MARATHI", SWIG_From_int((int)(wxLANGUAGE_MARATHI)));
23762 }
23763 {
23764 PyDict_SetItemString(d,"LANGUAGE_MOLDAVIAN", SWIG_From_int((int)(wxLANGUAGE_MOLDAVIAN)));
23765 }
23766 {
23767 PyDict_SetItemString(d,"LANGUAGE_MONGOLIAN", SWIG_From_int((int)(wxLANGUAGE_MONGOLIAN)));
23768 }
23769 {
23770 PyDict_SetItemString(d,"LANGUAGE_NAURU", SWIG_From_int((int)(wxLANGUAGE_NAURU)));
23771 }
23772 {
23773 PyDict_SetItemString(d,"LANGUAGE_NEPALI", SWIG_From_int((int)(wxLANGUAGE_NEPALI)));
23774 }
23775 {
23776 PyDict_SetItemString(d,"LANGUAGE_NEPALI_INDIA", SWIG_From_int((int)(wxLANGUAGE_NEPALI_INDIA)));
23777 }
23778 {
23779 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_BOKMAL", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_BOKMAL)));
23780 }
23781 {
23782 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_NYNORSK", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_NYNORSK)));
23783 }
23784 {
23785 PyDict_SetItemString(d,"LANGUAGE_OCCITAN", SWIG_From_int((int)(wxLANGUAGE_OCCITAN)));
23786 }
23787 {
23788 PyDict_SetItemString(d,"LANGUAGE_ORIYA", SWIG_From_int((int)(wxLANGUAGE_ORIYA)));
23789 }
23790 {
23791 PyDict_SetItemString(d,"LANGUAGE_OROMO", SWIG_From_int((int)(wxLANGUAGE_OROMO)));
23792 }
23793 {
23794 PyDict_SetItemString(d,"LANGUAGE_PASHTO", SWIG_From_int((int)(wxLANGUAGE_PASHTO)));
23795 }
23796 {
23797 PyDict_SetItemString(d,"LANGUAGE_POLISH", SWIG_From_int((int)(wxLANGUAGE_POLISH)));
23798 }
23799 {
23800 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE)));
23801 }
23802 {
23803 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE_BRAZILIAN", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE_BRAZILIAN)));
23804 }
23805 {
23806 PyDict_SetItemString(d,"LANGUAGE_PUNJABI", SWIG_From_int((int)(wxLANGUAGE_PUNJABI)));
23807 }
23808 {
23809 PyDict_SetItemString(d,"LANGUAGE_QUECHUA", SWIG_From_int((int)(wxLANGUAGE_QUECHUA)));
23810 }
23811 {
23812 PyDict_SetItemString(d,"LANGUAGE_RHAETO_ROMANCE", SWIG_From_int((int)(wxLANGUAGE_RHAETO_ROMANCE)));
23813 }
23814 {
23815 PyDict_SetItemString(d,"LANGUAGE_ROMANIAN", SWIG_From_int((int)(wxLANGUAGE_ROMANIAN)));
23816 }
23817 {
23818 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN)));
23819 }
23820 {
23821 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN_UKRAINE", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN_UKRAINE)));
23822 }
23823 {
23824 PyDict_SetItemString(d,"LANGUAGE_SAMOAN", SWIG_From_int((int)(wxLANGUAGE_SAMOAN)));
23825 }
23826 {
23827 PyDict_SetItemString(d,"LANGUAGE_SANGHO", SWIG_From_int((int)(wxLANGUAGE_SANGHO)));
23828 }
23829 {
23830 PyDict_SetItemString(d,"LANGUAGE_SANSKRIT", SWIG_From_int((int)(wxLANGUAGE_SANSKRIT)));
23831 }
23832 {
23833 PyDict_SetItemString(d,"LANGUAGE_SCOTS_GAELIC", SWIG_From_int((int)(wxLANGUAGE_SCOTS_GAELIC)));
23834 }
23835 {
23836 PyDict_SetItemString(d,"LANGUAGE_SERBIAN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN)));
23837 }
23838 {
23839 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_CYRILLIC)));
23840 }
23841 {
23842 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_LATIN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_LATIN)));
23843 }
23844 {
23845 PyDict_SetItemString(d,"LANGUAGE_SERBO_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_SERBO_CROATIAN)));
23846 }
23847 {
23848 PyDict_SetItemString(d,"LANGUAGE_SESOTHO", SWIG_From_int((int)(wxLANGUAGE_SESOTHO)));
23849 }
23850 {
23851 PyDict_SetItemString(d,"LANGUAGE_SETSWANA", SWIG_From_int((int)(wxLANGUAGE_SETSWANA)));
23852 }
23853 {
23854 PyDict_SetItemString(d,"LANGUAGE_SHONA", SWIG_From_int((int)(wxLANGUAGE_SHONA)));
23855 }
23856 {
23857 PyDict_SetItemString(d,"LANGUAGE_SINDHI", SWIG_From_int((int)(wxLANGUAGE_SINDHI)));
23858 }
23859 {
23860 PyDict_SetItemString(d,"LANGUAGE_SINHALESE", SWIG_From_int((int)(wxLANGUAGE_SINHALESE)));
23861 }
23862 {
23863 PyDict_SetItemString(d,"LANGUAGE_SISWATI", SWIG_From_int((int)(wxLANGUAGE_SISWATI)));
23864 }
23865 {
23866 PyDict_SetItemString(d,"LANGUAGE_SLOVAK", SWIG_From_int((int)(wxLANGUAGE_SLOVAK)));
23867 }
23868 {
23869 PyDict_SetItemString(d,"LANGUAGE_SLOVENIAN", SWIG_From_int((int)(wxLANGUAGE_SLOVENIAN)));
23870 }
23871 {
23872 PyDict_SetItemString(d,"LANGUAGE_SOMALI", SWIG_From_int((int)(wxLANGUAGE_SOMALI)));
23873 }
23874 {
23875 PyDict_SetItemString(d,"LANGUAGE_SPANISH", SWIG_From_int((int)(wxLANGUAGE_SPANISH)));
23876 }
23877 {
23878 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ARGENTINA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ARGENTINA)));
23879 }
23880 {
23881 PyDict_SetItemString(d,"LANGUAGE_SPANISH_BOLIVIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_BOLIVIA)));
23882 }
23883 {
23884 PyDict_SetItemString(d,"LANGUAGE_SPANISH_CHILE", SWIG_From_int((int)(wxLANGUAGE_SPANISH_CHILE)));
23885 }
23886 {
23887 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COLOMBIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COLOMBIA)));
23888 }
23889 {
23890 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COSTA_RICA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COSTA_RICA)));
23891 }
23892 {
23893 PyDict_SetItemString(d,"LANGUAGE_SPANISH_DOMINICAN_REPUBLIC", SWIG_From_int((int)(wxLANGUAGE_SPANISH_DOMINICAN_REPUBLIC)));
23894 }
23895 {
23896 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ECUADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ECUADOR)));
23897 }
23898 {
23899 PyDict_SetItemString(d,"LANGUAGE_SPANISH_EL_SALVADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_EL_SALVADOR)));
23900 }
23901 {
23902 PyDict_SetItemString(d,"LANGUAGE_SPANISH_GUATEMALA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_GUATEMALA)));
23903 }
23904 {
23905 PyDict_SetItemString(d,"LANGUAGE_SPANISH_HONDURAS", SWIG_From_int((int)(wxLANGUAGE_SPANISH_HONDURAS)));
23906 }
23907 {
23908 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MEXICAN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MEXICAN)));
23909 }
23910 {
23911 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MODERN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MODERN)));
23912 }
23913 {
23914 PyDict_SetItemString(d,"LANGUAGE_SPANISH_NICARAGUA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_NICARAGUA)));
23915 }
23916 {
23917 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PANAMA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PANAMA)));
23918 }
23919 {
23920 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PARAGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PARAGUAY)));
23921 }
23922 {
23923 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PERU", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PERU)));
23924 }
23925 {
23926 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PUERTO_RICO", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PUERTO_RICO)));
23927 }
23928 {
23929 PyDict_SetItemString(d,"LANGUAGE_SPANISH_URUGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_URUGUAY)));
23930 }
23931 {
23932 PyDict_SetItemString(d,"LANGUAGE_SPANISH_US", SWIG_From_int((int)(wxLANGUAGE_SPANISH_US)));
23933 }
23934 {
23935 PyDict_SetItemString(d,"LANGUAGE_SPANISH_VENEZUELA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_VENEZUELA)));
23936 }
23937 {
23938 PyDict_SetItemString(d,"LANGUAGE_SUNDANESE", SWIG_From_int((int)(wxLANGUAGE_SUNDANESE)));
23939 }
23940 {
23941 PyDict_SetItemString(d,"LANGUAGE_SWAHILI", SWIG_From_int((int)(wxLANGUAGE_SWAHILI)));
23942 }
23943 {
23944 PyDict_SetItemString(d,"LANGUAGE_SWEDISH", SWIG_From_int((int)(wxLANGUAGE_SWEDISH)));
23945 }
23946 {
23947 PyDict_SetItemString(d,"LANGUAGE_SWEDISH_FINLAND", SWIG_From_int((int)(wxLANGUAGE_SWEDISH_FINLAND)));
23948 }
23949 {
23950 PyDict_SetItemString(d,"LANGUAGE_TAGALOG", SWIG_From_int((int)(wxLANGUAGE_TAGALOG)));
23951 }
23952 {
23953 PyDict_SetItemString(d,"LANGUAGE_TAJIK", SWIG_From_int((int)(wxLANGUAGE_TAJIK)));
23954 }
23955 {
23956 PyDict_SetItemString(d,"LANGUAGE_TAMIL", SWIG_From_int((int)(wxLANGUAGE_TAMIL)));
23957 }
23958 {
23959 PyDict_SetItemString(d,"LANGUAGE_TATAR", SWIG_From_int((int)(wxLANGUAGE_TATAR)));
23960 }
23961 {
23962 PyDict_SetItemString(d,"LANGUAGE_TELUGU", SWIG_From_int((int)(wxLANGUAGE_TELUGU)));
23963 }
23964 {
23965 PyDict_SetItemString(d,"LANGUAGE_THAI", SWIG_From_int((int)(wxLANGUAGE_THAI)));
23966 }
23967 {
23968 PyDict_SetItemString(d,"LANGUAGE_TIBETAN", SWIG_From_int((int)(wxLANGUAGE_TIBETAN)));
23969 }
23970 {
23971 PyDict_SetItemString(d,"LANGUAGE_TIGRINYA", SWIG_From_int((int)(wxLANGUAGE_TIGRINYA)));
23972 }
23973 {
23974 PyDict_SetItemString(d,"LANGUAGE_TONGA", SWIG_From_int((int)(wxLANGUAGE_TONGA)));
23975 }
23976 {
23977 PyDict_SetItemString(d,"LANGUAGE_TSONGA", SWIG_From_int((int)(wxLANGUAGE_TSONGA)));
23978 }
23979 {
23980 PyDict_SetItemString(d,"LANGUAGE_TURKISH", SWIG_From_int((int)(wxLANGUAGE_TURKISH)));
23981 }
23982 {
23983 PyDict_SetItemString(d,"LANGUAGE_TURKMEN", SWIG_From_int((int)(wxLANGUAGE_TURKMEN)));
23984 }
23985 {
23986 PyDict_SetItemString(d,"LANGUAGE_TWI", SWIG_From_int((int)(wxLANGUAGE_TWI)));
23987 }
23988 {
23989 PyDict_SetItemString(d,"LANGUAGE_UIGHUR", SWIG_From_int((int)(wxLANGUAGE_UIGHUR)));
23990 }
23991 {
23992 PyDict_SetItemString(d,"LANGUAGE_UKRAINIAN", SWIG_From_int((int)(wxLANGUAGE_UKRAINIAN)));
23993 }
23994 {
23995 PyDict_SetItemString(d,"LANGUAGE_URDU", SWIG_From_int((int)(wxLANGUAGE_URDU)));
23996 }
23997 {
23998 PyDict_SetItemString(d,"LANGUAGE_URDU_INDIA", SWIG_From_int((int)(wxLANGUAGE_URDU_INDIA)));
23999 }
24000 {
24001 PyDict_SetItemString(d,"LANGUAGE_URDU_PAKISTAN", SWIG_From_int((int)(wxLANGUAGE_URDU_PAKISTAN)));
24002 }
24003 {
24004 PyDict_SetItemString(d,"LANGUAGE_UZBEK", SWIG_From_int((int)(wxLANGUAGE_UZBEK)));
24005 }
24006 {
24007 PyDict_SetItemString(d,"LANGUAGE_UZBEK_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_UZBEK_CYRILLIC)));
24008 }
24009 {
24010 PyDict_SetItemString(d,"LANGUAGE_UZBEK_LATIN", SWIG_From_int((int)(wxLANGUAGE_UZBEK_LATIN)));
24011 }
24012 {
24013 PyDict_SetItemString(d,"LANGUAGE_VIETNAMESE", SWIG_From_int((int)(wxLANGUAGE_VIETNAMESE)));
24014 }
24015 {
24016 PyDict_SetItemString(d,"LANGUAGE_VOLAPUK", SWIG_From_int((int)(wxLANGUAGE_VOLAPUK)));
24017 }
24018 {
24019 PyDict_SetItemString(d,"LANGUAGE_WELSH", SWIG_From_int((int)(wxLANGUAGE_WELSH)));
24020 }
24021 {
24022 PyDict_SetItemString(d,"LANGUAGE_WOLOF", SWIG_From_int((int)(wxLANGUAGE_WOLOF)));
24023 }
24024 {
24025 PyDict_SetItemString(d,"LANGUAGE_XHOSA", SWIG_From_int((int)(wxLANGUAGE_XHOSA)));
24026 }
24027 {
24028 PyDict_SetItemString(d,"LANGUAGE_YIDDISH", SWIG_From_int((int)(wxLANGUAGE_YIDDISH)));
24029 }
24030 {
24031 PyDict_SetItemString(d,"LANGUAGE_YORUBA", SWIG_From_int((int)(wxLANGUAGE_YORUBA)));
24032 }
24033 {
24034 PyDict_SetItemString(d,"LANGUAGE_ZHUANG", SWIG_From_int((int)(wxLANGUAGE_ZHUANG)));
24035 }
24036 {
24037 PyDict_SetItemString(d,"LANGUAGE_ZULU", SWIG_From_int((int)(wxLANGUAGE_ZULU)));
24038 }
24039 {
24040 PyDict_SetItemString(d,"LANGUAGE_USER_DEFINED", SWIG_From_int((int)(wxLANGUAGE_USER_DEFINED)));
24041 }
24042 {
24043 PyDict_SetItemString(d,"LOCALE_CAT_NUMBER", SWIG_From_int((int)(wxLOCALE_CAT_NUMBER)));
24044 }
24045 {
24046 PyDict_SetItemString(d,"LOCALE_CAT_DATE", SWIG_From_int((int)(wxLOCALE_CAT_DATE)));
24047 }
24048 {
24049 PyDict_SetItemString(d,"LOCALE_CAT_MONEY", SWIG_From_int((int)(wxLOCALE_CAT_MONEY)));
24050 }
24051 {
24052 PyDict_SetItemString(d,"LOCALE_CAT_MAX", SWIG_From_int((int)(wxLOCALE_CAT_MAX)));
24053 }
24054 {
24055 PyDict_SetItemString(d,"LOCALE_THOUSANDS_SEP", SWIG_From_int((int)(wxLOCALE_THOUSANDS_SEP)));
24056 }
24057 {
24058 PyDict_SetItemString(d,"LOCALE_DECIMAL_POINT", SWIG_From_int((int)(wxLOCALE_DECIMAL_POINT)));
24059 }
24060 {
24061 PyDict_SetItemString(d,"LOCALE_LOAD_DEFAULT", SWIG_From_int((int)(wxLOCALE_LOAD_DEFAULT)));
24062 }
24063 {
24064 PyDict_SetItemString(d,"LOCALE_CONV_ENCODING", SWIG_From_int((int)(wxLOCALE_CONV_ENCODING)));
24065 }
24066 {
24067 PyDict_SetItemString(d,"CONVERT_STRICT", SWIG_From_int((int)(wxCONVERT_STRICT)));
24068 }
24069 {
24070 PyDict_SetItemString(d,"CONVERT_SUBSTITUTE", SWIG_From_int((int)(wxCONVERT_SUBSTITUTE)));
24071 }
24072 {
24073 PyDict_SetItemString(d,"PLATFORM_CURRENT", SWIG_From_int((int)(wxPLATFORM_CURRENT)));
24074 }
24075 {
24076 PyDict_SetItemString(d,"PLATFORM_UNIX", SWIG_From_int((int)(wxPLATFORM_UNIX)));
24077 }
24078 {
24079 PyDict_SetItemString(d,"PLATFORM_WINDOWS", SWIG_From_int((int)(wxPLATFORM_WINDOWS)));
24080 }
24081 {
24082 PyDict_SetItemString(d,"PLATFORM_OS2", SWIG_From_int((int)(wxPLATFORM_OS2)));
24083 }
24084 {
24085 PyDict_SetItemString(d,"PLATFORM_MAC", SWIG_From_int((int)(wxPLATFORM_MAC)));
24086 }
24087 {
24088 PyDict_SetItemString(d,"BUFFER_VIRTUAL_AREA", SWIG_From_int((int)(wxBUFFER_VIRTUAL_AREA)));
24089 }
24090 {
24091 PyDict_SetItemString(d,"BUFFER_CLIENT_AREA", SWIG_From_int((int)(wxBUFFER_CLIENT_AREA)));
24092 }
24093 {
24094 PyDict_SetItemString(d,"IMAGELIST_DRAW_NORMAL", SWIG_From_int((int)(wxIMAGELIST_DRAW_NORMAL)));
24095 }
24096 {
24097 PyDict_SetItemString(d,"IMAGELIST_DRAW_TRANSPARENT", SWIG_From_int((int)(wxIMAGELIST_DRAW_TRANSPARENT)));
24098 }
24099 {
24100 PyDict_SetItemString(d,"IMAGELIST_DRAW_SELECTED", SWIG_From_int((int)(wxIMAGELIST_DRAW_SELECTED)));
24101 }
24102 {
24103 PyDict_SetItemString(d,"IMAGELIST_DRAW_FOCUSED", SWIG_From_int((int)(wxIMAGELIST_DRAW_FOCUSED)));
24104 }
24105 {
24106 PyDict_SetItemString(d,"IMAGE_LIST_NORMAL", SWIG_From_int((int)(wxIMAGE_LIST_NORMAL)));
24107 }
24108 {
24109 PyDict_SetItemString(d,"IMAGE_LIST_SMALL", SWIG_From_int((int)(wxIMAGE_LIST_SMALL)));
24110 }
24111 {
24112 PyDict_SetItemString(d,"IMAGE_LIST_STATE", SWIG_From_int((int)(wxIMAGE_LIST_STATE)));
24113 }
24114 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
24115 SWIG_addvarlink(SWIG_globals,(char*)"NORMAL_FONT",_wrap_NORMAL_FONT_get, _wrap_NORMAL_FONT_set);
24116 SWIG_addvarlink(SWIG_globals,(char*)"SMALL_FONT",_wrap_SMALL_FONT_get, _wrap_SMALL_FONT_set);
24117 SWIG_addvarlink(SWIG_globals,(char*)"ITALIC_FONT",_wrap_ITALIC_FONT_get, _wrap_ITALIC_FONT_set);
24118 SWIG_addvarlink(SWIG_globals,(char*)"SWISS_FONT",_wrap_SWISS_FONT_get, _wrap_SWISS_FONT_set);
24119 SWIG_addvarlink(SWIG_globals,(char*)"RED_PEN",_wrap_RED_PEN_get, _wrap_RED_PEN_set);
24120 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_PEN",_wrap_CYAN_PEN_get, _wrap_CYAN_PEN_set);
24121 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_PEN",_wrap_GREEN_PEN_get, _wrap_GREEN_PEN_set);
24122 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_PEN",_wrap_BLACK_PEN_get, _wrap_BLACK_PEN_set);
24123 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_PEN",_wrap_WHITE_PEN_get, _wrap_WHITE_PEN_set);
24124 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_PEN",_wrap_TRANSPARENT_PEN_get, _wrap_TRANSPARENT_PEN_set);
24125 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_DASHED_PEN",_wrap_BLACK_DASHED_PEN_get, _wrap_BLACK_DASHED_PEN_set);
24126 SWIG_addvarlink(SWIG_globals,(char*)"GREY_PEN",_wrap_GREY_PEN_get, _wrap_GREY_PEN_set);
24127 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_PEN",_wrap_MEDIUM_GREY_PEN_get, _wrap_MEDIUM_GREY_PEN_set);
24128 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_PEN",_wrap_LIGHT_GREY_PEN_get, _wrap_LIGHT_GREY_PEN_set);
24129 SWIG_addvarlink(SWIG_globals,(char*)"BLUE_BRUSH",_wrap_BLUE_BRUSH_get, _wrap_BLUE_BRUSH_set);
24130 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_BRUSH",_wrap_GREEN_BRUSH_get, _wrap_GREEN_BRUSH_set);
24131 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_BRUSH",_wrap_WHITE_BRUSH_get, _wrap_WHITE_BRUSH_set);
24132 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_BRUSH",_wrap_BLACK_BRUSH_get, _wrap_BLACK_BRUSH_set);
24133 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_BRUSH",_wrap_TRANSPARENT_BRUSH_get, _wrap_TRANSPARENT_BRUSH_set);
24134 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_BRUSH",_wrap_CYAN_BRUSH_get, _wrap_CYAN_BRUSH_set);
24135 SWIG_addvarlink(SWIG_globals,(char*)"RED_BRUSH",_wrap_RED_BRUSH_get, _wrap_RED_BRUSH_set);
24136 SWIG_addvarlink(SWIG_globals,(char*)"GREY_BRUSH",_wrap_GREY_BRUSH_get, _wrap_GREY_BRUSH_set);
24137 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_BRUSH",_wrap_MEDIUM_GREY_BRUSH_get, _wrap_MEDIUM_GREY_BRUSH_set);
24138 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_BRUSH",_wrap_LIGHT_GREY_BRUSH_get, _wrap_LIGHT_GREY_BRUSH_set);
24139 SWIG_addvarlink(SWIG_globals,(char*)"BLACK",_wrap_BLACK_get, _wrap_BLACK_set);
24140 SWIG_addvarlink(SWIG_globals,(char*)"WHITE",_wrap_WHITE_get, _wrap_WHITE_set);
24141 SWIG_addvarlink(SWIG_globals,(char*)"RED",_wrap_RED_get, _wrap_RED_set);
24142 SWIG_addvarlink(SWIG_globals,(char*)"BLUE",_wrap_BLUE_get, _wrap_BLUE_set);
24143 SWIG_addvarlink(SWIG_globals,(char*)"GREEN",_wrap_GREEN_get, _wrap_GREEN_set);
24144 SWIG_addvarlink(SWIG_globals,(char*)"CYAN",_wrap_CYAN_get, _wrap_CYAN_set);
24145 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY",_wrap_LIGHT_GREY_get, _wrap_LIGHT_GREY_set);
24146 SWIG_addvarlink(SWIG_globals,(char*)"STANDARD_CURSOR",_wrap_STANDARD_CURSOR_get, _wrap_STANDARD_CURSOR_set);
24147 SWIG_addvarlink(SWIG_globals,(char*)"HOURGLASS_CURSOR",_wrap_HOURGLASS_CURSOR_get, _wrap_HOURGLASS_CURSOR_set);
24148 SWIG_addvarlink(SWIG_globals,(char*)"CROSS_CURSOR",_wrap_CROSS_CURSOR_get, _wrap_CROSS_CURSOR_set);
24149 SWIG_addvarlink(SWIG_globals,(char*)"NullBitmap",_wrap_NullBitmap_get, _wrap_NullBitmap_set);
24150 SWIG_addvarlink(SWIG_globals,(char*)"NullIcon",_wrap_NullIcon_get, _wrap_NullIcon_set);
24151 SWIG_addvarlink(SWIG_globals,(char*)"NullCursor",_wrap_NullCursor_get, _wrap_NullCursor_set);
24152 SWIG_addvarlink(SWIG_globals,(char*)"NullPen",_wrap_NullPen_get, _wrap_NullPen_set);
24153 SWIG_addvarlink(SWIG_globals,(char*)"NullBrush",_wrap_NullBrush_get, _wrap_NullBrush_set);
24154 SWIG_addvarlink(SWIG_globals,(char*)"NullPalette",_wrap_NullPalette_get, _wrap_NullPalette_set);
24155 SWIG_addvarlink(SWIG_globals,(char*)"NullFont",_wrap_NullFont_get, _wrap_NullFont_set);
24156 SWIG_addvarlink(SWIG_globals,(char*)"NullColour",_wrap_NullColour_get, _wrap_NullColour_set);
24157 SWIG_addvarlink(SWIG_globals,(char*)"TheFontList",_wrap_TheFontList_get, _wrap_TheFontList_set);
24158 SWIG_addvarlink(SWIG_globals,(char*)"ThePenList",_wrap_ThePenList_get, _wrap_ThePenList_set);
24159 SWIG_addvarlink(SWIG_globals,(char*)"TheBrushList",_wrap_TheBrushList_get, _wrap_TheBrushList_set);
24160 SWIG_addvarlink(SWIG_globals,(char*)"TheColourDatabase",_wrap_TheColourDatabase_get, _wrap_TheColourDatabase_set);
24161
24162 // Work around a chicken/egg problem in drawlist.cpp
24163 wxPyDrawList_SetAPIPtr();
24164
24165 }
24166
wxWidgets (Impactor)