]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_gdi_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Added wx.BrushFromBitmap to create a stippled brush in a single step.
[wxWidgets.git] / wxPython / src / gtk / _gdi_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 if (str)
1041 Py_DECREF(str);
1042 return;
1043 }
1044 }
1045 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1046 } else {
1047 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1048 }
1049 }
1050
1051 SWIGRUNTIMEINLINE void
1052 SWIG_Python_NullRef(const char *type)
1053 {
1054 if (type) {
1055 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1056 } else {
1057 PyErr_Format(PyExc_TypeError, "null reference was received");
1058 }
1059 }
1060
1061 SWIGRUNTIME int
1062 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1063 {
1064 if (PyErr_Occurred()) {
1065 PyObject *type = 0;
1066 PyObject *value = 0;
1067 PyObject *traceback = 0;
1068 PyErr_Fetch(&type, &value, &traceback);
1069 if (value) {
1070 PyObject *old_str = PyObject_Str(value);
1071 Py_XINCREF(type);
1072 PyErr_Clear();
1073 if (infront) {
1074 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1075 } else {
1076 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1077 }
1078 Py_DECREF(old_str);
1079 }
1080 return 1;
1081 } else {
1082 return 0;
1083 }
1084 }
1085
1086 SWIGRUNTIME int
1087 SWIG_Python_ArgFail(int argnum)
1088 {
1089 if (PyErr_Occurred()) {
1090 /* add information about failing argument */
1091 char mesg[256];
1092 sprintf(mesg, "argument number %d:", argnum);
1093 return SWIG_Python_AddErrMesg(mesg, 1);
1094 } else {
1095 return 0;
1096 }
1097 }
1098
1099
1100 /* -----------------------------------------------------------------------------
1101 * pointers/data manipulation
1102 * ----------------------------------------------------------------------------- */
1103
1104 /* Convert a pointer value */
1105 SWIGRUNTIME int
1106 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1107 swig_type_info *tc;
1108 const char *c = 0;
1109 static PyObject *SWIG_this = 0;
1110 int newref = 0;
1111 PyObject *pyobj = 0;
1112 void *vptr;
1113
1114 if (!obj) return 0;
1115 if (obj == Py_None) {
1116 *ptr = 0;
1117 return 0;
1118 }
1119
1120 #ifdef SWIG_COBJECT_TYPES
1121 if (!(PySwigObject_Check(obj))) {
1122 if (!SWIG_this)
1123 SWIG_this = PyString_FromString("this");
1124 pyobj = obj;
1125 obj = PyObject_GetAttr(obj,SWIG_this);
1126 newref = 1;
1127 if (!obj) goto type_error;
1128 if (!PySwigObject_Check(obj)) {
1129 Py_DECREF(obj);
1130 goto type_error;
1131 }
1132 }
1133 vptr = PySwigObject_AsVoidPtr(obj);
1134 c = (const char *) PySwigObject_GetDesc(obj);
1135 if (newref) { Py_DECREF(obj); }
1136 goto type_check;
1137 #else
1138 if (!(PyString_Check(obj))) {
1139 if (!SWIG_this)
1140 SWIG_this = PyString_FromString("this");
1141 pyobj = obj;
1142 obj = PyObject_GetAttr(obj,SWIG_this);
1143 newref = 1;
1144 if (!obj) goto type_error;
1145 if (!PyString_Check(obj)) {
1146 Py_DECREF(obj);
1147 goto type_error;
1148 }
1149 }
1150 c = PyString_AS_STRING(obj);
1151 /* Pointer values must start with leading underscore */
1152 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1153 if (newref) { Py_DECREF(obj); }
1154 if (!c) goto type_error;
1155 #endif
1156
1157 type_check:
1158
1159 if (ty) {
1160 tc = SWIG_TypeCheck(c,ty);
1161 if (!tc) goto type_error;
1162 *ptr = SWIG_TypeCast(tc,vptr);
1163 } else {
1164 *ptr = vptr;
1165 }
1166
1167 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1168 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1169 }
1170 return 0;
1171
1172 type_error:
1173 PyErr_Clear();
1174 if (pyobj && !obj) {
1175 obj = pyobj;
1176 if (PyCFunction_Check(obj)) {
1177 /* here we get the method pointer for callbacks */
1178 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1179 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1180 if (c) {
1181 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1182 if (!c) goto type_error;
1183 goto type_check;
1184 }
1185 }
1186 }
1187 if (flags & SWIG_POINTER_EXCEPTION) {
1188 if (ty) {
1189 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1190 } else {
1191 SWIG_Python_TypeError("C/C++ pointer", obj);
1192 }
1193 }
1194 return -1;
1195 }
1196
1197 /* Convert a pointer value, signal an exception on a type mismatch */
1198 SWIGRUNTIME void *
1199 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1200 void *result;
1201 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1202 PyErr_Clear();
1203 if (flags & SWIG_POINTER_EXCEPTION) {
1204 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1205 SWIG_Python_ArgFail(argnum);
1206 }
1207 }
1208 return result;
1209 }
1210
1211 /* Convert a packed value value */
1212 SWIGRUNTIME int
1213 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1214 swig_type_info *tc;
1215 const char *c = 0;
1216
1217 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1218 c = PySwigPacked_UnpackData(obj, ptr, sz);
1219 #else
1220 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1221 c = PyString_AS_STRING(obj);
1222 /* Pointer values must start with leading underscore */
1223 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1224 #endif
1225 if (!c) goto type_error;
1226 if (ty) {
1227 tc = SWIG_TypeCheck(c,ty);
1228 if (!tc) goto type_error;
1229 }
1230 return 0;
1231
1232 type_error:
1233 PyErr_Clear();
1234 if (flags & SWIG_POINTER_EXCEPTION) {
1235 if (ty) {
1236 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1237 } else {
1238 SWIG_Python_TypeError("C/C++ packed data", obj);
1239 }
1240 }
1241 return -1;
1242 }
1243
1244 /* Create a new array object */
1245 SWIGRUNTIME PyObject *
1246 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1247 PyObject *robj = 0;
1248 if (!ptr) {
1249 Py_INCREF(Py_None);
1250 return Py_None;
1251 }
1252 #ifdef SWIG_COBJECT_TYPES
1253 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1254 #else
1255 {
1256 char result[SWIG_BUFFER_SIZE];
1257 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1258 PyString_FromString(result) : 0;
1259 }
1260 #endif
1261 if (!robj || (robj == Py_None)) return robj;
1262 if (type->clientdata) {
1263 PyObject *inst;
1264 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1265 Py_DECREF(robj);
1266 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1267 Py_DECREF(args);
1268 if (inst) {
1269 if (own) {
1270 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1271 }
1272 robj = inst;
1273 }
1274 }
1275 return robj;
1276 }
1277
1278 SWIGRUNTIME PyObject *
1279 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1280 PyObject *robj = 0;
1281 if (!ptr) {
1282 Py_INCREF(Py_None);
1283 return Py_None;
1284 }
1285 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1286 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1287 #else
1288 {
1289 char result[SWIG_BUFFER_SIZE];
1290 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1291 PyString_FromString(result) : 0;
1292 }
1293 #endif
1294 return robj;
1295 }
1296
1297 /* -----------------------------------------------------------------------------*
1298 * Get type list
1299 * -----------------------------------------------------------------------------*/
1300
1301 #ifdef SWIG_LINK_RUNTIME
1302 void *SWIG_ReturnGlobalTypeList(void *);
1303 #endif
1304
1305 SWIGRUNTIME swig_type_info **
1306 SWIG_Python_GetTypeListHandle() {
1307 static void *type_pointer = (void *)0;
1308 /* first check if module already created */
1309 if (!type_pointer) {
1310 #ifdef SWIG_LINK_RUNTIME
1311 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1312 #else
1313 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1314 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1315 if (PyErr_Occurred()) {
1316 PyErr_Clear();
1317 type_pointer = (void *)0;
1318 }
1319 }
1320 #endif
1321 return (swig_type_info **) type_pointer;
1322 }
1323
1324 /*
1325 Search for a swig_type_info structure
1326 */
1327 SWIGRUNTIMEINLINE swig_type_info *
1328 SWIG_Python_GetTypeList() {
1329 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1330 return tlh ? *tlh : (swig_type_info*)0;
1331 }
1332
1333 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1334
1335 #ifdef __cplusplus
1336 }
1337 #endif
1338
1339
1340 /* -------- TYPES TABLE (BEGIN) -------- */
1341
1342 #define SWIGTYPE_p_wxPostScriptDC swig_types[0]
1343 #define SWIGTYPE_p_wxBrush swig_types[1]
1344 #define SWIGTYPE_p_wxColour swig_types[2]
1345 #define SWIGTYPE_p_wxDC swig_types[3]
1346 #define SWIGTYPE_p_wxMirrorDC swig_types[4]
1347 #define SWIGTYPE_p_form_ops_t swig_types[5]
1348 #define SWIGTYPE_p_wxDuplexMode swig_types[6]
1349 #define SWIGTYPE_p_wxPyFontEnumerator swig_types[7]
1350 #define SWIGTYPE_p_char swig_types[8]
1351 #define SWIGTYPE_p_wxIconLocation swig_types[9]
1352 #define SWIGTYPE_p_wxImage swig_types[10]
1353 #define SWIGTYPE_p_wxMetaFileDC swig_types[11]
1354 #define SWIGTYPE_p_wxMask swig_types[12]
1355 #define SWIGTYPE_p_wxSize swig_types[13]
1356 #define SWIGTYPE_p_wxFont swig_types[14]
1357 #define SWIGTYPE_p_wxWindow swig_types[15]
1358 #define SWIGTYPE_p_double swig_types[16]
1359 #define SWIGTYPE_p_wxMemoryDC swig_types[17]
1360 #define SWIGTYPE_p_wxFontMapper swig_types[18]
1361 #define SWIGTYPE_p_wxEffects swig_types[19]
1362 #define SWIGTYPE_p_wxNativeEncodingInfo swig_types[20]
1363 #define SWIGTYPE_p_wxPalette swig_types[21]
1364 #define SWIGTYPE_p_wxBitmap swig_types[22]
1365 #define SWIGTYPE_p_wxObject swig_types[23]
1366 #define SWIGTYPE_p_wxRegionIterator swig_types[24]
1367 #define SWIGTYPE_p_wxRect swig_types[25]
1368 #define SWIGTYPE_p_wxPaperSize swig_types[26]
1369 #define SWIGTYPE_p_wxString swig_types[27]
1370 #define SWIGTYPE_unsigned_int swig_types[28]
1371 #define SWIGTYPE_p_unsigned_int swig_types[29]
1372 #define SWIGTYPE_p_wxPrinterDC swig_types[30]
1373 #define SWIGTYPE_p_wxIconBundle swig_types[31]
1374 #define SWIGTYPE_p_wxPoint swig_types[32]
1375 #define SWIGTYPE_p_wxDash swig_types[33]
1376 #define SWIGTYPE_p_wxScreenDC swig_types[34]
1377 #define SWIGTYPE_p_wxCursor swig_types[35]
1378 #define SWIGTYPE_p_wxClientDC swig_types[36]
1379 #define SWIGTYPE_p_wxBufferedDC swig_types[37]
1380 #define SWIGTYPE_p_wxImageList swig_types[38]
1381 #define SWIGTYPE_p_unsigned_char swig_types[39]
1382 #define SWIGTYPE_p_wxGDIObject swig_types[40]
1383 #define SWIGTYPE_p_wxIcon swig_types[41]
1384 #define SWIGTYPE_p_wxLocale swig_types[42]
1385 #define SWIGTYPE_ptrdiff_t swig_types[43]
1386 #define SWIGTYPE_std__ptrdiff_t swig_types[44]
1387 #define SWIGTYPE_p_wxRegion swig_types[45]
1388 #define SWIGTYPE_p_wxConfigBase swig_types[46]
1389 #define SWIGTYPE_p_wxLanguageInfo swig_types[47]
1390 #define SWIGTYPE_p_wxWindowDC swig_types[48]
1391 #define SWIGTYPE_p_wxPrintData swig_types[49]
1392 #define SWIGTYPE_p_wxBrushList swig_types[50]
1393 #define SWIGTYPE_p_wxFontList swig_types[51]
1394 #define SWIGTYPE_p_wxPen swig_types[52]
1395 #define SWIGTYPE_p_wxBufferedPaintDC swig_types[53]
1396 #define SWIGTYPE_p_wxPaintDC swig_types[54]
1397 #define SWIGTYPE_p_wxPenList swig_types[55]
1398 #define SWIGTYPE_p_int swig_types[56]
1399 #define SWIGTYPE_p_wxMetaFile swig_types[57]
1400 #define SWIGTYPE_p_unsigned_long swig_types[58]
1401 #define SWIGTYPE_p_wxNativeFontInfo swig_types[59]
1402 #define SWIGTYPE_p_wxEncodingConverter swig_types[60]
1403 #define SWIGTYPE_p_wxColourDatabase swig_types[61]
1404 static swig_type_info *swig_types[63];
1405
1406 /* -------- TYPES TABLE (END) -------- */
1407
1408
1409 /*-----------------------------------------------
1410 @(target):= _gdi_.so
1411 ------------------------------------------------*/
1412 #define SWIG_init init_gdi_
1413
1414 #define SWIG_name "_gdi_"
1415
1416 #include "wx/wxPython/wxPython.h"
1417 #include "wx/wxPython/pyclasses.h"
1418
1419
1420 static const wxString wxPyEmptyString(wxEmptyString);
1421
1422 #include <limits.h>
1423
1424
1425 SWIGINTERN int
1426 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1427 const char *errmsg)
1428 {
1429 if (value < min_value) {
1430 if (errmsg) {
1431 PyErr_Format(PyExc_OverflowError,
1432 "value %ld is less than '%s' minimum %ld",
1433 value, errmsg, min_value);
1434 }
1435 return 0;
1436 } else if (value > max_value) {
1437 if (errmsg) {
1438 PyErr_Format(PyExc_OverflowError,
1439 "value %ld is greater than '%s' maximum %ld",
1440 value, errmsg, max_value);
1441 }
1442 return 0;
1443 }
1444 return 1;
1445 }
1446
1447
1448 SWIGINTERN int
1449 SWIG_AsVal_long(PyObject* obj, long* val)
1450 {
1451 if (PyNumber_Check(obj)) {
1452 if (val) *val = PyInt_AsLong(obj);
1453 return 1;
1454 }
1455 else {
1456 SWIG_type_error("number", obj);
1457 }
1458 return 0;
1459 }
1460
1461
1462 #if INT_MAX != LONG_MAX
1463 SWIGINTERN int
1464 SWIG_AsVal_int(PyObject *obj, int *val)
1465 {
1466 const char* errmsg = val ? "int" : (char*)0;
1467 long v;
1468 if (SWIG_AsVal_long(obj, &v)) {
1469 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1470 if (val) *val = (int)(v);
1471 return 1;
1472 } else {
1473 return 0;
1474 }
1475 } else {
1476 PyErr_Clear();
1477 }
1478 if (val) {
1479 SWIG_type_error(errmsg, obj);
1480 }
1481 return 0;
1482 }
1483 #else
1484 SWIGINTERNSHORT int
1485 SWIG_AsVal_int(PyObject *obj, int *val)
1486 {
1487 return SWIG_AsVal_long(obj,(long*)val);
1488 }
1489 #endif
1490
1491
1492 SWIGINTERN int
1493 SWIG_AsVal_bool(PyObject *obj, bool *val)
1494 {
1495 if (obj == Py_True) {
1496 if (val) *val = true;
1497 return 1;
1498 }
1499 if (obj == Py_False) {
1500 if (val) *val = false;
1501 return 1;
1502 }
1503 int res = 0;
1504 if (SWIG_AsVal_int(obj, &res)) {
1505 if (val) *val = res ? true : false;
1506 return 1;
1507 } else {
1508 PyErr_Clear();
1509 }
1510 if (val) {
1511 SWIG_type_error("bool", obj);
1512 }
1513 return 0;
1514 }
1515
1516
1517 SWIGINTERNSHORT bool
1518 SWIG_As_bool(PyObject* obj)
1519 {
1520 bool v;
1521 if (!SWIG_AsVal_bool(obj, &v)) {
1522 /*
1523 this is needed to make valgrind/purify happier.
1524 */
1525 memset((void*)&v, 0, sizeof(bool));
1526 }
1527 return v;
1528 }
1529
1530
1531 SWIGINTERNSHORT int
1532 SWIG_Check_bool(PyObject* obj)
1533 {
1534 return SWIG_AsVal_bool(obj, (bool*)0);
1535 }
1536
1537
1538 SWIGINTERN int
1539 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1540 {
1541 long v = 0;
1542 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1543 SWIG_type_error("unsigned number", obj);
1544 }
1545 else if (val)
1546 *val = (unsigned long)v;
1547 return 1;
1548 }
1549
1550
1551 SWIGINTERNSHORT int
1552 SWIG_CheckUnsignedLongInRange(unsigned long value,
1553 unsigned long max_value,
1554 const char *errmsg)
1555 {
1556 if (value > max_value) {
1557 if (errmsg) {
1558 PyErr_Format(PyExc_OverflowError,
1559 "value %lu is greater than '%s' minimum %lu",
1560 value, errmsg, max_value);
1561 }
1562 return 0;
1563 }
1564 return 1;
1565 }
1566
1567
1568 SWIGINTERN int
1569 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
1570 {
1571 const char* errmsg = val ? "unsigned char" : (char*)0;
1572 unsigned long v;
1573 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1574 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
1575 if (val) *val = (unsigned char)(v);
1576 return 1;
1577 } else {
1578 return 0;
1579 }
1580 } else {
1581 PyErr_Clear();
1582 }
1583 if (val) {
1584 SWIG_type_error(errmsg, obj);
1585 }
1586 return 0;
1587 }
1588
1589
1590 SWIGINTERNSHORT unsigned char
1591 SWIG_As_unsigned_SS_char(PyObject* obj)
1592 {
1593 unsigned char v;
1594 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
1595 /*
1596 this is needed to make valgrind/purify happier.
1597 */
1598 memset((void*)&v, 0, sizeof(unsigned char));
1599 }
1600 return v;
1601 }
1602
1603
1604 SWIGINTERNSHORT int
1605 SWIG_Check_unsigned_SS_char(PyObject* obj)
1606 {
1607 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
1608 }
1609
1610
1611 SWIGINTERNSHORT unsigned long
1612 SWIG_As_unsigned_SS_long(PyObject* obj)
1613 {
1614 unsigned long v;
1615 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1616 /*
1617 this is needed to make valgrind/purify happier.
1618 */
1619 memset((void*)&v, 0, sizeof(unsigned long));
1620 }
1621 return v;
1622 }
1623
1624
1625 SWIGINTERNSHORT int
1626 SWIG_Check_unsigned_SS_long(PyObject* obj)
1627 {
1628 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1629 }
1630
1631
1632 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1633 #define SWIG_From_unsigned_SS_char PyInt_FromLong
1634 /*@@*/
1635
1636
1637 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1638 #define SWIG_From_long PyInt_FromLong
1639 /*@@*/
1640
1641 static PyObject *wxColour_Get(wxColour *self){
1642 PyObject* rv = PyTuple_New(3);
1643 int red = -1;
1644 int green = -1;
1645 int blue = -1;
1646 if (self->Ok()) {
1647 red = self->Red();
1648 green = self->Green();
1649 blue = self->Blue();
1650 }
1651 PyTuple_SetItem(rv, 0, PyInt_FromLong(red));
1652 PyTuple_SetItem(rv, 1, PyInt_FromLong(green));
1653 PyTuple_SetItem(rv, 2, PyInt_FromLong(blue));
1654 return rv;
1655 }
1656 static unsigned long wxColour_GetRGB(wxColour *self){
1657 return self->Red() | (self->Green() << 8) | (self->Blue() << 16);
1658 }
1659
1660 SWIGINTERNSHORT PyObject*
1661 SWIG_From_unsigned_SS_long(unsigned long value)
1662 {
1663 return (value > LONG_MAX) ?
1664 PyLong_FromUnsignedLong(value)
1665 : PyInt_FromLong((long)(value));
1666 }
1667
1668
1669 SWIGINTERNSHORT int
1670 SWIG_As_int(PyObject* obj)
1671 {
1672 int v;
1673 if (!SWIG_AsVal_int(obj, &v)) {
1674 /*
1675 this is needed to make valgrind/purify happier.
1676 */
1677 memset((void*)&v, 0, sizeof(int));
1678 }
1679 return v;
1680 }
1681
1682
1683 SWIGINTERNSHORT int
1684 SWIG_Check_int(PyObject* obj)
1685 {
1686 return SWIG_AsVal_int(obj, (int*)0);
1687 }
1688
1689
1690 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1691 #define SWIG_From_int PyInt_FromLong
1692 /*@@*/
1693
1694
1695 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1696 PyObject* o2;
1697 PyObject* o3;
1698
1699 if (!target) {
1700 target = o;
1701 } else if (target == Py_None) {
1702 Py_DECREF(Py_None);
1703 target = o;
1704 } else {
1705 if (!PyTuple_Check(target)) {
1706 o2 = target;
1707 target = PyTuple_New(1);
1708 PyTuple_SetItem(target, 0, o2);
1709 }
1710 o3 = PyTuple_New(1);
1711 PyTuple_SetItem(o3, 0, o);
1712
1713 o2 = target;
1714 target = PySequence_Concat(o2, o3);
1715 Py_DECREF(o2);
1716 Py_DECREF(o3);
1717 }
1718 return target;
1719 }
1720
1721
1722 static PyObject *wxPen_GetDashes(wxPen *self){
1723 wxDash* dashes;
1724 int count = self->GetDashes(&dashes);
1725 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1726 PyObject* retval = PyList_New(0);
1727 for (int x=0; x<count; x++) {
1728 PyObject* pyint = PyInt_FromLong(dashes[x]);
1729 PyList_Append(retval, pyint);
1730 Py_DECREF(pyint);
1731 }
1732 wxPyEndBlockThreads(blocked);
1733 return retval;
1734 }
1735 static void wxPen__SetDashes(wxPen *self,PyObject *_self,PyObject *pyDashes){
1736 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1737 int size = PyList_Size(pyDashes);
1738 wxDash* dashes = (wxDash*)byte_LIST_helper(pyDashes);
1739
1740 // black magic warning! The array of wxDashes needs to exist as
1741 // long as the pen does because wxPen does not copy the array. So
1742 // stick a copy in a Python string object and attach it to _self,
1743 // and then call SetDashes with a pointer to that array. Then
1744 // when the Python pen object is destroyed the array will be
1745 // cleaned up too.
1746 PyObject* strDashes = PyString_FromStringAndSize((char*)dashes, size*sizeof(wxDash));
1747 PyObject_SetAttrString(_self, "_dashes", strDashes);
1748
1749 self->SetDashes(size, (wxDash*)PyString_AS_STRING(strDashes));
1750 delete [] dashes;
1751 Py_DECREF(strDashes);
1752 wxPyEndBlockThreads(blocked);
1753 }
1754 static bool wxPen___eq__(wxPen *self,wxPen const *other){ return other ? (*self == *other) : false; }
1755 static bool wxPen___ne__(wxPen *self,wxPen const *other){ return other ? (*self != *other) : true; }
1756
1757 #include <wx/image.h>
1758
1759 static char** ConvertListOfStrings(PyObject* listOfStrings) {
1760 char** cArray = NULL;
1761 int count;
1762
1763 if (!PyList_Check(listOfStrings)) {
1764 PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
1765 return NULL;
1766 }
1767 count = PyList_Size(listOfStrings);
1768 cArray = new char*[count];
1769
1770 for(int x=0; x<count; x++) {
1771 // TODO: Need some validation and error checking here
1772 cArray[x] = PyString_AsString(PyList_GET_ITEM(listOfStrings, x));
1773 }
1774 return cArray;
1775 }
1776
1777
1778 static wxBitmap *new_wxBitmap(PyObject *listOfStrings){
1779 char** cArray = NULL;
1780 wxBitmap* bmp;
1781
1782 cArray = ConvertListOfStrings(listOfStrings);
1783 if (! cArray)
1784 return NULL;
1785 bmp = new wxBitmap(cArray);
1786 delete [] cArray;
1787 return bmp;
1788 }
1789 static wxBitmap *new_wxBitmap(PyObject *bits,int width,int height,int depth=1){
1790 char* buf;
1791 int length;
1792 PyString_AsStringAndSize(bits, &buf, &length);
1793 return new wxBitmap(buf, width, height, depth);
1794 }
1795 static wxSize wxBitmap_GetSize(wxBitmap *self){
1796 wxSize size(self->GetWidth(), self->GetHeight());
1797 return size;
1798 }
1799 static void wxBitmap_SetMaskColour(wxBitmap *self,wxColour const &colour){
1800 wxMask *mask = new wxMask(*self, colour);
1801 self->SetMask(mask);
1802 }
1803 static void wxBitmap_SetSize(wxBitmap *self,wxSize const &size){
1804 self->SetWidth(size.x);
1805 self->SetHeight(size.y);
1806 }
1807 static bool wxBitmap___eq__(wxBitmap *self,wxBitmap const *other){ return other ? (*self == *other) : false; }
1808 static bool wxBitmap___ne__(wxBitmap *self,wxBitmap const *other){ return other ? (*self != *other) : true; }
1809 static wxMask *new_wxMask(wxBitmap const &bitmap,wxColour const &colour=wxNullColour){
1810 if ( !colour.Ok() )
1811 return new wxMask(bitmap, *wxBLACK);
1812 else
1813 return new wxMask(bitmap, colour);
1814 }
1815
1816 #include <wx/iconbndl.h>
1817
1818 static wxIcon *new_wxIcon(wxBitmap const &bmp){
1819 wxIcon* icon = new wxIcon();
1820 icon->CopyFromBitmap(bmp);
1821 return icon;
1822 }
1823 static wxIcon *new_wxIcon(PyObject *listOfStrings){
1824 char** cArray = NULL;
1825 wxIcon* icon;
1826
1827 cArray = ConvertListOfStrings(listOfStrings);
1828 if (! cArray)
1829 return NULL;
1830 icon = new wxIcon(cArray);
1831 delete [] cArray;
1832 return icon;
1833 }
1834 static wxIconLocation *new_wxIconLocation(wxString const *filename=&wxPyEmptyString,int num=0){
1835
1836
1837
1838 return new wxIconLocation(*filename);
1839
1840 }
1841 static void wxIconLocation_SetIndex(wxIconLocation *self,int num){
1842
1843
1844
1845 // do nothing
1846
1847 }
1848 static int wxIconLocation_GetIndex(wxIconLocation *self){
1849
1850
1851
1852 return -1;
1853
1854 }
1855
1856 SWIGINTERNSHORT long
1857 SWIG_As_long(PyObject* obj)
1858 {
1859 long v;
1860 if (!SWIG_AsVal_long(obj, &v)) {
1861 /*
1862 this is needed to make valgrind/purify happier.
1863 */
1864 memset((void*)&v, 0, sizeof(long));
1865 }
1866 return v;
1867 }
1868
1869
1870 SWIGINTERNSHORT int
1871 SWIG_Check_long(PyObject* obj)
1872 {
1873 return SWIG_AsVal_long(obj, (long*)0);
1874 }
1875
1876 static wxCursor *new_wxCursor(wxString const &cursorName,long type,int hotSpotX=0,int hotSpotY=0){
1877 #ifdef __WXGTK__
1878 wxImage img(cursorName, type);
1879 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X, hotSpotX);
1880 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y, hotSpotY);
1881 return new wxCursor(img);
1882 #else
1883 return new wxCursor(cursorName, type, hotSpotX, hotSpotY);
1884 #endif
1885 }
1886
1887
1888 static void wxRegionIterator_Next(wxRegionIterator *self){
1889 (*self) ++;
1890 }
1891 static bool wxRegionIterator___nonzero__(wxRegionIterator *self){
1892 return self->operator bool();
1893 }
1894
1895 #include <wx/fontutil.h>
1896 #include <wx/fontmap.h>
1897 #include <wx/fontenum.h>
1898
1899 static wxString wxNativeFontInfo___str__(wxNativeFontInfo *self){
1900 return self->ToString();
1901 }
1902
1903 wxNativeEncodingInfo* wxGetNativeFontEncoding(wxFontEncoding encoding) {
1904 static wxNativeEncodingInfo info;
1905 if ( wxGetNativeFontEncoding(encoding, &info) )
1906 return &info;
1907 else
1908 return NULL;
1909 }
1910
1911 static PyObject *wxFontMapper_GetAltForEncoding(wxFontMapper *self,wxFontEncoding encoding,wxString const &facename=wxPyEmptyString,bool interactive=true){
1912 wxFontEncoding alt_enc;
1913 if (self->GetAltForEncoding(encoding, &alt_enc, facename, interactive))
1914 return PyInt_FromLong(alt_enc);
1915 else {
1916 Py_INCREF(Py_None);
1917 return Py_None;
1918 }
1919 }
1920 static wxFont *new_wxFont(wxString const &info){
1921 wxNativeFontInfo nfi;
1922 nfi.FromString(info);
1923 return new wxFont(nfi);
1924 }
1925 static wxFont *new_wxFont(int pointSize,wxFontFamily family,int flags=wxFONTFLAG_DEFAULT,wxString const &face=wxPyEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1926 return wxFont::New(pointSize, family, flags, face, encoding);
1927 }
1928 static wxFont *new_wxFont(wxSize const &pixelSize,int family,int style,int weight,bool underlined=false,wxString const &face=wxEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1929 return wxFontBase::New(pixelSize, family,
1930 style, weight, underlined,
1931 face, encoding);
1932 }
1933 static bool wxFont___eq__(wxFont *self,wxFont const *other){ return other ? (*self == *other) : false; }
1934 static bool wxFont___ne__(wxFont *self,wxFont const *other){ return other ? (*self != *other) : true; }
1935
1936 class wxPyFontEnumerator : public wxFontEnumerator {
1937 public:
1938 wxPyFontEnumerator() {}
1939 ~wxPyFontEnumerator() {}
1940
1941 DEC_PYCALLBACK_BOOL_STRING(OnFacename);
1942 DEC_PYCALLBACK_BOOL_STRINGSTRING(OnFontEncoding);
1943
1944 PYPRIVATE;
1945 };
1946
1947 IMP_PYCALLBACK_BOOL_STRING(wxPyFontEnumerator, wxFontEnumerator, OnFacename);
1948 IMP_PYCALLBACK_BOOL_STRINGSTRING(wxPyFontEnumerator, wxFontEnumerator, OnFontEncoding);
1949
1950
1951 static PyObject *wxPyFontEnumerator_GetEncodings(wxPyFontEnumerator *self){
1952 wxArrayString* arr = self->GetEncodings();
1953 if (arr)
1954 return wxArrayString2PyList_helper(*arr);
1955 else
1956 return PyList_New(0);
1957 }
1958 static PyObject *wxPyFontEnumerator_GetFacenames(wxPyFontEnumerator *self){
1959 wxArrayString* arr = self->GetFacenames();
1960 if (arr)
1961 return wxArrayString2PyList_helper(*arr);
1962 else
1963 return PyList_New(0);
1964 }
1965
1966 #include <locale.h>
1967
1968 static wxLocale *new_wxLocale(int language=-1,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
1969 wxLocale* loc;
1970 if (language == -1)
1971 loc = new wxLocale();
1972 else
1973 loc = new wxLocale(language, flags);
1974 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1975 // for the floating point conversions and such to work right.
1976 #if PY_VERSION_HEX < 0x02040000
1977 setlocale(LC_NUMERIC, "C");
1978 #endif
1979 return loc;
1980 }
1981 static bool wxLocale_Init1(wxLocale *self,wxString const &szName,wxString const &szShort=wxPyEmptyString,wxString const &szLocale=wxPyEmptyString,bool bLoadDefault=true,bool bConvertEncoding=false){
1982 bool rc = self->Init(szName, szShort, szLocale, bLoadDefault, bConvertEncoding);
1983 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1984 // for the floating point conversions and such to work right.
1985 #if PY_VERSION_HEX < 0x02040000
1986 setlocale(LC_NUMERIC, "C");
1987 #endif
1988 return rc;
1989 }
1990 static bool wxLocale_Init2(wxLocale *self,int language=wxLANGUAGE_DEFAULT,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
1991 bool rc = self->Init(language, flags);
1992 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1993 // for the floating point conversions and such to work right.
1994 #if PY_VERSION_HEX < 0x02040000
1995 setlocale(LC_NUMERIC, "C");
1996 #endif
1997 return rc;
1998 }
1999
2000 #include "wx/wxPython/pydrawxxx.h"
2001
2002 static wxColour wxDC_GetPixel(wxDC *self,int x,int y){
2003 wxColour col;
2004 self->GetPixel(x, y, &col);
2005 return col;
2006 }
2007 static wxColour wxDC_GetPixelPoint(wxDC *self,wxPoint const &pt){
2008 wxColour col;
2009 self->GetPixel(pt, &col);
2010 return col;
2011 }
2012
2013 SWIGINTERN int
2014 SWIG_AsVal_double(PyObject *obj, double* val)
2015 {
2016 if (PyNumber_Check(obj)) {
2017 if (val) *val = PyFloat_AsDouble(obj);
2018 return 1;
2019 }
2020 else {
2021 SWIG_type_error("number", obj);
2022 }
2023 return 0;
2024 }
2025
2026
2027 SWIGINTERNSHORT double
2028 SWIG_As_double(PyObject* obj)
2029 {
2030 double v;
2031 if (!SWIG_AsVal_double(obj, &v)) {
2032 /*
2033 this is needed to make valgrind/purify happier.
2034 */
2035 memset((void*)&v, 0, sizeof(double));
2036 }
2037 return v;
2038 }
2039
2040
2041 SWIGINTERNSHORT int
2042 SWIG_Check_double(PyObject* obj)
2043 {
2044 return SWIG_AsVal_double(obj, (double*)0);
2045 }
2046
2047 static wxRect wxDC_DrawImageLabel(wxDC *self,wxString const &text,wxBitmap const &image,wxRect const &rect,int alignment=wxALIGN_LEFT|wxALIGN_TOP,int indexAccel=-1){
2048 wxRect rv;
2049 self->DrawLabel(text, image, rect, alignment, indexAccel, &rv);
2050 return rv;
2051 }
2052
2053 static wxRect wxDC_GetClippingRect(wxDC *self){
2054 wxRect rect;
2055 self->GetClippingBox(rect);
2056 return rect;
2057 }
2058 static wxArrayInt wxDC_GetPartialTextExtents(wxDC *self,wxString const &text){
2059 wxArrayInt widths;
2060 self->GetPartialTextExtents(text, widths);
2061 return widths;
2062 }
2063
2064 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2065 #define SWIG_From_double PyFloat_FromDouble
2066 /*@@*/
2067
2068
2069 static void wxDC_SetLogicalOriginPoint(wxDC *self,wxPoint const &point){
2070 self->SetLogicalOrigin(point.x, point.y);
2071 }
2072 static void wxDC_SetDeviceOriginPoint(wxDC *self,wxPoint const &point){
2073 self->SetDeviceOrigin(point.x, point.y);
2074 }
2075 static void wxDC_CalcBoundingBoxPoint(wxDC *self,wxPoint const &point){
2076 self->CalcBoundingBox(point.x, point.y);
2077 }
2078 static PyObject *wxDC__DrawPointList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2079 return wxPyDrawXXXList(*self, wxPyDrawXXXPoint, pyCoords, pyPens, pyBrushes);
2080 }
2081 static PyObject *wxDC__DrawLineList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2082 return wxPyDrawXXXList(*self, wxPyDrawXXXLine, pyCoords, pyPens, pyBrushes);
2083 }
2084 static PyObject *wxDC__DrawRectangleList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2085 return wxPyDrawXXXList(*self, wxPyDrawXXXRectangle, pyCoords, pyPens, pyBrushes);
2086 }
2087 static PyObject *wxDC__DrawEllipseList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2088 return wxPyDrawXXXList(*self, wxPyDrawXXXEllipse, pyCoords, pyPens, pyBrushes);
2089 }
2090 static PyObject *wxDC__DrawPolygonList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2091 return wxPyDrawXXXList(*self, wxPyDrawXXXPolygon, pyCoords, pyPens, pyBrushes);
2092 }
2093 static PyObject *wxDC__DrawTextList(wxDC *self,PyObject *textList,PyObject *pyPoints,PyObject *foregroundList,PyObject *backgroundList){
2094 return wxPyDrawTextList(*self, textList, pyPoints, foregroundList, backgroundList);
2095 }
2096
2097 static void wxDC_GetBoundingBox(wxDC* dc, int* x1, int* y1, int* x2, int* y2) {
2098 *x1 = dc->MinX();
2099 *y1 = dc->MinY();
2100 *x2 = dc->MaxX();
2101 *y2 = dc->MaxY();
2102 }
2103
2104
2105 #include <wx/dcbuffer.h>
2106
2107
2108 #include <wx/dcps.h>
2109
2110
2111 class wxMetaFile : public wxObject {
2112 public:
2113 wxMetaFile(const wxString&)
2114 { wxPyRaiseNotImplemented(); }
2115 };
2116
2117 class wxMetaFileDC : public wxClientDC {
2118 public:
2119 wxMetaFileDC(const wxString&, int, int, const wxString&)
2120 { wxPyRaiseNotImplemented(); }
2121 };
2122
2123
2124
2125 class wxPrinterDC : public wxClientDC {
2126 public:
2127 wxPrinterDC(const wxPrintData&)
2128 { wxPyRaiseNotImplemented(); }
2129
2130 };
2131
2132
2133
2134 static void wxColourDatabase_Append(wxColourDatabase *self,wxString const &name,int red,int green,int blue){
2135 self->AddColour(name, wxColour(red, green, blue));
2136 }
2137
2138 #include <wx/effects.h>
2139
2140 #ifdef __cplusplus
2141 extern "C" {
2142 #endif
2143 static PyObject *_wrap_new_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2144 PyObject *resultobj;
2145 wxGDIObject *result;
2146 char *kwnames[] = {
2147 NULL
2148 };
2149
2150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GDIObject",kwnames)) goto fail;
2151 {
2152 if (!wxPyCheckForApp()) SWIG_fail;
2153 PyThreadState* __tstate = wxPyBeginAllowThreads();
2154 result = (wxGDIObject *)new wxGDIObject();
2155
2156 wxPyEndAllowThreads(__tstate);
2157 if (PyErr_Occurred()) SWIG_fail;
2158 }
2159 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGDIObject, 1);
2160 return resultobj;
2161 fail:
2162 return NULL;
2163 }
2164
2165
2166 static PyObject *_wrap_delete_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2167 PyObject *resultobj;
2168 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2169 PyObject * obj0 = 0 ;
2170 char *kwnames[] = {
2171 (char *) "self", NULL
2172 };
2173
2174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GDIObject",kwnames,&obj0)) goto fail;
2175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2176 if (SWIG_arg_fail(1)) SWIG_fail;
2177 {
2178 PyThreadState* __tstate = wxPyBeginAllowThreads();
2179 delete arg1;
2180
2181 wxPyEndAllowThreads(__tstate);
2182 if (PyErr_Occurred()) SWIG_fail;
2183 }
2184 Py_INCREF(Py_None); resultobj = Py_None;
2185 return resultobj;
2186 fail:
2187 return NULL;
2188 }
2189
2190
2191 static PyObject *_wrap_GDIObject_GetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2192 PyObject *resultobj;
2193 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2194 bool result;
2195 PyObject * obj0 = 0 ;
2196 char *kwnames[] = {
2197 (char *) "self", NULL
2198 };
2199
2200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_GetVisible",kwnames,&obj0)) goto fail;
2201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2202 if (SWIG_arg_fail(1)) SWIG_fail;
2203 {
2204 PyThreadState* __tstate = wxPyBeginAllowThreads();
2205 result = (bool)(arg1)->GetVisible();
2206
2207 wxPyEndAllowThreads(__tstate);
2208 if (PyErr_Occurred()) SWIG_fail;
2209 }
2210 {
2211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2212 }
2213 return resultobj;
2214 fail:
2215 return NULL;
2216 }
2217
2218
2219 static PyObject *_wrap_GDIObject_SetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2220 PyObject *resultobj;
2221 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2222 bool arg2 ;
2223 PyObject * obj0 = 0 ;
2224 PyObject * obj1 = 0 ;
2225 char *kwnames[] = {
2226 (char *) "self",(char *) "visible", NULL
2227 };
2228
2229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GDIObject_SetVisible",kwnames,&obj0,&obj1)) goto fail;
2230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2231 if (SWIG_arg_fail(1)) SWIG_fail;
2232 {
2233 arg2 = (bool)(SWIG_As_bool(obj1));
2234 if (SWIG_arg_fail(2)) SWIG_fail;
2235 }
2236 {
2237 PyThreadState* __tstate = wxPyBeginAllowThreads();
2238 (arg1)->SetVisible(arg2);
2239
2240 wxPyEndAllowThreads(__tstate);
2241 if (PyErr_Occurred()) SWIG_fail;
2242 }
2243 Py_INCREF(Py_None); resultobj = Py_None;
2244 return resultobj;
2245 fail:
2246 return NULL;
2247 }
2248
2249
2250 static PyObject *_wrap_GDIObject_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
2251 PyObject *resultobj;
2252 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2253 bool result;
2254 PyObject * obj0 = 0 ;
2255 char *kwnames[] = {
2256 (char *) "self", NULL
2257 };
2258
2259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_IsNull",kwnames,&obj0)) goto fail;
2260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2261 if (SWIG_arg_fail(1)) SWIG_fail;
2262 {
2263 PyThreadState* __tstate = wxPyBeginAllowThreads();
2264 result = (bool)(arg1)->IsNull();
2265
2266 wxPyEndAllowThreads(__tstate);
2267 if (PyErr_Occurred()) SWIG_fail;
2268 }
2269 {
2270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2271 }
2272 return resultobj;
2273 fail:
2274 return NULL;
2275 }
2276
2277
2278 static PyObject * GDIObject_swigregister(PyObject *, PyObject *args) {
2279 PyObject *obj;
2280 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2281 SWIG_TypeClientData(SWIGTYPE_p_wxGDIObject, obj);
2282 Py_INCREF(obj);
2283 return Py_BuildValue((char *)"");
2284 }
2285 static PyObject *_wrap_new_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2286 PyObject *resultobj;
2287 byte arg1 = (byte) 0 ;
2288 byte arg2 = (byte) 0 ;
2289 byte arg3 = (byte) 0 ;
2290 wxColour *result;
2291 PyObject * obj0 = 0 ;
2292 PyObject * obj1 = 0 ;
2293 PyObject * obj2 = 0 ;
2294 char *kwnames[] = {
2295 (char *) "red",(char *) "green",(char *) "blue", NULL
2296 };
2297
2298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Colour",kwnames,&obj0,&obj1,&obj2)) goto fail;
2299 if (obj0) {
2300 {
2301 arg1 = (byte)(SWIG_As_unsigned_SS_char(obj0));
2302 if (SWIG_arg_fail(1)) SWIG_fail;
2303 }
2304 }
2305 if (obj1) {
2306 {
2307 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2308 if (SWIG_arg_fail(2)) SWIG_fail;
2309 }
2310 }
2311 if (obj2) {
2312 {
2313 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2314 if (SWIG_arg_fail(3)) SWIG_fail;
2315 }
2316 }
2317 {
2318 PyThreadState* __tstate = wxPyBeginAllowThreads();
2319 result = (wxColour *)new wxColour(arg1,arg2,arg3);
2320
2321 wxPyEndAllowThreads(__tstate);
2322 if (PyErr_Occurred()) SWIG_fail;
2323 }
2324 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2325 return resultobj;
2326 fail:
2327 return NULL;
2328 }
2329
2330
2331 static PyObject *_wrap_new_NamedColour(PyObject *, PyObject *args, PyObject *kwargs) {
2332 PyObject *resultobj;
2333 wxString *arg1 = 0 ;
2334 wxColour *result;
2335 bool temp1 = false ;
2336 PyObject * obj0 = 0 ;
2337 char *kwnames[] = {
2338 (char *) "colorName", NULL
2339 };
2340
2341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_NamedColour",kwnames,&obj0)) goto fail;
2342 {
2343 arg1 = wxString_in_helper(obj0);
2344 if (arg1 == NULL) SWIG_fail;
2345 temp1 = true;
2346 }
2347 {
2348 if (!wxPyCheckForApp()) SWIG_fail;
2349 PyThreadState* __tstate = wxPyBeginAllowThreads();
2350 result = (wxColour *)new wxColour((wxString const &)*arg1);
2351
2352 wxPyEndAllowThreads(__tstate);
2353 if (PyErr_Occurred()) SWIG_fail;
2354 }
2355 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2356 {
2357 if (temp1)
2358 delete arg1;
2359 }
2360 return resultobj;
2361 fail:
2362 {
2363 if (temp1)
2364 delete arg1;
2365 }
2366 return NULL;
2367 }
2368
2369
2370 static PyObject *_wrap_new_ColourRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2371 PyObject *resultobj;
2372 unsigned long arg1 ;
2373 wxColour *result;
2374 PyObject * obj0 = 0 ;
2375 char *kwnames[] = {
2376 (char *) "colRGB", NULL
2377 };
2378
2379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ColourRGB",kwnames,&obj0)) goto fail;
2380 {
2381 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
2382 if (SWIG_arg_fail(1)) SWIG_fail;
2383 }
2384 {
2385 PyThreadState* __tstate = wxPyBeginAllowThreads();
2386 result = (wxColour *)new wxColour(arg1);
2387
2388 wxPyEndAllowThreads(__tstate);
2389 if (PyErr_Occurred()) SWIG_fail;
2390 }
2391 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2392 return resultobj;
2393 fail:
2394 return NULL;
2395 }
2396
2397
2398 static PyObject *_wrap_delete_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2399 PyObject *resultobj;
2400 wxColour *arg1 = (wxColour *) 0 ;
2401 PyObject * obj0 = 0 ;
2402 char *kwnames[] = {
2403 (char *) "self", NULL
2404 };
2405
2406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Colour",kwnames,&obj0)) goto fail;
2407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2408 if (SWIG_arg_fail(1)) SWIG_fail;
2409 {
2410 PyThreadState* __tstate = wxPyBeginAllowThreads();
2411 delete arg1;
2412
2413 wxPyEndAllowThreads(__tstate);
2414 if (PyErr_Occurred()) SWIG_fail;
2415 }
2416 Py_INCREF(Py_None); resultobj = Py_None;
2417 return resultobj;
2418 fail:
2419 return NULL;
2420 }
2421
2422
2423 static PyObject *_wrap_Colour_Red(PyObject *, PyObject *args, PyObject *kwargs) {
2424 PyObject *resultobj;
2425 wxColour *arg1 = (wxColour *) 0 ;
2426 byte result;
2427 PyObject * obj0 = 0 ;
2428 char *kwnames[] = {
2429 (char *) "self", NULL
2430 };
2431
2432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Red",kwnames,&obj0)) goto fail;
2433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2434 if (SWIG_arg_fail(1)) SWIG_fail;
2435 {
2436 PyThreadState* __tstate = wxPyBeginAllowThreads();
2437 result = (byte)(arg1)->Red();
2438
2439 wxPyEndAllowThreads(__tstate);
2440 if (PyErr_Occurred()) SWIG_fail;
2441 }
2442 {
2443 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2444 }
2445 return resultobj;
2446 fail:
2447 return NULL;
2448 }
2449
2450
2451 static PyObject *_wrap_Colour_Green(PyObject *, PyObject *args, PyObject *kwargs) {
2452 PyObject *resultobj;
2453 wxColour *arg1 = (wxColour *) 0 ;
2454 byte result;
2455 PyObject * obj0 = 0 ;
2456 char *kwnames[] = {
2457 (char *) "self", NULL
2458 };
2459
2460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Green",kwnames,&obj0)) goto fail;
2461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2462 if (SWIG_arg_fail(1)) SWIG_fail;
2463 {
2464 PyThreadState* __tstate = wxPyBeginAllowThreads();
2465 result = (byte)(arg1)->Green();
2466
2467 wxPyEndAllowThreads(__tstate);
2468 if (PyErr_Occurred()) SWIG_fail;
2469 }
2470 {
2471 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2472 }
2473 return resultobj;
2474 fail:
2475 return NULL;
2476 }
2477
2478
2479 static PyObject *_wrap_Colour_Blue(PyObject *, PyObject *args, PyObject *kwargs) {
2480 PyObject *resultobj;
2481 wxColour *arg1 = (wxColour *) 0 ;
2482 byte result;
2483 PyObject * obj0 = 0 ;
2484 char *kwnames[] = {
2485 (char *) "self", NULL
2486 };
2487
2488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Blue",kwnames,&obj0)) goto fail;
2489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2490 if (SWIG_arg_fail(1)) SWIG_fail;
2491 {
2492 PyThreadState* __tstate = wxPyBeginAllowThreads();
2493 result = (byte)(arg1)->Blue();
2494
2495 wxPyEndAllowThreads(__tstate);
2496 if (PyErr_Occurred()) SWIG_fail;
2497 }
2498 {
2499 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2500 }
2501 return resultobj;
2502 fail:
2503 return NULL;
2504 }
2505
2506
2507 static PyObject *_wrap_Colour_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
2508 PyObject *resultobj;
2509 wxColour *arg1 = (wxColour *) 0 ;
2510 bool result;
2511 PyObject * obj0 = 0 ;
2512 char *kwnames[] = {
2513 (char *) "self", NULL
2514 };
2515
2516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Ok",kwnames,&obj0)) goto fail;
2517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2518 if (SWIG_arg_fail(1)) SWIG_fail;
2519 {
2520 PyThreadState* __tstate = wxPyBeginAllowThreads();
2521 result = (bool)(arg1)->Ok();
2522
2523 wxPyEndAllowThreads(__tstate);
2524 if (PyErr_Occurred()) SWIG_fail;
2525 }
2526 {
2527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2528 }
2529 return resultobj;
2530 fail:
2531 return NULL;
2532 }
2533
2534
2535 static PyObject *_wrap_Colour_Set(PyObject *, PyObject *args, PyObject *kwargs) {
2536 PyObject *resultobj;
2537 wxColour *arg1 = (wxColour *) 0 ;
2538 byte arg2 ;
2539 byte arg3 ;
2540 byte arg4 ;
2541 PyObject * obj0 = 0 ;
2542 PyObject * obj1 = 0 ;
2543 PyObject * obj2 = 0 ;
2544 PyObject * obj3 = 0 ;
2545 char *kwnames[] = {
2546 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2547 };
2548
2549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Colour_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2551 if (SWIG_arg_fail(1)) SWIG_fail;
2552 {
2553 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2554 if (SWIG_arg_fail(2)) SWIG_fail;
2555 }
2556 {
2557 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2558 if (SWIG_arg_fail(3)) SWIG_fail;
2559 }
2560 {
2561 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2562 if (SWIG_arg_fail(4)) SWIG_fail;
2563 }
2564 {
2565 PyThreadState* __tstate = wxPyBeginAllowThreads();
2566 (arg1)->Set(arg2,arg3,arg4);
2567
2568 wxPyEndAllowThreads(__tstate);
2569 if (PyErr_Occurred()) SWIG_fail;
2570 }
2571 Py_INCREF(Py_None); resultobj = Py_None;
2572 return resultobj;
2573 fail:
2574 return NULL;
2575 }
2576
2577
2578 static PyObject *_wrap_Colour_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2579 PyObject *resultobj;
2580 wxColour *arg1 = (wxColour *) 0 ;
2581 unsigned long arg2 ;
2582 PyObject * obj0 = 0 ;
2583 PyObject * obj1 = 0 ;
2584 char *kwnames[] = {
2585 (char *) "self",(char *) "colRGB", NULL
2586 };
2587
2588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetRGB",kwnames,&obj0,&obj1)) goto fail;
2589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2590 if (SWIG_arg_fail(1)) SWIG_fail;
2591 {
2592 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
2593 if (SWIG_arg_fail(2)) SWIG_fail;
2594 }
2595 {
2596 PyThreadState* __tstate = wxPyBeginAllowThreads();
2597 (arg1)->Set(arg2);
2598
2599 wxPyEndAllowThreads(__tstate);
2600 if (PyErr_Occurred()) SWIG_fail;
2601 }
2602 Py_INCREF(Py_None); resultobj = Py_None;
2603 return resultobj;
2604 fail:
2605 return NULL;
2606 }
2607
2608
2609 static PyObject *_wrap_Colour_SetFromName(PyObject *, PyObject *args, PyObject *kwargs) {
2610 PyObject *resultobj;
2611 wxColour *arg1 = (wxColour *) 0 ;
2612 wxString *arg2 = 0 ;
2613 bool temp2 = false ;
2614 PyObject * obj0 = 0 ;
2615 PyObject * obj1 = 0 ;
2616 char *kwnames[] = {
2617 (char *) "self",(char *) "colourName", NULL
2618 };
2619
2620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetFromName",kwnames,&obj0,&obj1)) goto fail;
2621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2622 if (SWIG_arg_fail(1)) SWIG_fail;
2623 {
2624 arg2 = wxString_in_helper(obj1);
2625 if (arg2 == NULL) SWIG_fail;
2626 temp2 = true;
2627 }
2628 {
2629 PyThreadState* __tstate = wxPyBeginAllowThreads();
2630 (arg1)->InitFromName((wxString const &)*arg2);
2631
2632 wxPyEndAllowThreads(__tstate);
2633 if (PyErr_Occurred()) SWIG_fail;
2634 }
2635 Py_INCREF(Py_None); resultobj = Py_None;
2636 {
2637 if (temp2)
2638 delete arg2;
2639 }
2640 return resultobj;
2641 fail:
2642 {
2643 if (temp2)
2644 delete arg2;
2645 }
2646 return NULL;
2647 }
2648
2649
2650 static PyObject *_wrap_Colour_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2651 PyObject *resultobj;
2652 wxColour *arg1 = (wxColour *) 0 ;
2653 long result;
2654 PyObject * obj0 = 0 ;
2655 char *kwnames[] = {
2656 (char *) "self", NULL
2657 };
2658
2659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetPixel",kwnames,&obj0)) goto fail;
2660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2661 if (SWIG_arg_fail(1)) SWIG_fail;
2662 {
2663 PyThreadState* __tstate = wxPyBeginAllowThreads();
2664 result = (long)((wxColour const *)arg1)->GetPixel();
2665
2666 wxPyEndAllowThreads(__tstate);
2667 if (PyErr_Occurred()) SWIG_fail;
2668 }
2669 {
2670 resultobj = SWIG_From_long((long)(result));
2671 }
2672 return resultobj;
2673 fail:
2674 return NULL;
2675 }
2676
2677
2678 static PyObject *_wrap_Colour___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
2679 PyObject *resultobj;
2680 wxColour *arg1 = (wxColour *) 0 ;
2681 wxColour *arg2 = 0 ;
2682 bool result;
2683 wxColour temp2 ;
2684 PyObject * obj0 = 0 ;
2685 PyObject * obj1 = 0 ;
2686 char *kwnames[] = {
2687 (char *) "self",(char *) "colour", NULL
2688 };
2689
2690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___eq__",kwnames,&obj0,&obj1)) goto fail;
2691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2692 if (SWIG_arg_fail(1)) SWIG_fail;
2693 {
2694 arg2 = &temp2;
2695 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2696 }
2697 {
2698 PyThreadState* __tstate = wxPyBeginAllowThreads();
2699 result = (bool)((wxColour const *)arg1)->operator ==((wxColour const &)*arg2);
2700
2701 wxPyEndAllowThreads(__tstate);
2702 if (PyErr_Occurred()) SWIG_fail;
2703 }
2704 {
2705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2706 }
2707 return resultobj;
2708 fail:
2709 return NULL;
2710 }
2711
2712
2713 static PyObject *_wrap_Colour___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
2714 PyObject *resultobj;
2715 wxColour *arg1 = (wxColour *) 0 ;
2716 wxColour *arg2 = 0 ;
2717 bool result;
2718 wxColour temp2 ;
2719 PyObject * obj0 = 0 ;
2720 PyObject * obj1 = 0 ;
2721 char *kwnames[] = {
2722 (char *) "self",(char *) "colour", NULL
2723 };
2724
2725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___ne__",kwnames,&obj0,&obj1)) goto fail;
2726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2727 if (SWIG_arg_fail(1)) SWIG_fail;
2728 {
2729 arg2 = &temp2;
2730 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2731 }
2732 {
2733 PyThreadState* __tstate = wxPyBeginAllowThreads();
2734 result = (bool)((wxColour const *)arg1)->operator !=((wxColour const &)*arg2);
2735
2736 wxPyEndAllowThreads(__tstate);
2737 if (PyErr_Occurred()) SWIG_fail;
2738 }
2739 {
2740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2741 }
2742 return resultobj;
2743 fail:
2744 return NULL;
2745 }
2746
2747
2748 static PyObject *_wrap_Colour_Get(PyObject *, PyObject *args, PyObject *kwargs) {
2749 PyObject *resultobj;
2750 wxColour *arg1 = (wxColour *) 0 ;
2751 PyObject *result;
2752 PyObject * obj0 = 0 ;
2753 char *kwnames[] = {
2754 (char *) "self", NULL
2755 };
2756
2757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Get",kwnames,&obj0)) goto fail;
2758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2759 if (SWIG_arg_fail(1)) SWIG_fail;
2760 {
2761 PyThreadState* __tstate = wxPyBeginAllowThreads();
2762 result = (PyObject *)wxColour_Get(arg1);
2763
2764 wxPyEndAllowThreads(__tstate);
2765 if (PyErr_Occurred()) SWIG_fail;
2766 }
2767 resultobj = result;
2768 return resultobj;
2769 fail:
2770 return NULL;
2771 }
2772
2773
2774 static PyObject *_wrap_Colour_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2775 PyObject *resultobj;
2776 wxColour *arg1 = (wxColour *) 0 ;
2777 unsigned long result;
2778 PyObject * obj0 = 0 ;
2779 char *kwnames[] = {
2780 (char *) "self", NULL
2781 };
2782
2783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetRGB",kwnames,&obj0)) goto fail;
2784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2785 if (SWIG_arg_fail(1)) SWIG_fail;
2786 {
2787 PyThreadState* __tstate = wxPyBeginAllowThreads();
2788 result = (unsigned long)wxColour_GetRGB(arg1);
2789
2790 wxPyEndAllowThreads(__tstate);
2791 if (PyErr_Occurred()) SWIG_fail;
2792 }
2793 {
2794 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
2795 }
2796 return resultobj;
2797 fail:
2798 return NULL;
2799 }
2800
2801
2802 static PyObject * Colour_swigregister(PyObject *, PyObject *args) {
2803 PyObject *obj;
2804 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2805 SWIG_TypeClientData(SWIGTYPE_p_wxColour, obj);
2806 Py_INCREF(obj);
2807 return Py_BuildValue((char *)"");
2808 }
2809 static PyObject *_wrap_new_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2810 PyObject *resultobj;
2811 int arg1 ;
2812 unsigned char *arg2 = (unsigned char *) 0 ;
2813 unsigned char *arg3 = (unsigned char *) 0 ;
2814 unsigned char *arg4 = (unsigned char *) 0 ;
2815 wxPalette *result;
2816 PyObject * obj0 = 0 ;
2817 PyObject * obj1 = 0 ;
2818 PyObject * obj2 = 0 ;
2819 PyObject * obj3 = 0 ;
2820 char *kwnames[] = {
2821 (char *) "n",(char *) "red",(char *) "green",(char *) "blue", NULL
2822 };
2823
2824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_Palette",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2825 {
2826 arg1 = (int)(SWIG_As_int(obj0));
2827 if (SWIG_arg_fail(1)) SWIG_fail;
2828 }
2829 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2830 if (SWIG_arg_fail(2)) SWIG_fail;
2831 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2832 if (SWIG_arg_fail(3)) SWIG_fail;
2833 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2834 if (SWIG_arg_fail(4)) SWIG_fail;
2835 {
2836 if (!wxPyCheckForApp()) SWIG_fail;
2837 PyThreadState* __tstate = wxPyBeginAllowThreads();
2838 result = (wxPalette *)new wxPalette(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
2839
2840 wxPyEndAllowThreads(__tstate);
2841 if (PyErr_Occurred()) SWIG_fail;
2842 }
2843 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 1);
2844 return resultobj;
2845 fail:
2846 return NULL;
2847 }
2848
2849
2850 static PyObject *_wrap_delete_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2851 PyObject *resultobj;
2852 wxPalette *arg1 = (wxPalette *) 0 ;
2853 PyObject * obj0 = 0 ;
2854 char *kwnames[] = {
2855 (char *) "self", NULL
2856 };
2857
2858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Palette",kwnames,&obj0)) goto fail;
2859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2860 if (SWIG_arg_fail(1)) SWIG_fail;
2861 {
2862 PyThreadState* __tstate = wxPyBeginAllowThreads();
2863 delete arg1;
2864
2865 wxPyEndAllowThreads(__tstate);
2866 if (PyErr_Occurred()) SWIG_fail;
2867 }
2868 Py_INCREF(Py_None); resultobj = Py_None;
2869 return resultobj;
2870 fail:
2871 return NULL;
2872 }
2873
2874
2875 static PyObject *_wrap_Palette_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2876 PyObject *resultobj;
2877 wxPalette *arg1 = (wxPalette *) 0 ;
2878 byte arg2 ;
2879 byte arg3 ;
2880 byte arg4 ;
2881 int result;
2882 PyObject * obj0 = 0 ;
2883 PyObject * obj1 = 0 ;
2884 PyObject * obj2 = 0 ;
2885 PyObject * obj3 = 0 ;
2886 char *kwnames[] = {
2887 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2888 };
2889
2890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Palette_GetPixel",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2892 if (SWIG_arg_fail(1)) SWIG_fail;
2893 {
2894 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2895 if (SWIG_arg_fail(2)) SWIG_fail;
2896 }
2897 {
2898 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2899 if (SWIG_arg_fail(3)) SWIG_fail;
2900 }
2901 {
2902 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2903 if (SWIG_arg_fail(4)) SWIG_fail;
2904 }
2905 {
2906 PyThreadState* __tstate = wxPyBeginAllowThreads();
2907 result = (int)(arg1)->GetPixel(arg2,arg3,arg4);
2908
2909 wxPyEndAllowThreads(__tstate);
2910 if (PyErr_Occurred()) SWIG_fail;
2911 }
2912 {
2913 resultobj = SWIG_From_int((int)(result));
2914 }
2915 return resultobj;
2916 fail:
2917 return NULL;
2918 }
2919
2920
2921 static PyObject *_wrap_Palette_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2922 PyObject *resultobj;
2923 wxPalette *arg1 = (wxPalette *) 0 ;
2924 int arg2 ;
2925 byte *arg3 = (byte *) 0 ;
2926 byte *arg4 = (byte *) 0 ;
2927 byte *arg5 = (byte *) 0 ;
2928 bool result;
2929 byte temp3 ;
2930 int res3 = 0 ;
2931 byte temp4 ;
2932 int res4 = 0 ;
2933 byte temp5 ;
2934 int res5 = 0 ;
2935 PyObject * obj0 = 0 ;
2936 PyObject * obj1 = 0 ;
2937 char *kwnames[] = {
2938 (char *) "self",(char *) "pixel", NULL
2939 };
2940
2941 arg3 = &temp3; res3 = SWIG_NEWOBJ;
2942 arg4 = &temp4; res4 = SWIG_NEWOBJ;
2943 arg5 = &temp5; res5 = SWIG_NEWOBJ;
2944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Palette_GetRGB",kwnames,&obj0,&obj1)) goto fail;
2945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2946 if (SWIG_arg_fail(1)) SWIG_fail;
2947 {
2948 arg2 = (int)(SWIG_As_int(obj1));
2949 if (SWIG_arg_fail(2)) SWIG_fail;
2950 }
2951 {
2952 PyThreadState* __tstate = wxPyBeginAllowThreads();
2953 result = (bool)(arg1)->GetRGB(arg2,arg3,arg4,arg5);
2954
2955 wxPyEndAllowThreads(__tstate);
2956 if (PyErr_Occurred()) SWIG_fail;
2957 }
2958 {
2959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2960 }
2961 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
2962 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
2963 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
2964 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
2965 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
2966 SWIG_From_unsigned_SS_char((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_unsigned_char, 0)));
2967 return resultobj;
2968 fail:
2969 return NULL;
2970 }
2971
2972
2973 static PyObject *_wrap_Palette_GetColoursCount(PyObject *, PyObject *args, PyObject *kwargs) {
2974 PyObject *resultobj;
2975 wxPalette *arg1 = (wxPalette *) 0 ;
2976 int result;
2977 PyObject * obj0 = 0 ;
2978 char *kwnames[] = {
2979 (char *) "self", NULL
2980 };
2981
2982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_GetColoursCount",kwnames,&obj0)) goto fail;
2983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2984 if (SWIG_arg_fail(1)) SWIG_fail;
2985 {
2986 PyThreadState* __tstate = wxPyBeginAllowThreads();
2987 result = (int)((wxPalette const *)arg1)->GetColoursCount();
2988
2989 wxPyEndAllowThreads(__tstate);
2990 if (PyErr_Occurred()) SWIG_fail;
2991 }
2992 {
2993 resultobj = SWIG_From_int((int)(result));
2994 }
2995 return resultobj;
2996 fail:
2997 return NULL;
2998 }
2999
3000
3001 static PyObject *_wrap_Palette_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3002 PyObject *resultobj;
3003 wxPalette *arg1 = (wxPalette *) 0 ;
3004 bool result;
3005 PyObject * obj0 = 0 ;
3006 char *kwnames[] = {
3007 (char *) "self", NULL
3008 };
3009
3010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_Ok",kwnames,&obj0)) goto fail;
3011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
3012 if (SWIG_arg_fail(1)) SWIG_fail;
3013 {
3014 PyThreadState* __tstate = wxPyBeginAllowThreads();
3015 result = (bool)(arg1)->Ok();
3016
3017 wxPyEndAllowThreads(__tstate);
3018 if (PyErr_Occurred()) SWIG_fail;
3019 }
3020 {
3021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3022 }
3023 return resultobj;
3024 fail:
3025 return NULL;
3026 }
3027
3028
3029 static PyObject * Palette_swigregister(PyObject *, PyObject *args) {
3030 PyObject *obj;
3031 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3032 SWIG_TypeClientData(SWIGTYPE_p_wxPalette, obj);
3033 Py_INCREF(obj);
3034 return Py_BuildValue((char *)"");
3035 }
3036 static PyObject *_wrap_new_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3037 PyObject *resultobj;
3038 wxColour *arg1 = 0 ;
3039 int arg2 = (int) 1 ;
3040 int arg3 = (int) wxSOLID ;
3041 wxPen *result;
3042 wxColour temp1 ;
3043 PyObject * obj0 = 0 ;
3044 PyObject * obj1 = 0 ;
3045 PyObject * obj2 = 0 ;
3046 char *kwnames[] = {
3047 (char *) "colour",(char *) "width",(char *) "style", NULL
3048 };
3049
3050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Pen",kwnames,&obj0,&obj1,&obj2)) goto fail;
3051 {
3052 arg1 = &temp1;
3053 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3054 }
3055 if (obj1) {
3056 {
3057 arg2 = (int)(SWIG_As_int(obj1));
3058 if (SWIG_arg_fail(2)) SWIG_fail;
3059 }
3060 }
3061 if (obj2) {
3062 {
3063 arg3 = (int)(SWIG_As_int(obj2));
3064 if (SWIG_arg_fail(3)) SWIG_fail;
3065 }
3066 }
3067 {
3068 if (!wxPyCheckForApp()) SWIG_fail;
3069 PyThreadState* __tstate = wxPyBeginAllowThreads();
3070 result = (wxPen *)new wxPen(*arg1,arg2,arg3);
3071
3072 wxPyEndAllowThreads(__tstate);
3073 if (PyErr_Occurred()) SWIG_fail;
3074 }
3075 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 1);
3076 return resultobj;
3077 fail:
3078 return NULL;
3079 }
3080
3081
3082 static PyObject *_wrap_delete_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3083 PyObject *resultobj;
3084 wxPen *arg1 = (wxPen *) 0 ;
3085 PyObject * obj0 = 0 ;
3086 char *kwnames[] = {
3087 (char *) "self", NULL
3088 };
3089
3090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Pen",kwnames,&obj0)) goto fail;
3091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3092 if (SWIG_arg_fail(1)) SWIG_fail;
3093 {
3094 PyThreadState* __tstate = wxPyBeginAllowThreads();
3095 delete arg1;
3096
3097 wxPyEndAllowThreads(__tstate);
3098 if (PyErr_Occurred()) SWIG_fail;
3099 }
3100 Py_INCREF(Py_None); resultobj = Py_None;
3101 return resultobj;
3102 fail:
3103 return NULL;
3104 }
3105
3106
3107 static PyObject *_wrap_Pen_GetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3108 PyObject *resultobj;
3109 wxPen *arg1 = (wxPen *) 0 ;
3110 int result;
3111 PyObject * obj0 = 0 ;
3112 char *kwnames[] = {
3113 (char *) "self", NULL
3114 };
3115
3116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetCap",kwnames,&obj0)) goto fail;
3117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3118 if (SWIG_arg_fail(1)) SWIG_fail;
3119 {
3120 PyThreadState* __tstate = wxPyBeginAllowThreads();
3121 result = (int)(arg1)->GetCap();
3122
3123 wxPyEndAllowThreads(__tstate);
3124 if (PyErr_Occurred()) SWIG_fail;
3125 }
3126 {
3127 resultobj = SWIG_From_int((int)(result));
3128 }
3129 return resultobj;
3130 fail:
3131 return NULL;
3132 }
3133
3134
3135 static PyObject *_wrap_Pen_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3136 PyObject *resultobj;
3137 wxPen *arg1 = (wxPen *) 0 ;
3138 wxColour result;
3139 PyObject * obj0 = 0 ;
3140 char *kwnames[] = {
3141 (char *) "self", NULL
3142 };
3143
3144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetColour",kwnames,&obj0)) goto fail;
3145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3146 if (SWIG_arg_fail(1)) SWIG_fail;
3147 {
3148 PyThreadState* __tstate = wxPyBeginAllowThreads();
3149 result = (arg1)->GetColour();
3150
3151 wxPyEndAllowThreads(__tstate);
3152 if (PyErr_Occurred()) SWIG_fail;
3153 }
3154 {
3155 wxColour * resultptr;
3156 resultptr = new wxColour((wxColour &)(result));
3157 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3158 }
3159 return resultobj;
3160 fail:
3161 return NULL;
3162 }
3163
3164
3165 static PyObject *_wrap_Pen_GetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3166 PyObject *resultobj;
3167 wxPen *arg1 = (wxPen *) 0 ;
3168 int result;
3169 PyObject * obj0 = 0 ;
3170 char *kwnames[] = {
3171 (char *) "self", NULL
3172 };
3173
3174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetJoin",kwnames,&obj0)) goto fail;
3175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3176 if (SWIG_arg_fail(1)) SWIG_fail;
3177 {
3178 PyThreadState* __tstate = wxPyBeginAllowThreads();
3179 result = (int)(arg1)->GetJoin();
3180
3181 wxPyEndAllowThreads(__tstate);
3182 if (PyErr_Occurred()) SWIG_fail;
3183 }
3184 {
3185 resultobj = SWIG_From_int((int)(result));
3186 }
3187 return resultobj;
3188 fail:
3189 return NULL;
3190 }
3191
3192
3193 static PyObject *_wrap_Pen_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3194 PyObject *resultobj;
3195 wxPen *arg1 = (wxPen *) 0 ;
3196 int result;
3197 PyObject * obj0 = 0 ;
3198 char *kwnames[] = {
3199 (char *) "self", NULL
3200 };
3201
3202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetStyle",kwnames,&obj0)) goto fail;
3203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3204 if (SWIG_arg_fail(1)) SWIG_fail;
3205 {
3206 PyThreadState* __tstate = wxPyBeginAllowThreads();
3207 result = (int)(arg1)->GetStyle();
3208
3209 wxPyEndAllowThreads(__tstate);
3210 if (PyErr_Occurred()) SWIG_fail;
3211 }
3212 {
3213 resultobj = SWIG_From_int((int)(result));
3214 }
3215 return resultobj;
3216 fail:
3217 return NULL;
3218 }
3219
3220
3221 static PyObject *_wrap_Pen_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3222 PyObject *resultobj;
3223 wxPen *arg1 = (wxPen *) 0 ;
3224 int result;
3225 PyObject * obj0 = 0 ;
3226 char *kwnames[] = {
3227 (char *) "self", NULL
3228 };
3229
3230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetWidth",kwnames,&obj0)) goto fail;
3231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3232 if (SWIG_arg_fail(1)) SWIG_fail;
3233 {
3234 PyThreadState* __tstate = wxPyBeginAllowThreads();
3235 result = (int)(arg1)->GetWidth();
3236
3237 wxPyEndAllowThreads(__tstate);
3238 if (PyErr_Occurred()) SWIG_fail;
3239 }
3240 {
3241 resultobj = SWIG_From_int((int)(result));
3242 }
3243 return resultobj;
3244 fail:
3245 return NULL;
3246 }
3247
3248
3249 static PyObject *_wrap_Pen_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3250 PyObject *resultobj;
3251 wxPen *arg1 = (wxPen *) 0 ;
3252 bool result;
3253 PyObject * obj0 = 0 ;
3254 char *kwnames[] = {
3255 (char *) "self", NULL
3256 };
3257
3258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_Ok",kwnames,&obj0)) goto fail;
3259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3260 if (SWIG_arg_fail(1)) SWIG_fail;
3261 {
3262 PyThreadState* __tstate = wxPyBeginAllowThreads();
3263 result = (bool)(arg1)->Ok();
3264
3265 wxPyEndAllowThreads(__tstate);
3266 if (PyErr_Occurred()) SWIG_fail;
3267 }
3268 {
3269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3270 }
3271 return resultobj;
3272 fail:
3273 return NULL;
3274 }
3275
3276
3277 static PyObject *_wrap_Pen_SetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3278 PyObject *resultobj;
3279 wxPen *arg1 = (wxPen *) 0 ;
3280 int arg2 ;
3281 PyObject * obj0 = 0 ;
3282 PyObject * obj1 = 0 ;
3283 char *kwnames[] = {
3284 (char *) "self",(char *) "cap_style", NULL
3285 };
3286
3287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetCap",kwnames,&obj0,&obj1)) goto fail;
3288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3289 if (SWIG_arg_fail(1)) SWIG_fail;
3290 {
3291 arg2 = (int)(SWIG_As_int(obj1));
3292 if (SWIG_arg_fail(2)) SWIG_fail;
3293 }
3294 {
3295 PyThreadState* __tstate = wxPyBeginAllowThreads();
3296 (arg1)->SetCap(arg2);
3297
3298 wxPyEndAllowThreads(__tstate);
3299 if (PyErr_Occurred()) SWIG_fail;
3300 }
3301 Py_INCREF(Py_None); resultobj = Py_None;
3302 return resultobj;
3303 fail:
3304 return NULL;
3305 }
3306
3307
3308 static PyObject *_wrap_Pen_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3309 PyObject *resultobj;
3310 wxPen *arg1 = (wxPen *) 0 ;
3311 wxColour *arg2 = 0 ;
3312 wxColour temp2 ;
3313 PyObject * obj0 = 0 ;
3314 PyObject * obj1 = 0 ;
3315 char *kwnames[] = {
3316 (char *) "self",(char *) "colour", NULL
3317 };
3318
3319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetColour",kwnames,&obj0,&obj1)) goto fail;
3320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3321 if (SWIG_arg_fail(1)) SWIG_fail;
3322 {
3323 arg2 = &temp2;
3324 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3325 }
3326 {
3327 PyThreadState* __tstate = wxPyBeginAllowThreads();
3328 (arg1)->SetColour(*arg2);
3329
3330 wxPyEndAllowThreads(__tstate);
3331 if (PyErr_Occurred()) SWIG_fail;
3332 }
3333 Py_INCREF(Py_None); resultobj = Py_None;
3334 return resultobj;
3335 fail:
3336 return NULL;
3337 }
3338
3339
3340 static PyObject *_wrap_Pen_SetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3341 PyObject *resultobj;
3342 wxPen *arg1 = (wxPen *) 0 ;
3343 int arg2 ;
3344 PyObject * obj0 = 0 ;
3345 PyObject * obj1 = 0 ;
3346 char *kwnames[] = {
3347 (char *) "self",(char *) "join_style", NULL
3348 };
3349
3350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetJoin",kwnames,&obj0,&obj1)) goto fail;
3351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3352 if (SWIG_arg_fail(1)) SWIG_fail;
3353 {
3354 arg2 = (int)(SWIG_As_int(obj1));
3355 if (SWIG_arg_fail(2)) SWIG_fail;
3356 }
3357 {
3358 PyThreadState* __tstate = wxPyBeginAllowThreads();
3359 (arg1)->SetJoin(arg2);
3360
3361 wxPyEndAllowThreads(__tstate);
3362 if (PyErr_Occurred()) SWIG_fail;
3363 }
3364 Py_INCREF(Py_None); resultobj = Py_None;
3365 return resultobj;
3366 fail:
3367 return NULL;
3368 }
3369
3370
3371 static PyObject *_wrap_Pen_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3372 PyObject *resultobj;
3373 wxPen *arg1 = (wxPen *) 0 ;
3374 int arg2 ;
3375 PyObject * obj0 = 0 ;
3376 PyObject * obj1 = 0 ;
3377 char *kwnames[] = {
3378 (char *) "self",(char *) "style", NULL
3379 };
3380
3381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3383 if (SWIG_arg_fail(1)) SWIG_fail;
3384 {
3385 arg2 = (int)(SWIG_As_int(obj1));
3386 if (SWIG_arg_fail(2)) SWIG_fail;
3387 }
3388 {
3389 PyThreadState* __tstate = wxPyBeginAllowThreads();
3390 (arg1)->SetStyle(arg2);
3391
3392 wxPyEndAllowThreads(__tstate);
3393 if (PyErr_Occurred()) SWIG_fail;
3394 }
3395 Py_INCREF(Py_None); resultobj = Py_None;
3396 return resultobj;
3397 fail:
3398 return NULL;
3399 }
3400
3401
3402 static PyObject *_wrap_Pen_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3403 PyObject *resultobj;
3404 wxPen *arg1 = (wxPen *) 0 ;
3405 int arg2 ;
3406 PyObject * obj0 = 0 ;
3407 PyObject * obj1 = 0 ;
3408 char *kwnames[] = {
3409 (char *) "self",(char *) "width", NULL
3410 };
3411
3412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3414 if (SWIG_arg_fail(1)) SWIG_fail;
3415 {
3416 arg2 = (int)(SWIG_As_int(obj1));
3417 if (SWIG_arg_fail(2)) SWIG_fail;
3418 }
3419 {
3420 PyThreadState* __tstate = wxPyBeginAllowThreads();
3421 (arg1)->SetWidth(arg2);
3422
3423 wxPyEndAllowThreads(__tstate);
3424 if (PyErr_Occurred()) SWIG_fail;
3425 }
3426 Py_INCREF(Py_None); resultobj = Py_None;
3427 return resultobj;
3428 fail:
3429 return NULL;
3430 }
3431
3432
3433 static PyObject *_wrap_Pen_SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3434 PyObject *resultobj;
3435 wxPen *arg1 = (wxPen *) 0 ;
3436 int arg2 ;
3437 wxDash *arg3 = (wxDash *) 0 ;
3438 PyObject * obj0 = 0 ;
3439 PyObject * obj1 = 0 ;
3440 char *kwnames[] = {
3441 (char *) "self",(char *) "dashes", NULL
3442 };
3443
3444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetDashes",kwnames,&obj0,&obj1)) goto fail;
3445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3446 if (SWIG_arg_fail(1)) SWIG_fail;
3447 {
3448 arg2 = PyList_Size(obj1);
3449 arg3 = (wxDash*)byte_LIST_helper(obj1);
3450 if (arg3 == NULL) SWIG_fail;
3451 }
3452 {
3453 PyThreadState* __tstate = wxPyBeginAllowThreads();
3454 (arg1)->SetDashes(arg2,arg3);
3455
3456 wxPyEndAllowThreads(__tstate);
3457 if (PyErr_Occurred()) SWIG_fail;
3458 }
3459 Py_INCREF(Py_None); resultobj = Py_None;
3460 {
3461 if (arg3) delete [] arg3;
3462 }
3463 return resultobj;
3464 fail:
3465 {
3466 if (arg3) delete [] arg3;
3467 }
3468 return NULL;
3469 }
3470
3471
3472 static PyObject *_wrap_Pen_GetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3473 PyObject *resultobj;
3474 wxPen *arg1 = (wxPen *) 0 ;
3475 PyObject *result;
3476 PyObject * obj0 = 0 ;
3477 char *kwnames[] = {
3478 (char *) "self", NULL
3479 };
3480
3481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetDashes",kwnames,&obj0)) goto fail;
3482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3483 if (SWIG_arg_fail(1)) SWIG_fail;
3484 {
3485 PyThreadState* __tstate = wxPyBeginAllowThreads();
3486 result = (PyObject *)wxPen_GetDashes(arg1);
3487
3488 wxPyEndAllowThreads(__tstate);
3489 if (PyErr_Occurred()) SWIG_fail;
3490 }
3491 resultobj = result;
3492 return resultobj;
3493 fail:
3494 return NULL;
3495 }
3496
3497
3498 static PyObject *_wrap_Pen__SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3499 PyObject *resultobj;
3500 wxPen *arg1 = (wxPen *) 0 ;
3501 PyObject *arg2 = (PyObject *) 0 ;
3502 PyObject *arg3 = (PyObject *) 0 ;
3503 PyObject * obj0 = 0 ;
3504 PyObject * obj1 = 0 ;
3505 PyObject * obj2 = 0 ;
3506 char *kwnames[] = {
3507 (char *) "self",(char *) "_self",(char *) "pyDashes", NULL
3508 };
3509
3510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Pen__SetDashes",kwnames,&obj0,&obj1,&obj2)) goto fail;
3511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3512 if (SWIG_arg_fail(1)) SWIG_fail;
3513 arg2 = obj1;
3514 arg3 = obj2;
3515 {
3516 PyThreadState* __tstate = wxPyBeginAllowThreads();
3517 wxPen__SetDashes(arg1,arg2,arg3);
3518
3519 wxPyEndAllowThreads(__tstate);
3520 if (PyErr_Occurred()) SWIG_fail;
3521 }
3522 Py_INCREF(Py_None); resultobj = Py_None;
3523 return resultobj;
3524 fail:
3525 return NULL;
3526 }
3527
3528
3529 static PyObject *_wrap_Pen_GetDashCount(PyObject *, PyObject *args, PyObject *kwargs) {
3530 PyObject *resultobj;
3531 wxPen *arg1 = (wxPen *) 0 ;
3532 int result;
3533 PyObject * obj0 = 0 ;
3534 char *kwnames[] = {
3535 (char *) "self", NULL
3536 };
3537
3538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetDashCount",kwnames,&obj0)) goto fail;
3539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3540 if (SWIG_arg_fail(1)) SWIG_fail;
3541 {
3542 PyThreadState* __tstate = wxPyBeginAllowThreads();
3543 result = (int)((wxPen const *)arg1)->GetDashCount();
3544
3545 wxPyEndAllowThreads(__tstate);
3546 if (PyErr_Occurred()) SWIG_fail;
3547 }
3548 {
3549 resultobj = SWIG_From_int((int)(result));
3550 }
3551 return resultobj;
3552 fail:
3553 return NULL;
3554 }
3555
3556
3557 static PyObject *_wrap_Pen___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3558 PyObject *resultobj;
3559 wxPen *arg1 = (wxPen *) 0 ;
3560 wxPen *arg2 = (wxPen *) 0 ;
3561 bool result;
3562 PyObject * obj0 = 0 ;
3563 PyObject * obj1 = 0 ;
3564 char *kwnames[] = {
3565 (char *) "self",(char *) "other", NULL
3566 };
3567
3568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___eq__",kwnames,&obj0,&obj1)) goto fail;
3569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3570 if (SWIG_arg_fail(1)) SWIG_fail;
3571 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3572 if (SWIG_arg_fail(2)) SWIG_fail;
3573 {
3574 PyThreadState* __tstate = wxPyBeginAllowThreads();
3575 result = (bool)wxPen___eq__(arg1,(wxPen const *)arg2);
3576
3577 wxPyEndAllowThreads(__tstate);
3578 if (PyErr_Occurred()) SWIG_fail;
3579 }
3580 {
3581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3582 }
3583 return resultobj;
3584 fail:
3585 return NULL;
3586 }
3587
3588
3589 static PyObject *_wrap_Pen___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3590 PyObject *resultobj;
3591 wxPen *arg1 = (wxPen *) 0 ;
3592 wxPen *arg2 = (wxPen *) 0 ;
3593 bool result;
3594 PyObject * obj0 = 0 ;
3595 PyObject * obj1 = 0 ;
3596 char *kwnames[] = {
3597 (char *) "self",(char *) "other", NULL
3598 };
3599
3600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___ne__",kwnames,&obj0,&obj1)) goto fail;
3601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3602 if (SWIG_arg_fail(1)) SWIG_fail;
3603 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3604 if (SWIG_arg_fail(2)) SWIG_fail;
3605 {
3606 PyThreadState* __tstate = wxPyBeginAllowThreads();
3607 result = (bool)wxPen___ne__(arg1,(wxPen const *)arg2);
3608
3609 wxPyEndAllowThreads(__tstate);
3610 if (PyErr_Occurred()) SWIG_fail;
3611 }
3612 {
3613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3614 }
3615 return resultobj;
3616 fail:
3617 return NULL;
3618 }
3619
3620
3621 static PyObject * Pen_swigregister(PyObject *, PyObject *args) {
3622 PyObject *obj;
3623 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3624 SWIG_TypeClientData(SWIGTYPE_p_wxPen, obj);
3625 Py_INCREF(obj);
3626 return Py_BuildValue((char *)"");
3627 }
3628 static PyObject *_wrap_new_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3629 PyObject *resultobj;
3630 wxColour *arg1 = 0 ;
3631 int arg2 = (int) wxSOLID ;
3632 wxBrush *result;
3633 wxColour temp1 ;
3634 PyObject * obj0 = 0 ;
3635 PyObject * obj1 = 0 ;
3636 char *kwnames[] = {
3637 (char *) "colour",(char *) "style", NULL
3638 };
3639
3640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Brush",kwnames,&obj0,&obj1)) goto fail;
3641 {
3642 arg1 = &temp1;
3643 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3644 }
3645 if (obj1) {
3646 {
3647 arg2 = (int)(SWIG_As_int(obj1));
3648 if (SWIG_arg_fail(2)) SWIG_fail;
3649 }
3650 }
3651 {
3652 if (!wxPyCheckForApp()) SWIG_fail;
3653 PyThreadState* __tstate = wxPyBeginAllowThreads();
3654 result = (wxBrush *)new wxBrush((wxColour const &)*arg1,arg2);
3655
3656 wxPyEndAllowThreads(__tstate);
3657 if (PyErr_Occurred()) SWIG_fail;
3658 }
3659 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 1);
3660 return resultobj;
3661 fail:
3662 return NULL;
3663 }
3664
3665
3666 static PyObject *_wrap_delete_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3667 PyObject *resultobj;
3668 wxBrush *arg1 = (wxBrush *) 0 ;
3669 PyObject * obj0 = 0 ;
3670 char *kwnames[] = {
3671 (char *) "self", NULL
3672 };
3673
3674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Brush",kwnames,&obj0)) goto fail;
3675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3676 if (SWIG_arg_fail(1)) SWIG_fail;
3677 {
3678 PyThreadState* __tstate = wxPyBeginAllowThreads();
3679 delete arg1;
3680
3681 wxPyEndAllowThreads(__tstate);
3682 if (PyErr_Occurred()) SWIG_fail;
3683 }
3684 Py_INCREF(Py_None); resultobj = Py_None;
3685 return resultobj;
3686 fail:
3687 return NULL;
3688 }
3689
3690
3691 static PyObject *_wrap_Brush_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3692 PyObject *resultobj;
3693 wxBrush *arg1 = (wxBrush *) 0 ;
3694 wxColour *arg2 = 0 ;
3695 wxColour temp2 ;
3696 PyObject * obj0 = 0 ;
3697 PyObject * obj1 = 0 ;
3698 char *kwnames[] = {
3699 (char *) "self",(char *) "col", NULL
3700 };
3701
3702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetColour",kwnames,&obj0,&obj1)) goto fail;
3703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3704 if (SWIG_arg_fail(1)) SWIG_fail;
3705 {
3706 arg2 = &temp2;
3707 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3708 }
3709 {
3710 PyThreadState* __tstate = wxPyBeginAllowThreads();
3711 (arg1)->SetColour((wxColour const &)*arg2);
3712
3713 wxPyEndAllowThreads(__tstate);
3714 if (PyErr_Occurred()) SWIG_fail;
3715 }
3716 Py_INCREF(Py_None); resultobj = Py_None;
3717 return resultobj;
3718 fail:
3719 return NULL;
3720 }
3721
3722
3723 static PyObject *_wrap_Brush_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3724 PyObject *resultobj;
3725 wxBrush *arg1 = (wxBrush *) 0 ;
3726 int arg2 ;
3727 PyObject * obj0 = 0 ;
3728 PyObject * obj1 = 0 ;
3729 char *kwnames[] = {
3730 (char *) "self",(char *) "style", NULL
3731 };
3732
3733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3735 if (SWIG_arg_fail(1)) SWIG_fail;
3736 {
3737 arg2 = (int)(SWIG_As_int(obj1));
3738 if (SWIG_arg_fail(2)) SWIG_fail;
3739 }
3740 {
3741 PyThreadState* __tstate = wxPyBeginAllowThreads();
3742 (arg1)->SetStyle(arg2);
3743
3744 wxPyEndAllowThreads(__tstate);
3745 if (PyErr_Occurred()) SWIG_fail;
3746 }
3747 Py_INCREF(Py_None); resultobj = Py_None;
3748 return resultobj;
3749 fail:
3750 return NULL;
3751 }
3752
3753
3754 static PyObject *_wrap_Brush_SetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3755 PyObject *resultobj;
3756 wxBrush *arg1 = (wxBrush *) 0 ;
3757 wxBitmap *arg2 = 0 ;
3758 PyObject * obj0 = 0 ;
3759 PyObject * obj1 = 0 ;
3760 char *kwnames[] = {
3761 (char *) "self",(char *) "stipple", NULL
3762 };
3763
3764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStipple",kwnames,&obj0,&obj1)) goto fail;
3765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3766 if (SWIG_arg_fail(1)) SWIG_fail;
3767 {
3768 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3769 if (SWIG_arg_fail(2)) SWIG_fail;
3770 if (arg2 == NULL) {
3771 SWIG_null_ref("wxBitmap");
3772 }
3773 if (SWIG_arg_fail(2)) SWIG_fail;
3774 }
3775 {
3776 PyThreadState* __tstate = wxPyBeginAllowThreads();
3777 (arg1)->SetStipple((wxBitmap const &)*arg2);
3778
3779 wxPyEndAllowThreads(__tstate);
3780 if (PyErr_Occurred()) SWIG_fail;
3781 }
3782 Py_INCREF(Py_None); resultobj = Py_None;
3783 return resultobj;
3784 fail:
3785 return NULL;
3786 }
3787
3788
3789 static PyObject *_wrap_Brush_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3790 PyObject *resultobj;
3791 wxBrush *arg1 = (wxBrush *) 0 ;
3792 wxColour result;
3793 PyObject * obj0 = 0 ;
3794 char *kwnames[] = {
3795 (char *) "self", NULL
3796 };
3797
3798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetColour",kwnames,&obj0)) goto fail;
3799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3800 if (SWIG_arg_fail(1)) SWIG_fail;
3801 {
3802 PyThreadState* __tstate = wxPyBeginAllowThreads();
3803 result = ((wxBrush const *)arg1)->GetColour();
3804
3805 wxPyEndAllowThreads(__tstate);
3806 if (PyErr_Occurred()) SWIG_fail;
3807 }
3808 {
3809 wxColour * resultptr;
3810 resultptr = new wxColour((wxColour &)(result));
3811 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3812 }
3813 return resultobj;
3814 fail:
3815 return NULL;
3816 }
3817
3818
3819 static PyObject *_wrap_Brush_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3820 PyObject *resultobj;
3821 wxBrush *arg1 = (wxBrush *) 0 ;
3822 int result;
3823 PyObject * obj0 = 0 ;
3824 char *kwnames[] = {
3825 (char *) "self", NULL
3826 };
3827
3828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStyle",kwnames,&obj0)) goto fail;
3829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3830 if (SWIG_arg_fail(1)) SWIG_fail;
3831 {
3832 PyThreadState* __tstate = wxPyBeginAllowThreads();
3833 result = (int)((wxBrush const *)arg1)->GetStyle();
3834
3835 wxPyEndAllowThreads(__tstate);
3836 if (PyErr_Occurred()) SWIG_fail;
3837 }
3838 {
3839 resultobj = SWIG_From_int((int)(result));
3840 }
3841 return resultobj;
3842 fail:
3843 return NULL;
3844 }
3845
3846
3847 static PyObject *_wrap_Brush_GetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3848 PyObject *resultobj;
3849 wxBrush *arg1 = (wxBrush *) 0 ;
3850 wxBitmap *result;
3851 PyObject * obj0 = 0 ;
3852 char *kwnames[] = {
3853 (char *) "self", NULL
3854 };
3855
3856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStipple",kwnames,&obj0)) goto fail;
3857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3858 if (SWIG_arg_fail(1)) SWIG_fail;
3859 {
3860 PyThreadState* __tstate = wxPyBeginAllowThreads();
3861 result = (wxBitmap *)((wxBrush const *)arg1)->GetStipple();
3862
3863 wxPyEndAllowThreads(__tstate);
3864 if (PyErr_Occurred()) SWIG_fail;
3865 }
3866 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 0);
3867 return resultobj;
3868 fail:
3869 return NULL;
3870 }
3871
3872
3873 static PyObject *_wrap_Brush_IsHatch(PyObject *, PyObject *args, PyObject *kwargs) {
3874 PyObject *resultobj;
3875 wxBrush *arg1 = (wxBrush *) 0 ;
3876 bool result;
3877 PyObject * obj0 = 0 ;
3878 char *kwnames[] = {
3879 (char *) "self", NULL
3880 };
3881
3882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_IsHatch",kwnames,&obj0)) goto fail;
3883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3884 if (SWIG_arg_fail(1)) SWIG_fail;
3885 {
3886 PyThreadState* __tstate = wxPyBeginAllowThreads();
3887 result = (bool)((wxBrush const *)arg1)->IsHatch();
3888
3889 wxPyEndAllowThreads(__tstate);
3890 if (PyErr_Occurred()) SWIG_fail;
3891 }
3892 {
3893 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3894 }
3895 return resultobj;
3896 fail:
3897 return NULL;
3898 }
3899
3900
3901 static PyObject *_wrap_Brush_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3902 PyObject *resultobj;
3903 wxBrush *arg1 = (wxBrush *) 0 ;
3904 bool result;
3905 PyObject * obj0 = 0 ;
3906 char *kwnames[] = {
3907 (char *) "self", NULL
3908 };
3909
3910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_Ok",kwnames,&obj0)) goto fail;
3911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3912 if (SWIG_arg_fail(1)) SWIG_fail;
3913 {
3914 PyThreadState* __tstate = wxPyBeginAllowThreads();
3915 result = (bool)(arg1)->Ok();
3916
3917 wxPyEndAllowThreads(__tstate);
3918 if (PyErr_Occurred()) SWIG_fail;
3919 }
3920 {
3921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3922 }
3923 return resultobj;
3924 fail:
3925 return NULL;
3926 }
3927
3928
3929 static PyObject * Brush_swigregister(PyObject *, PyObject *args) {
3930 PyObject *obj;
3931 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3932 SWIG_TypeClientData(SWIGTYPE_p_wxBrush, obj);
3933 Py_INCREF(obj);
3934 return Py_BuildValue((char *)"");
3935 }
3936 static PyObject *_wrap_new_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
3937 PyObject *resultobj;
3938 wxString *arg1 = 0 ;
3939 wxBitmapType arg2 = (wxBitmapType) wxBITMAP_TYPE_ANY ;
3940 wxBitmap *result;
3941 bool temp1 = false ;
3942 PyObject * obj0 = 0 ;
3943 PyObject * obj1 = 0 ;
3944 char *kwnames[] = {
3945 (char *) "name",(char *) "type", NULL
3946 };
3947
3948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Bitmap",kwnames,&obj0,&obj1)) goto fail;
3949 {
3950 arg1 = wxString_in_helper(obj0);
3951 if (arg1 == NULL) SWIG_fail;
3952 temp1 = true;
3953 }
3954 if (obj1) {
3955 {
3956 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
3957 if (SWIG_arg_fail(2)) SWIG_fail;
3958 }
3959 }
3960 {
3961 if (!wxPyCheckForApp()) SWIG_fail;
3962 PyThreadState* __tstate = wxPyBeginAllowThreads();
3963 result = (wxBitmap *)new wxBitmap((wxString const &)*arg1,(wxBitmapType )arg2);
3964
3965 wxPyEndAllowThreads(__tstate);
3966 if (PyErr_Occurred()) SWIG_fail;
3967 }
3968 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
3969 {
3970 if (temp1)
3971 delete arg1;
3972 }
3973 return resultobj;
3974 fail:
3975 {
3976 if (temp1)
3977 delete arg1;
3978 }
3979 return NULL;
3980 }
3981
3982
3983 static PyObject *_wrap_delete_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
3984 PyObject *resultobj;
3985 wxBitmap *arg1 = (wxBitmap *) 0 ;
3986 PyObject * obj0 = 0 ;
3987 char *kwnames[] = {
3988 (char *) "self", NULL
3989 };
3990
3991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Bitmap",kwnames,&obj0)) goto fail;
3992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3993 if (SWIG_arg_fail(1)) SWIG_fail;
3994 {
3995 PyThreadState* __tstate = wxPyBeginAllowThreads();
3996 delete arg1;
3997
3998 wxPyEndAllowThreads(__tstate);
3999 if (PyErr_Occurred()) SWIG_fail;
4000 }
4001 Py_INCREF(Py_None); resultobj = Py_None;
4002 return resultobj;
4003 fail:
4004 return NULL;
4005 }
4006
4007
4008 static PyObject *_wrap_new_EmptyBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4009 PyObject *resultobj;
4010 int arg1 ;
4011 int arg2 ;
4012 int arg3 = (int) -1 ;
4013 wxBitmap *result;
4014 PyObject * obj0 = 0 ;
4015 PyObject * obj1 = 0 ;
4016 PyObject * obj2 = 0 ;
4017 char *kwnames[] = {
4018 (char *) "width",(char *) "height",(char *) "depth", NULL
4019 };
4020
4021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_EmptyBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
4022 {
4023 arg1 = (int)(SWIG_As_int(obj0));
4024 if (SWIG_arg_fail(1)) SWIG_fail;
4025 }
4026 {
4027 arg2 = (int)(SWIG_As_int(obj1));
4028 if (SWIG_arg_fail(2)) SWIG_fail;
4029 }
4030 if (obj2) {
4031 {
4032 arg3 = (int)(SWIG_As_int(obj2));
4033 if (SWIG_arg_fail(3)) SWIG_fail;
4034 }
4035 }
4036 {
4037 if (!wxPyCheckForApp()) SWIG_fail;
4038 PyThreadState* __tstate = wxPyBeginAllowThreads();
4039 result = (wxBitmap *)new wxBitmap(arg1,arg2,arg3);
4040
4041 wxPyEndAllowThreads(__tstate);
4042 if (PyErr_Occurred()) SWIG_fail;
4043 }
4044 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4045 return resultobj;
4046 fail:
4047 return NULL;
4048 }
4049
4050
4051 static PyObject *_wrap_new_BitmapFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4052 PyObject *resultobj;
4053 wxIcon *arg1 = 0 ;
4054 wxBitmap *result;
4055 PyObject * obj0 = 0 ;
4056 char *kwnames[] = {
4057 (char *) "icon", NULL
4058 };
4059
4060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromIcon",kwnames,&obj0)) goto fail;
4061 {
4062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4063 if (SWIG_arg_fail(1)) SWIG_fail;
4064 if (arg1 == NULL) {
4065 SWIG_null_ref("wxIcon");
4066 }
4067 if (SWIG_arg_fail(1)) SWIG_fail;
4068 }
4069 {
4070 if (!wxPyCheckForApp()) SWIG_fail;
4071 PyThreadState* __tstate = wxPyBeginAllowThreads();
4072 result = (wxBitmap *)new wxBitmap((wxIcon const &)*arg1);
4073
4074 wxPyEndAllowThreads(__tstate);
4075 if (PyErr_Occurred()) SWIG_fail;
4076 }
4077 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4078 return resultobj;
4079 fail:
4080 return NULL;
4081 }
4082
4083
4084 static PyObject *_wrap_new_BitmapFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
4085 PyObject *resultobj;
4086 wxImage *arg1 = 0 ;
4087 int arg2 = (int) -1 ;
4088 wxBitmap *result;
4089 PyObject * obj0 = 0 ;
4090 PyObject * obj1 = 0 ;
4091 char *kwnames[] = {
4092 (char *) "image",(char *) "depth", NULL
4093 };
4094
4095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BitmapFromImage",kwnames,&obj0,&obj1)) goto fail;
4096 {
4097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
4098 if (SWIG_arg_fail(1)) SWIG_fail;
4099 if (arg1 == NULL) {
4100 SWIG_null_ref("wxImage");
4101 }
4102 if (SWIG_arg_fail(1)) SWIG_fail;
4103 }
4104 if (obj1) {
4105 {
4106 arg2 = (int)(SWIG_As_int(obj1));
4107 if (SWIG_arg_fail(2)) SWIG_fail;
4108 }
4109 }
4110 {
4111 if (!wxPyCheckForApp()) SWIG_fail;
4112 PyThreadState* __tstate = wxPyBeginAllowThreads();
4113 result = (wxBitmap *)new wxBitmap((wxImage const &)*arg1,arg2);
4114
4115 wxPyEndAllowThreads(__tstate);
4116 if (PyErr_Occurred()) SWIG_fail;
4117 }
4118 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4119 return resultobj;
4120 fail:
4121 return NULL;
4122 }
4123
4124
4125 static PyObject *_wrap_new_BitmapFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
4126 PyObject *resultobj;
4127 PyObject *arg1 = (PyObject *) 0 ;
4128 wxBitmap *result;
4129 PyObject * obj0 = 0 ;
4130 char *kwnames[] = {
4131 (char *) "listOfStrings", NULL
4132 };
4133
4134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromXPMData",kwnames,&obj0)) goto fail;
4135 arg1 = obj0;
4136 {
4137 if (!wxPyCheckForApp()) SWIG_fail;
4138 PyThreadState* __tstate = wxPyBeginAllowThreads();
4139 result = (wxBitmap *)new_wxBitmap(arg1);
4140
4141 wxPyEndAllowThreads(__tstate);
4142 if (PyErr_Occurred()) SWIG_fail;
4143 }
4144 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4145 return resultobj;
4146 fail:
4147 return NULL;
4148 }
4149
4150
4151 static PyObject *_wrap_new_BitmapFromBits(PyObject *, PyObject *args, PyObject *kwargs) {
4152 PyObject *resultobj;
4153 PyObject *arg1 = (PyObject *) 0 ;
4154 int arg2 ;
4155 int arg3 ;
4156 int arg4 = (int) 1 ;
4157 wxBitmap *result;
4158 PyObject * obj0 = 0 ;
4159 PyObject * obj1 = 0 ;
4160 PyObject * obj2 = 0 ;
4161 PyObject * obj3 = 0 ;
4162 char *kwnames[] = {
4163 (char *) "bits",(char *) "width",(char *) "height",(char *) "depth", NULL
4164 };
4165
4166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:new_BitmapFromBits",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4167 arg1 = obj0;
4168 {
4169 arg2 = (int)(SWIG_As_int(obj1));
4170 if (SWIG_arg_fail(2)) SWIG_fail;
4171 }
4172 {
4173 arg3 = (int)(SWIG_As_int(obj2));
4174 if (SWIG_arg_fail(3)) SWIG_fail;
4175 }
4176 if (obj3) {
4177 {
4178 arg4 = (int)(SWIG_As_int(obj3));
4179 if (SWIG_arg_fail(4)) SWIG_fail;
4180 }
4181 }
4182 {
4183 if (!wxPyCheckForApp()) SWIG_fail;
4184 PyThreadState* __tstate = wxPyBeginAllowThreads();
4185 result = (wxBitmap *)new_wxBitmap(arg1,arg2,arg3,arg4);
4186
4187 wxPyEndAllowThreads(__tstate);
4188 if (PyErr_Occurred()) SWIG_fail;
4189 }
4190 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4191 return resultobj;
4192 fail:
4193 return NULL;
4194 }
4195
4196
4197 static PyObject *_wrap_Bitmap_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
4198 PyObject *resultobj;
4199 wxBitmap *arg1 = (wxBitmap *) 0 ;
4200 bool result;
4201 PyObject * obj0 = 0 ;
4202 char *kwnames[] = {
4203 (char *) "self", NULL
4204 };
4205
4206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_Ok",kwnames,&obj0)) goto fail;
4207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4208 if (SWIG_arg_fail(1)) SWIG_fail;
4209 {
4210 PyThreadState* __tstate = wxPyBeginAllowThreads();
4211 result = (bool)(arg1)->Ok();
4212
4213 wxPyEndAllowThreads(__tstate);
4214 if (PyErr_Occurred()) SWIG_fail;
4215 }
4216 {
4217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4218 }
4219 return resultobj;
4220 fail:
4221 return NULL;
4222 }
4223
4224
4225 static PyObject *_wrap_Bitmap_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4226 PyObject *resultobj;
4227 wxBitmap *arg1 = (wxBitmap *) 0 ;
4228 int result;
4229 PyObject * obj0 = 0 ;
4230 char *kwnames[] = {
4231 (char *) "self", NULL
4232 };
4233
4234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetWidth",kwnames,&obj0)) goto fail;
4235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4236 if (SWIG_arg_fail(1)) SWIG_fail;
4237 {
4238 PyThreadState* __tstate = wxPyBeginAllowThreads();
4239 result = (int)(arg1)->GetWidth();
4240
4241 wxPyEndAllowThreads(__tstate);
4242 if (PyErr_Occurred()) SWIG_fail;
4243 }
4244 {
4245 resultobj = SWIG_From_int((int)(result));
4246 }
4247 return resultobj;
4248 fail:
4249 return NULL;
4250 }
4251
4252
4253 static PyObject *_wrap_Bitmap_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4254 PyObject *resultobj;
4255 wxBitmap *arg1 = (wxBitmap *) 0 ;
4256 int result;
4257 PyObject * obj0 = 0 ;
4258 char *kwnames[] = {
4259 (char *) "self", NULL
4260 };
4261
4262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetHeight",kwnames,&obj0)) goto fail;
4263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4264 if (SWIG_arg_fail(1)) SWIG_fail;
4265 {
4266 PyThreadState* __tstate = wxPyBeginAllowThreads();
4267 result = (int)(arg1)->GetHeight();
4268
4269 wxPyEndAllowThreads(__tstate);
4270 if (PyErr_Occurred()) SWIG_fail;
4271 }
4272 {
4273 resultobj = SWIG_From_int((int)(result));
4274 }
4275 return resultobj;
4276 fail:
4277 return NULL;
4278 }
4279
4280
4281 static PyObject *_wrap_Bitmap_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4282 PyObject *resultobj;
4283 wxBitmap *arg1 = (wxBitmap *) 0 ;
4284 int result;
4285 PyObject * obj0 = 0 ;
4286 char *kwnames[] = {
4287 (char *) "self", NULL
4288 };
4289
4290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetDepth",kwnames,&obj0)) goto fail;
4291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4292 if (SWIG_arg_fail(1)) SWIG_fail;
4293 {
4294 PyThreadState* __tstate = wxPyBeginAllowThreads();
4295 result = (int)(arg1)->GetDepth();
4296
4297 wxPyEndAllowThreads(__tstate);
4298 if (PyErr_Occurred()) SWIG_fail;
4299 }
4300 {
4301 resultobj = SWIG_From_int((int)(result));
4302 }
4303 return resultobj;
4304 fail:
4305 return NULL;
4306 }
4307
4308
4309 static PyObject *_wrap_Bitmap_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4310 PyObject *resultobj;
4311 wxBitmap *arg1 = (wxBitmap *) 0 ;
4312 wxSize result;
4313 PyObject * obj0 = 0 ;
4314 char *kwnames[] = {
4315 (char *) "self", NULL
4316 };
4317
4318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetSize",kwnames,&obj0)) goto fail;
4319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4320 if (SWIG_arg_fail(1)) SWIG_fail;
4321 {
4322 PyThreadState* __tstate = wxPyBeginAllowThreads();
4323 result = wxBitmap_GetSize(arg1);
4324
4325 wxPyEndAllowThreads(__tstate);
4326 if (PyErr_Occurred()) SWIG_fail;
4327 }
4328 {
4329 wxSize * resultptr;
4330 resultptr = new wxSize((wxSize &)(result));
4331 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
4332 }
4333 return resultobj;
4334 fail:
4335 return NULL;
4336 }
4337
4338
4339 static PyObject *_wrap_Bitmap_ConvertToImage(PyObject *, PyObject *args, PyObject *kwargs) {
4340 PyObject *resultobj;
4341 wxBitmap *arg1 = (wxBitmap *) 0 ;
4342 SwigValueWrapper<wxImage > result;
4343 PyObject * obj0 = 0 ;
4344 char *kwnames[] = {
4345 (char *) "self", NULL
4346 };
4347
4348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_ConvertToImage",kwnames,&obj0)) goto fail;
4349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4350 if (SWIG_arg_fail(1)) SWIG_fail;
4351 {
4352 PyThreadState* __tstate = wxPyBeginAllowThreads();
4353 result = ((wxBitmap const *)arg1)->ConvertToImage();
4354
4355 wxPyEndAllowThreads(__tstate);
4356 if (PyErr_Occurred()) SWIG_fail;
4357 }
4358 {
4359 wxImage * resultptr;
4360 resultptr = new wxImage((wxImage &)(result));
4361 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
4362 }
4363 return resultobj;
4364 fail:
4365 return NULL;
4366 }
4367
4368
4369 static PyObject *_wrap_Bitmap_GetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4370 PyObject *resultobj;
4371 wxBitmap *arg1 = (wxBitmap *) 0 ;
4372 wxMask *result;
4373 PyObject * obj0 = 0 ;
4374 char *kwnames[] = {
4375 (char *) "self", NULL
4376 };
4377
4378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetMask",kwnames,&obj0)) goto fail;
4379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4380 if (SWIG_arg_fail(1)) SWIG_fail;
4381 {
4382 PyThreadState* __tstate = wxPyBeginAllowThreads();
4383 result = (wxMask *)((wxBitmap const *)arg1)->GetMask();
4384
4385 wxPyEndAllowThreads(__tstate);
4386 if (PyErr_Occurred()) SWIG_fail;
4387 }
4388 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 0);
4389 return resultobj;
4390 fail:
4391 return NULL;
4392 }
4393
4394
4395 static PyObject *_wrap_Bitmap_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4396 PyObject *resultobj;
4397 wxBitmap *arg1 = (wxBitmap *) 0 ;
4398 wxMask *arg2 = (wxMask *) 0 ;
4399 PyObject * obj0 = 0 ;
4400 PyObject * obj1 = 0 ;
4401 char *kwnames[] = {
4402 (char *) "self",(char *) "mask", NULL
4403 };
4404
4405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMask",kwnames,&obj0,&obj1)) goto fail;
4406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4407 if (SWIG_arg_fail(1)) SWIG_fail;
4408 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMask, SWIG_POINTER_EXCEPTION | 0);
4409 if (SWIG_arg_fail(2)) SWIG_fail;
4410 {
4411 PyThreadState* __tstate = wxPyBeginAllowThreads();
4412 (arg1)->SetMask(arg2);
4413
4414 wxPyEndAllowThreads(__tstate);
4415 if (PyErr_Occurred()) SWIG_fail;
4416 }
4417 Py_INCREF(Py_None); resultobj = Py_None;
4418 return resultobj;
4419 fail:
4420 return NULL;
4421 }
4422
4423
4424 static PyObject *_wrap_Bitmap_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
4425 PyObject *resultobj;
4426 wxBitmap *arg1 = (wxBitmap *) 0 ;
4427 wxColour *arg2 = 0 ;
4428 wxColour temp2 ;
4429 PyObject * obj0 = 0 ;
4430 PyObject * obj1 = 0 ;
4431 char *kwnames[] = {
4432 (char *) "self",(char *) "colour", NULL
4433 };
4434
4435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMaskColour",kwnames,&obj0,&obj1)) goto fail;
4436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4437 if (SWIG_arg_fail(1)) SWIG_fail;
4438 {
4439 arg2 = &temp2;
4440 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4441 }
4442 {
4443 PyThreadState* __tstate = wxPyBeginAllowThreads();
4444 wxBitmap_SetMaskColour(arg1,(wxColour const &)*arg2);
4445
4446 wxPyEndAllowThreads(__tstate);
4447 if (PyErr_Occurred()) SWIG_fail;
4448 }
4449 Py_INCREF(Py_None); resultobj = Py_None;
4450 return resultobj;
4451 fail:
4452 return NULL;
4453 }
4454
4455
4456 static PyObject *_wrap_Bitmap_GetSubBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4457 PyObject *resultobj;
4458 wxBitmap *arg1 = (wxBitmap *) 0 ;
4459 wxRect *arg2 = 0 ;
4460 SwigValueWrapper<wxBitmap > result;
4461 wxRect temp2 ;
4462 PyObject * obj0 = 0 ;
4463 PyObject * obj1 = 0 ;
4464 char *kwnames[] = {
4465 (char *) "self",(char *) "rect", NULL
4466 };
4467
4468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_GetSubBitmap",kwnames,&obj0,&obj1)) goto fail;
4469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4470 if (SWIG_arg_fail(1)) SWIG_fail;
4471 {
4472 arg2 = &temp2;
4473 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4474 }
4475 {
4476 PyThreadState* __tstate = wxPyBeginAllowThreads();
4477 result = ((wxBitmap const *)arg1)->GetSubBitmap((wxRect const &)*arg2);
4478
4479 wxPyEndAllowThreads(__tstate);
4480 if (PyErr_Occurred()) SWIG_fail;
4481 }
4482 {
4483 wxBitmap * resultptr;
4484 resultptr = new wxBitmap((wxBitmap &)(result));
4485 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
4486 }
4487 return resultobj;
4488 fail:
4489 return NULL;
4490 }
4491
4492
4493 static PyObject *_wrap_Bitmap_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
4494 PyObject *resultobj;
4495 wxBitmap *arg1 = (wxBitmap *) 0 ;
4496 wxString *arg2 = 0 ;
4497 wxBitmapType arg3 ;
4498 wxPalette *arg4 = (wxPalette *) NULL ;
4499 bool result;
4500 bool temp2 = false ;
4501 PyObject * obj0 = 0 ;
4502 PyObject * obj1 = 0 ;
4503 PyObject * obj2 = 0 ;
4504 PyObject * obj3 = 0 ;
4505 char *kwnames[] = {
4506 (char *) "self",(char *) "name",(char *) "type",(char *) "palette", NULL
4507 };
4508
4509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Bitmap_SaveFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4511 if (SWIG_arg_fail(1)) SWIG_fail;
4512 {
4513 arg2 = wxString_in_helper(obj1);
4514 if (arg2 == NULL) SWIG_fail;
4515 temp2 = true;
4516 }
4517 {
4518 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4519 if (SWIG_arg_fail(3)) SWIG_fail;
4520 }
4521 if (obj3) {
4522 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
4523 if (SWIG_arg_fail(4)) SWIG_fail;
4524 }
4525 {
4526 PyThreadState* __tstate = wxPyBeginAllowThreads();
4527 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxBitmapType )arg3,arg4);
4528
4529 wxPyEndAllowThreads(__tstate);
4530 if (PyErr_Occurred()) SWIG_fail;
4531 }
4532 {
4533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4534 }
4535 {
4536 if (temp2)
4537 delete arg2;
4538 }
4539 return resultobj;
4540 fail:
4541 {
4542 if (temp2)
4543 delete arg2;
4544 }
4545 return NULL;
4546 }
4547
4548
4549 static PyObject *_wrap_Bitmap_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
4550 PyObject *resultobj;
4551 wxBitmap *arg1 = (wxBitmap *) 0 ;
4552 wxString *arg2 = 0 ;
4553 wxBitmapType arg3 ;
4554 bool result;
4555 bool temp2 = false ;
4556 PyObject * obj0 = 0 ;
4557 PyObject * obj1 = 0 ;
4558 PyObject * obj2 = 0 ;
4559 char *kwnames[] = {
4560 (char *) "self",(char *) "name",(char *) "type", NULL
4561 };
4562
4563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Bitmap_LoadFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
4564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4565 if (SWIG_arg_fail(1)) SWIG_fail;
4566 {
4567 arg2 = wxString_in_helper(obj1);
4568 if (arg2 == NULL) SWIG_fail;
4569 temp2 = true;
4570 }
4571 {
4572 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4573 if (SWIG_arg_fail(3)) SWIG_fail;
4574 }
4575 {
4576 PyThreadState* __tstate = wxPyBeginAllowThreads();
4577 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxBitmapType )arg3);
4578
4579 wxPyEndAllowThreads(__tstate);
4580 if (PyErr_Occurred()) SWIG_fail;
4581 }
4582 {
4583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4584 }
4585 {
4586 if (temp2)
4587 delete arg2;
4588 }
4589 return resultobj;
4590 fail:
4591 {
4592 if (temp2)
4593 delete arg2;
4594 }
4595 return NULL;
4596 }
4597
4598
4599 static PyObject *_wrap_Bitmap_GetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
4600 PyObject *resultobj;
4601 wxBitmap *arg1 = (wxBitmap *) 0 ;
4602 wxPalette *result;
4603 PyObject * obj0 = 0 ;
4604 char *kwnames[] = {
4605 (char *) "self", NULL
4606 };
4607
4608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetPalette",kwnames,&obj0)) goto fail;
4609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4610 if (SWIG_arg_fail(1)) SWIG_fail;
4611 {
4612 PyThreadState* __tstate = wxPyBeginAllowThreads();
4613 result = (wxPalette *)((wxBitmap const *)arg1)->GetPalette();
4614
4615 wxPyEndAllowThreads(__tstate);
4616 if (PyErr_Occurred()) SWIG_fail;
4617 }
4618 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 0);
4619 return resultobj;
4620 fail:
4621 return NULL;
4622 }
4623
4624
4625 static PyObject *_wrap_Bitmap_CopyFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4626 PyObject *resultobj;
4627 wxBitmap *arg1 = (wxBitmap *) 0 ;
4628 wxIcon *arg2 = 0 ;
4629 bool result;
4630 PyObject * obj0 = 0 ;
4631 PyObject * obj1 = 0 ;
4632 char *kwnames[] = {
4633 (char *) "self",(char *) "icon", NULL
4634 };
4635
4636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_CopyFromIcon",kwnames,&obj0,&obj1)) goto fail;
4637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4638 if (SWIG_arg_fail(1)) SWIG_fail;
4639 {
4640 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4641 if (SWIG_arg_fail(2)) SWIG_fail;
4642 if (arg2 == NULL) {
4643 SWIG_null_ref("wxIcon");
4644 }
4645 if (SWIG_arg_fail(2)) SWIG_fail;
4646 }
4647 {
4648 PyThreadState* __tstate = wxPyBeginAllowThreads();
4649 result = (bool)(arg1)->CopyFromIcon((wxIcon const &)*arg2);
4650
4651 wxPyEndAllowThreads(__tstate);
4652 if (PyErr_Occurred()) SWIG_fail;
4653 }
4654 {
4655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4656 }
4657 return resultobj;
4658 fail:
4659 return NULL;
4660 }
4661
4662
4663 static PyObject *_wrap_Bitmap_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4664 PyObject *resultobj;
4665 wxBitmap *arg1 = (wxBitmap *) 0 ;
4666 int arg2 ;
4667 PyObject * obj0 = 0 ;
4668 PyObject * obj1 = 0 ;
4669 char *kwnames[] = {
4670 (char *) "self",(char *) "height", NULL
4671 };
4672
4673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetHeight",kwnames,&obj0,&obj1)) goto fail;
4674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4675 if (SWIG_arg_fail(1)) SWIG_fail;
4676 {
4677 arg2 = (int)(SWIG_As_int(obj1));
4678 if (SWIG_arg_fail(2)) SWIG_fail;
4679 }
4680 {
4681 PyThreadState* __tstate = wxPyBeginAllowThreads();
4682 (arg1)->SetHeight(arg2);
4683
4684 wxPyEndAllowThreads(__tstate);
4685 if (PyErr_Occurred()) SWIG_fail;
4686 }
4687 Py_INCREF(Py_None); resultobj = Py_None;
4688 return resultobj;
4689 fail:
4690 return NULL;
4691 }
4692
4693
4694 static PyObject *_wrap_Bitmap_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4695 PyObject *resultobj;
4696 wxBitmap *arg1 = (wxBitmap *) 0 ;
4697 int arg2 ;
4698 PyObject * obj0 = 0 ;
4699 PyObject * obj1 = 0 ;
4700 char *kwnames[] = {
4701 (char *) "self",(char *) "width", NULL
4702 };
4703
4704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetWidth",kwnames,&obj0,&obj1)) goto fail;
4705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4706 if (SWIG_arg_fail(1)) SWIG_fail;
4707 {
4708 arg2 = (int)(SWIG_As_int(obj1));
4709 if (SWIG_arg_fail(2)) SWIG_fail;
4710 }
4711 {
4712 PyThreadState* __tstate = wxPyBeginAllowThreads();
4713 (arg1)->SetWidth(arg2);
4714
4715 wxPyEndAllowThreads(__tstate);
4716 if (PyErr_Occurred()) SWIG_fail;
4717 }
4718 Py_INCREF(Py_None); resultobj = Py_None;
4719 return resultobj;
4720 fail:
4721 return NULL;
4722 }
4723
4724
4725 static PyObject *_wrap_Bitmap_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4726 PyObject *resultobj;
4727 wxBitmap *arg1 = (wxBitmap *) 0 ;
4728 int arg2 ;
4729 PyObject * obj0 = 0 ;
4730 PyObject * obj1 = 0 ;
4731 char *kwnames[] = {
4732 (char *) "self",(char *) "depth", NULL
4733 };
4734
4735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetDepth",kwnames,&obj0,&obj1)) goto fail;
4736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4737 if (SWIG_arg_fail(1)) SWIG_fail;
4738 {
4739 arg2 = (int)(SWIG_As_int(obj1));
4740 if (SWIG_arg_fail(2)) SWIG_fail;
4741 }
4742 {
4743 PyThreadState* __tstate = wxPyBeginAllowThreads();
4744 (arg1)->SetDepth(arg2);
4745
4746 wxPyEndAllowThreads(__tstate);
4747 if (PyErr_Occurred()) SWIG_fail;
4748 }
4749 Py_INCREF(Py_None); resultobj = Py_None;
4750 return resultobj;
4751 fail:
4752 return NULL;
4753 }
4754
4755
4756 static PyObject *_wrap_Bitmap_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4757 PyObject *resultobj;
4758 wxBitmap *arg1 = (wxBitmap *) 0 ;
4759 wxSize *arg2 = 0 ;
4760 wxSize temp2 ;
4761 PyObject * obj0 = 0 ;
4762 PyObject * obj1 = 0 ;
4763 char *kwnames[] = {
4764 (char *) "self",(char *) "size", NULL
4765 };
4766
4767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetSize",kwnames,&obj0,&obj1)) goto fail;
4768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4769 if (SWIG_arg_fail(1)) SWIG_fail;
4770 {
4771 arg2 = &temp2;
4772 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4773 }
4774 {
4775 PyThreadState* __tstate = wxPyBeginAllowThreads();
4776 wxBitmap_SetSize(arg1,(wxSize const &)*arg2);
4777
4778 wxPyEndAllowThreads(__tstate);
4779 if (PyErr_Occurred()) SWIG_fail;
4780 }
4781 Py_INCREF(Py_None); resultobj = Py_None;
4782 return resultobj;
4783 fail:
4784 return NULL;
4785 }
4786
4787
4788 static PyObject *_wrap_Bitmap___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4789 PyObject *resultobj;
4790 wxBitmap *arg1 = (wxBitmap *) 0 ;
4791 wxBitmap *arg2 = (wxBitmap *) 0 ;
4792 bool result;
4793 PyObject * obj0 = 0 ;
4794 PyObject * obj1 = 0 ;
4795 char *kwnames[] = {
4796 (char *) "self",(char *) "other", NULL
4797 };
4798
4799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___eq__",kwnames,&obj0,&obj1)) goto fail;
4800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4801 if (SWIG_arg_fail(1)) SWIG_fail;
4802 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4803 if (SWIG_arg_fail(2)) SWIG_fail;
4804 {
4805 PyThreadState* __tstate = wxPyBeginAllowThreads();
4806 result = (bool)wxBitmap___eq__(arg1,(wxBitmap const *)arg2);
4807
4808 wxPyEndAllowThreads(__tstate);
4809 if (PyErr_Occurred()) SWIG_fail;
4810 }
4811 {
4812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4813 }
4814 return resultobj;
4815 fail:
4816 return NULL;
4817 }
4818
4819
4820 static PyObject *_wrap_Bitmap___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4821 PyObject *resultobj;
4822 wxBitmap *arg1 = (wxBitmap *) 0 ;
4823 wxBitmap *arg2 = (wxBitmap *) 0 ;
4824 bool result;
4825 PyObject * obj0 = 0 ;
4826 PyObject * obj1 = 0 ;
4827 char *kwnames[] = {
4828 (char *) "self",(char *) "other", NULL
4829 };
4830
4831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___ne__",kwnames,&obj0,&obj1)) goto fail;
4832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4833 if (SWIG_arg_fail(1)) SWIG_fail;
4834 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4835 if (SWIG_arg_fail(2)) SWIG_fail;
4836 {
4837 PyThreadState* __tstate = wxPyBeginAllowThreads();
4838 result = (bool)wxBitmap___ne__(arg1,(wxBitmap const *)arg2);
4839
4840 wxPyEndAllowThreads(__tstate);
4841 if (PyErr_Occurred()) SWIG_fail;
4842 }
4843 {
4844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4845 }
4846 return resultobj;
4847 fail:
4848 return NULL;
4849 }
4850
4851
4852 static PyObject * Bitmap_swigregister(PyObject *, PyObject *args) {
4853 PyObject *obj;
4854 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4855 SWIG_TypeClientData(SWIGTYPE_p_wxBitmap, obj);
4856 Py_INCREF(obj);
4857 return Py_BuildValue((char *)"");
4858 }
4859 static PyObject *_wrap_new_Mask(PyObject *, PyObject *args, PyObject *kwargs) {
4860 PyObject *resultobj;
4861 wxBitmap *arg1 = 0 ;
4862 wxColour const &arg2_defvalue = wxNullColour ;
4863 wxColour *arg2 = (wxColour *) &arg2_defvalue ;
4864 wxMask *result;
4865 wxColour temp2 ;
4866 PyObject * obj0 = 0 ;
4867 PyObject * obj1 = 0 ;
4868 char *kwnames[] = {
4869 (char *) "bitmap",(char *) "colour", NULL
4870 };
4871
4872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Mask",kwnames,&obj0,&obj1)) goto fail;
4873 {
4874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4875 if (SWIG_arg_fail(1)) SWIG_fail;
4876 if (arg1 == NULL) {
4877 SWIG_null_ref("wxBitmap");
4878 }
4879 if (SWIG_arg_fail(1)) SWIG_fail;
4880 }
4881 if (obj1) {
4882 {
4883 arg2 = &temp2;
4884 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4885 }
4886 }
4887 {
4888 if (!wxPyCheckForApp()) SWIG_fail;
4889 PyThreadState* __tstate = wxPyBeginAllowThreads();
4890 result = (wxMask *)new_wxMask((wxBitmap const &)*arg1,(wxColour const &)*arg2);
4891
4892 wxPyEndAllowThreads(__tstate);
4893 if (PyErr_Occurred()) SWIG_fail;
4894 }
4895 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 1);
4896 return resultobj;
4897 fail:
4898 return NULL;
4899 }
4900
4901
4902 static PyObject * Mask_swigregister(PyObject *, PyObject *args) {
4903 PyObject *obj;
4904 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4905 SWIG_TypeClientData(SWIGTYPE_p_wxMask, obj);
4906 Py_INCREF(obj);
4907 return Py_BuildValue((char *)"");
4908 }
4909 static PyObject *_wrap_new_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
4910 PyObject *resultobj;
4911 wxString *arg1 = 0 ;
4912 wxBitmapType arg2 ;
4913 int arg3 = (int) -1 ;
4914 int arg4 = (int) -1 ;
4915 wxIcon *result;
4916 bool temp1 = false ;
4917 PyObject * obj0 = 0 ;
4918 PyObject * obj1 = 0 ;
4919 PyObject * obj2 = 0 ;
4920 PyObject * obj3 = 0 ;
4921 char *kwnames[] = {
4922 (char *) "name",(char *) "type",(char *) "desiredWidth",(char *) "desiredHeight", NULL
4923 };
4924
4925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Icon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4926 {
4927 arg1 = wxString_in_helper(obj0);
4928 if (arg1 == NULL) SWIG_fail;
4929 temp1 = true;
4930 }
4931 {
4932 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
4933 if (SWIG_arg_fail(2)) SWIG_fail;
4934 }
4935 if (obj2) {
4936 {
4937 arg3 = (int)(SWIG_As_int(obj2));
4938 if (SWIG_arg_fail(3)) SWIG_fail;
4939 }
4940 }
4941 if (obj3) {
4942 {
4943 arg4 = (int)(SWIG_As_int(obj3));
4944 if (SWIG_arg_fail(4)) SWIG_fail;
4945 }
4946 }
4947 {
4948 if (!wxPyCheckForApp()) SWIG_fail;
4949 PyThreadState* __tstate = wxPyBeginAllowThreads();
4950 result = (wxIcon *)new wxIcon((wxString const &)*arg1,(wxBitmapType )arg2,arg3,arg4);
4951
4952 wxPyEndAllowThreads(__tstate);
4953 if (PyErr_Occurred()) SWIG_fail;
4954 }
4955 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
4956 {
4957 if (temp1)
4958 delete arg1;
4959 }
4960 return resultobj;
4961 fail:
4962 {
4963 if (temp1)
4964 delete arg1;
4965 }
4966 return NULL;
4967 }
4968
4969
4970 static PyObject *_wrap_delete_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
4971 PyObject *resultobj;
4972 wxIcon *arg1 = (wxIcon *) 0 ;
4973 PyObject * obj0 = 0 ;
4974 char *kwnames[] = {
4975 (char *) "self", NULL
4976 };
4977
4978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Icon",kwnames,&obj0)) goto fail;
4979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4980 if (SWIG_arg_fail(1)) SWIG_fail;
4981 {
4982 PyThreadState* __tstate = wxPyBeginAllowThreads();
4983 delete arg1;
4984
4985 wxPyEndAllowThreads(__tstate);
4986 if (PyErr_Occurred()) SWIG_fail;
4987 }
4988 Py_INCREF(Py_None); resultobj = Py_None;
4989 return resultobj;
4990 fail:
4991 return NULL;
4992 }
4993
4994
4995 static PyObject *_wrap_new_EmptyIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4996 PyObject *resultobj;
4997 wxIcon *result;
4998 char *kwnames[] = {
4999 NULL
5000 };
5001
5002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EmptyIcon",kwnames)) goto fail;
5003 {
5004 if (!wxPyCheckForApp()) SWIG_fail;
5005 PyThreadState* __tstate = wxPyBeginAllowThreads();
5006 result = (wxIcon *)new wxIcon();
5007
5008 wxPyEndAllowThreads(__tstate);
5009 if (PyErr_Occurred()) SWIG_fail;
5010 }
5011 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5012 return resultobj;
5013 fail:
5014 return NULL;
5015 }
5016
5017
5018 static PyObject *_wrap_new_IconFromLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5019 PyObject *resultobj;
5020 wxIconLocation *arg1 = 0 ;
5021 wxIcon *result;
5022 PyObject * obj0 = 0 ;
5023 char *kwnames[] = {
5024 (char *) "loc", NULL
5025 };
5026
5027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromLocation",kwnames,&obj0)) goto fail;
5028 {
5029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5030 if (SWIG_arg_fail(1)) SWIG_fail;
5031 if (arg1 == NULL) {
5032 SWIG_null_ref("wxIconLocation");
5033 }
5034 if (SWIG_arg_fail(1)) SWIG_fail;
5035 }
5036 {
5037 if (!wxPyCheckForApp()) SWIG_fail;
5038 PyThreadState* __tstate = wxPyBeginAllowThreads();
5039 result = (wxIcon *)new wxIcon((wxIconLocation const &)*arg1);
5040
5041 wxPyEndAllowThreads(__tstate);
5042 if (PyErr_Occurred()) SWIG_fail;
5043 }
5044 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5045 return resultobj;
5046 fail:
5047 return NULL;
5048 }
5049
5050
5051 static PyObject *_wrap_new_IconFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5052 PyObject *resultobj;
5053 wxBitmap *arg1 = 0 ;
5054 wxIcon *result;
5055 PyObject * obj0 = 0 ;
5056 char *kwnames[] = {
5057 (char *) "bmp", NULL
5058 };
5059
5060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromBitmap",kwnames,&obj0)) goto fail;
5061 {
5062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5063 if (SWIG_arg_fail(1)) SWIG_fail;
5064 if (arg1 == NULL) {
5065 SWIG_null_ref("wxBitmap");
5066 }
5067 if (SWIG_arg_fail(1)) SWIG_fail;
5068 }
5069 {
5070 if (!wxPyCheckForApp()) SWIG_fail;
5071 PyThreadState* __tstate = wxPyBeginAllowThreads();
5072 result = (wxIcon *)new_wxIcon((wxBitmap const &)*arg1);
5073
5074 wxPyEndAllowThreads(__tstate);
5075 if (PyErr_Occurred()) SWIG_fail;
5076 }
5077 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5078 return resultobj;
5079 fail:
5080 return NULL;
5081 }
5082
5083
5084 static PyObject *_wrap_new_IconFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
5085 PyObject *resultobj;
5086 PyObject *arg1 = (PyObject *) 0 ;
5087 wxIcon *result;
5088 PyObject * obj0 = 0 ;
5089 char *kwnames[] = {
5090 (char *) "listOfStrings", NULL
5091 };
5092
5093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromXPMData",kwnames,&obj0)) goto fail;
5094 arg1 = obj0;
5095 {
5096 if (!wxPyCheckForApp()) SWIG_fail;
5097 PyThreadState* __tstate = wxPyBeginAllowThreads();
5098 result = (wxIcon *)new_wxIcon(arg1);
5099
5100 wxPyEndAllowThreads(__tstate);
5101 if (PyErr_Occurred()) SWIG_fail;
5102 }
5103 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5104 return resultobj;
5105 fail:
5106 return NULL;
5107 }
5108
5109
5110 static PyObject *_wrap_Icon_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
5111 PyObject *resultobj;
5112 wxIcon *arg1 = (wxIcon *) 0 ;
5113 wxString *arg2 = 0 ;
5114 wxBitmapType arg3 ;
5115 bool result;
5116 bool temp2 = false ;
5117 PyObject * obj0 = 0 ;
5118 PyObject * obj1 = 0 ;
5119 PyObject * obj2 = 0 ;
5120 char *kwnames[] = {
5121 (char *) "self",(char *) "name",(char *) "type", NULL
5122 };
5123
5124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Icon_LoadFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
5125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5126 if (SWIG_arg_fail(1)) SWIG_fail;
5127 {
5128 arg2 = wxString_in_helper(obj1);
5129 if (arg2 == NULL) SWIG_fail;
5130 temp2 = true;
5131 }
5132 {
5133 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
5134 if (SWIG_arg_fail(3)) SWIG_fail;
5135 }
5136 {
5137 PyThreadState* __tstate = wxPyBeginAllowThreads();
5138 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxBitmapType )arg3);
5139
5140 wxPyEndAllowThreads(__tstate);
5141 if (PyErr_Occurred()) SWIG_fail;
5142 }
5143 {
5144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5145 }
5146 {
5147 if (temp2)
5148 delete arg2;
5149 }
5150 return resultobj;
5151 fail:
5152 {
5153 if (temp2)
5154 delete arg2;
5155 }
5156 return NULL;
5157 }
5158
5159
5160 static PyObject *_wrap_Icon_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
5161 PyObject *resultobj;
5162 wxIcon *arg1 = (wxIcon *) 0 ;
5163 bool result;
5164 PyObject * obj0 = 0 ;
5165 char *kwnames[] = {
5166 (char *) "self", NULL
5167 };
5168
5169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_Ok",kwnames,&obj0)) goto fail;
5170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5171 if (SWIG_arg_fail(1)) SWIG_fail;
5172 {
5173 PyThreadState* __tstate = wxPyBeginAllowThreads();
5174 result = (bool)(arg1)->Ok();
5175
5176 wxPyEndAllowThreads(__tstate);
5177 if (PyErr_Occurred()) SWIG_fail;
5178 }
5179 {
5180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5181 }
5182 return resultobj;
5183 fail:
5184 return NULL;
5185 }
5186
5187
5188 static PyObject *_wrap_Icon_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5189 PyObject *resultobj;
5190 wxIcon *arg1 = (wxIcon *) 0 ;
5191 int result;
5192 PyObject * obj0 = 0 ;
5193 char *kwnames[] = {
5194 (char *) "self", NULL
5195 };
5196
5197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetWidth",kwnames,&obj0)) goto fail;
5198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5199 if (SWIG_arg_fail(1)) SWIG_fail;
5200 {
5201 PyThreadState* __tstate = wxPyBeginAllowThreads();
5202 result = (int)(arg1)->GetWidth();
5203
5204 wxPyEndAllowThreads(__tstate);
5205 if (PyErr_Occurred()) SWIG_fail;
5206 }
5207 {
5208 resultobj = SWIG_From_int((int)(result));
5209 }
5210 return resultobj;
5211 fail:
5212 return NULL;
5213 }
5214
5215
5216 static PyObject *_wrap_Icon_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5217 PyObject *resultobj;
5218 wxIcon *arg1 = (wxIcon *) 0 ;
5219 int result;
5220 PyObject * obj0 = 0 ;
5221 char *kwnames[] = {
5222 (char *) "self", NULL
5223 };
5224
5225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetHeight",kwnames,&obj0)) goto fail;
5226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5227 if (SWIG_arg_fail(1)) SWIG_fail;
5228 {
5229 PyThreadState* __tstate = wxPyBeginAllowThreads();
5230 result = (int)(arg1)->GetHeight();
5231
5232 wxPyEndAllowThreads(__tstate);
5233 if (PyErr_Occurred()) SWIG_fail;
5234 }
5235 {
5236 resultobj = SWIG_From_int((int)(result));
5237 }
5238 return resultobj;
5239 fail:
5240 return NULL;
5241 }
5242
5243
5244 static PyObject *_wrap_Icon_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5245 PyObject *resultobj;
5246 wxIcon *arg1 = (wxIcon *) 0 ;
5247 int result;
5248 PyObject * obj0 = 0 ;
5249 char *kwnames[] = {
5250 (char *) "self", NULL
5251 };
5252
5253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetDepth",kwnames,&obj0)) goto fail;
5254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5255 if (SWIG_arg_fail(1)) SWIG_fail;
5256 {
5257 PyThreadState* __tstate = wxPyBeginAllowThreads();
5258 result = (int)(arg1)->GetDepth();
5259
5260 wxPyEndAllowThreads(__tstate);
5261 if (PyErr_Occurred()) SWIG_fail;
5262 }
5263 {
5264 resultobj = SWIG_From_int((int)(result));
5265 }
5266 return resultobj;
5267 fail:
5268 return NULL;
5269 }
5270
5271
5272 static PyObject *_wrap_Icon_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5273 PyObject *resultobj;
5274 wxIcon *arg1 = (wxIcon *) 0 ;
5275 int arg2 ;
5276 PyObject * obj0 = 0 ;
5277 PyObject * obj1 = 0 ;
5278 char *kwnames[] = {
5279 (char *) "self",(char *) "w", NULL
5280 };
5281
5282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5284 if (SWIG_arg_fail(1)) SWIG_fail;
5285 {
5286 arg2 = (int)(SWIG_As_int(obj1));
5287 if (SWIG_arg_fail(2)) SWIG_fail;
5288 }
5289 {
5290 PyThreadState* __tstate = wxPyBeginAllowThreads();
5291 (arg1)->SetWidth(arg2);
5292
5293 wxPyEndAllowThreads(__tstate);
5294 if (PyErr_Occurred()) SWIG_fail;
5295 }
5296 Py_INCREF(Py_None); resultobj = Py_None;
5297 return resultobj;
5298 fail:
5299 return NULL;
5300 }
5301
5302
5303 static PyObject *_wrap_Icon_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5304 PyObject *resultobj;
5305 wxIcon *arg1 = (wxIcon *) 0 ;
5306 int arg2 ;
5307 PyObject * obj0 = 0 ;
5308 PyObject * obj1 = 0 ;
5309 char *kwnames[] = {
5310 (char *) "self",(char *) "h", NULL
5311 };
5312
5313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5315 if (SWIG_arg_fail(1)) SWIG_fail;
5316 {
5317 arg2 = (int)(SWIG_As_int(obj1));
5318 if (SWIG_arg_fail(2)) SWIG_fail;
5319 }
5320 {
5321 PyThreadState* __tstate = wxPyBeginAllowThreads();
5322 (arg1)->SetHeight(arg2);
5323
5324 wxPyEndAllowThreads(__tstate);
5325 if (PyErr_Occurred()) SWIG_fail;
5326 }
5327 Py_INCREF(Py_None); resultobj = Py_None;
5328 return resultobj;
5329 fail:
5330 return NULL;
5331 }
5332
5333
5334 static PyObject *_wrap_Icon_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5335 PyObject *resultobj;
5336 wxIcon *arg1 = (wxIcon *) 0 ;
5337 int arg2 ;
5338 PyObject * obj0 = 0 ;
5339 PyObject * obj1 = 0 ;
5340 char *kwnames[] = {
5341 (char *) "self",(char *) "d", NULL
5342 };
5343
5344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetDepth",kwnames,&obj0,&obj1)) goto fail;
5345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5346 if (SWIG_arg_fail(1)) SWIG_fail;
5347 {
5348 arg2 = (int)(SWIG_As_int(obj1));
5349 if (SWIG_arg_fail(2)) SWIG_fail;
5350 }
5351 {
5352 PyThreadState* __tstate = wxPyBeginAllowThreads();
5353 (arg1)->SetDepth(arg2);
5354
5355 wxPyEndAllowThreads(__tstate);
5356 if (PyErr_Occurred()) SWIG_fail;
5357 }
5358 Py_INCREF(Py_None); resultobj = Py_None;
5359 return resultobj;
5360 fail:
5361 return NULL;
5362 }
5363
5364
5365 static PyObject *_wrap_Icon_CopyFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5366 PyObject *resultobj;
5367 wxIcon *arg1 = (wxIcon *) 0 ;
5368 wxBitmap *arg2 = 0 ;
5369 PyObject * obj0 = 0 ;
5370 PyObject * obj1 = 0 ;
5371 char *kwnames[] = {
5372 (char *) "self",(char *) "bmp", NULL
5373 };
5374
5375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_CopyFromBitmap",kwnames,&obj0,&obj1)) goto fail;
5376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5377 if (SWIG_arg_fail(1)) SWIG_fail;
5378 {
5379 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5380 if (SWIG_arg_fail(2)) SWIG_fail;
5381 if (arg2 == NULL) {
5382 SWIG_null_ref("wxBitmap");
5383 }
5384 if (SWIG_arg_fail(2)) SWIG_fail;
5385 }
5386 {
5387 PyThreadState* __tstate = wxPyBeginAllowThreads();
5388 (arg1)->CopyFromBitmap((wxBitmap const &)*arg2);
5389
5390 wxPyEndAllowThreads(__tstate);
5391 if (PyErr_Occurred()) SWIG_fail;
5392 }
5393 Py_INCREF(Py_None); resultobj = Py_None;
5394 return resultobj;
5395 fail:
5396 return NULL;
5397 }
5398
5399
5400 static PyObject * Icon_swigregister(PyObject *, PyObject *args) {
5401 PyObject *obj;
5402 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5403 SWIG_TypeClientData(SWIGTYPE_p_wxIcon, obj);
5404 Py_INCREF(obj);
5405 return Py_BuildValue((char *)"");
5406 }
5407 static PyObject *_wrap_new_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5408 PyObject *resultobj;
5409 wxString *arg1 = (wxString *) &wxPyEmptyString ;
5410 int arg2 = (int) 0 ;
5411 wxIconLocation *result;
5412 bool temp1 = false ;
5413 PyObject * obj0 = 0 ;
5414 PyObject * obj1 = 0 ;
5415 char *kwnames[] = {
5416 (char *) "filename",(char *) "num", NULL
5417 };
5418
5419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconLocation",kwnames,&obj0,&obj1)) goto fail;
5420 if (obj0) {
5421 {
5422 arg1 = wxString_in_helper(obj0);
5423 if (arg1 == NULL) SWIG_fail;
5424 temp1 = true;
5425 }
5426 }
5427 if (obj1) {
5428 {
5429 arg2 = (int)(SWIG_As_int(obj1));
5430 if (SWIG_arg_fail(2)) SWIG_fail;
5431 }
5432 }
5433 {
5434 PyThreadState* __tstate = wxPyBeginAllowThreads();
5435 result = (wxIconLocation *)new_wxIconLocation((wxString const *)arg1,arg2);
5436
5437 wxPyEndAllowThreads(__tstate);
5438 if (PyErr_Occurred()) SWIG_fail;
5439 }
5440 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconLocation, 1);
5441 {
5442 if (temp1)
5443 delete arg1;
5444 }
5445 return resultobj;
5446 fail:
5447 {
5448 if (temp1)
5449 delete arg1;
5450 }
5451 return NULL;
5452 }
5453
5454
5455 static PyObject *_wrap_delete_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5456 PyObject *resultobj;
5457 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5458 PyObject * obj0 = 0 ;
5459 char *kwnames[] = {
5460 (char *) "self", NULL
5461 };
5462
5463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconLocation",kwnames,&obj0)) goto fail;
5464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5465 if (SWIG_arg_fail(1)) SWIG_fail;
5466 {
5467 PyThreadState* __tstate = wxPyBeginAllowThreads();
5468 delete arg1;
5469
5470 wxPyEndAllowThreads(__tstate);
5471 if (PyErr_Occurred()) SWIG_fail;
5472 }
5473 Py_INCREF(Py_None); resultobj = Py_None;
5474 return resultobj;
5475 fail:
5476 return NULL;
5477 }
5478
5479
5480 static PyObject *_wrap_IconLocation_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
5481 PyObject *resultobj;
5482 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5483 bool result;
5484 PyObject * obj0 = 0 ;
5485 char *kwnames[] = {
5486 (char *) "self", NULL
5487 };
5488
5489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_IsOk",kwnames,&obj0)) goto fail;
5490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5491 if (SWIG_arg_fail(1)) SWIG_fail;
5492 {
5493 PyThreadState* __tstate = wxPyBeginAllowThreads();
5494 result = (bool)((wxIconLocation const *)arg1)->IsOk();
5495
5496 wxPyEndAllowThreads(__tstate);
5497 if (PyErr_Occurred()) SWIG_fail;
5498 }
5499 {
5500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5501 }
5502 return resultobj;
5503 fail:
5504 return NULL;
5505 }
5506
5507
5508 static PyObject *_wrap_IconLocation_SetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5509 PyObject *resultobj;
5510 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5511 wxString *arg2 = 0 ;
5512 bool temp2 = false ;
5513 PyObject * obj0 = 0 ;
5514 PyObject * obj1 = 0 ;
5515 char *kwnames[] = {
5516 (char *) "self",(char *) "filename", NULL
5517 };
5518
5519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetFileName",kwnames,&obj0,&obj1)) goto fail;
5520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5521 if (SWIG_arg_fail(1)) SWIG_fail;
5522 {
5523 arg2 = wxString_in_helper(obj1);
5524 if (arg2 == NULL) SWIG_fail;
5525 temp2 = true;
5526 }
5527 {
5528 PyThreadState* __tstate = wxPyBeginAllowThreads();
5529 (arg1)->SetFileName((wxString const &)*arg2);
5530
5531 wxPyEndAllowThreads(__tstate);
5532 if (PyErr_Occurred()) SWIG_fail;
5533 }
5534 Py_INCREF(Py_None); resultobj = Py_None;
5535 {
5536 if (temp2)
5537 delete arg2;
5538 }
5539 return resultobj;
5540 fail:
5541 {
5542 if (temp2)
5543 delete arg2;
5544 }
5545 return NULL;
5546 }
5547
5548
5549 static PyObject *_wrap_IconLocation_GetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5550 PyObject *resultobj;
5551 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5552 wxString *result;
5553 PyObject * obj0 = 0 ;
5554 char *kwnames[] = {
5555 (char *) "self", NULL
5556 };
5557
5558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetFileName",kwnames,&obj0)) goto fail;
5559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5560 if (SWIG_arg_fail(1)) SWIG_fail;
5561 {
5562 PyThreadState* __tstate = wxPyBeginAllowThreads();
5563 {
5564 wxString const &_result_ref = ((wxIconLocation const *)arg1)->GetFileName();
5565 result = (wxString *) &_result_ref;
5566 }
5567
5568 wxPyEndAllowThreads(__tstate);
5569 if (PyErr_Occurred()) SWIG_fail;
5570 }
5571 {
5572 #if wxUSE_UNICODE
5573 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
5574 #else
5575 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
5576 #endif
5577 }
5578 return resultobj;
5579 fail:
5580 return NULL;
5581 }
5582
5583
5584 static PyObject *_wrap_IconLocation_SetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5585 PyObject *resultobj;
5586 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5587 int arg2 ;
5588 PyObject * obj0 = 0 ;
5589 PyObject * obj1 = 0 ;
5590 char *kwnames[] = {
5591 (char *) "self",(char *) "num", NULL
5592 };
5593
5594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetIndex",kwnames,&obj0,&obj1)) goto fail;
5595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5596 if (SWIG_arg_fail(1)) SWIG_fail;
5597 {
5598 arg2 = (int)(SWIG_As_int(obj1));
5599 if (SWIG_arg_fail(2)) SWIG_fail;
5600 }
5601 {
5602 PyThreadState* __tstate = wxPyBeginAllowThreads();
5603 wxIconLocation_SetIndex(arg1,arg2);
5604
5605 wxPyEndAllowThreads(__tstate);
5606 if (PyErr_Occurred()) SWIG_fail;
5607 }
5608 Py_INCREF(Py_None); resultobj = Py_None;
5609 return resultobj;
5610 fail:
5611 return NULL;
5612 }
5613
5614
5615 static PyObject *_wrap_IconLocation_GetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5616 PyObject *resultobj;
5617 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5618 int result;
5619 PyObject * obj0 = 0 ;
5620 char *kwnames[] = {
5621 (char *) "self", NULL
5622 };
5623
5624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetIndex",kwnames,&obj0)) goto fail;
5625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5626 if (SWIG_arg_fail(1)) SWIG_fail;
5627 {
5628 PyThreadState* __tstate = wxPyBeginAllowThreads();
5629 result = (int)wxIconLocation_GetIndex(arg1);
5630
5631 wxPyEndAllowThreads(__tstate);
5632 if (PyErr_Occurred()) SWIG_fail;
5633 }
5634 {
5635 resultobj = SWIG_From_int((int)(result));
5636 }
5637 return resultobj;
5638 fail:
5639 return NULL;
5640 }
5641
5642
5643 static PyObject * IconLocation_swigregister(PyObject *, PyObject *args) {
5644 PyObject *obj;
5645 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5646 SWIG_TypeClientData(SWIGTYPE_p_wxIconLocation, obj);
5647 Py_INCREF(obj);
5648 return Py_BuildValue((char *)"");
5649 }
5650 static PyObject *_wrap_new_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
5651 PyObject *resultobj;
5652 wxIconBundle *result;
5653 char *kwnames[] = {
5654 NULL
5655 };
5656
5657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IconBundle",kwnames)) goto fail;
5658 {
5659 PyThreadState* __tstate = wxPyBeginAllowThreads();
5660 result = (wxIconBundle *)new wxIconBundle();
5661
5662 wxPyEndAllowThreads(__tstate);
5663 if (PyErr_Occurred()) SWIG_fail;
5664 }
5665 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5666 return resultobj;
5667 fail:
5668 return NULL;
5669 }
5670
5671
5672 static PyObject *_wrap_new_IconBundleFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
5673 PyObject *resultobj;
5674 wxString *arg1 = 0 ;
5675 long arg2 ;
5676 wxIconBundle *result;
5677 bool temp1 = false ;
5678 PyObject * obj0 = 0 ;
5679 PyObject * obj1 = 0 ;
5680 char *kwnames[] = {
5681 (char *) "file",(char *) "type", NULL
5682 };
5683
5684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_IconBundleFromFile",kwnames,&obj0,&obj1)) goto fail;
5685 {
5686 arg1 = wxString_in_helper(obj0);
5687 if (arg1 == NULL) SWIG_fail;
5688 temp1 = true;
5689 }
5690 {
5691 arg2 = (long)(SWIG_As_long(obj1));
5692 if (SWIG_arg_fail(2)) SWIG_fail;
5693 }
5694 {
5695 PyThreadState* __tstate = wxPyBeginAllowThreads();
5696 result = (wxIconBundle *)new wxIconBundle((wxString const &)*arg1,arg2);
5697
5698 wxPyEndAllowThreads(__tstate);
5699 if (PyErr_Occurred()) SWIG_fail;
5700 }
5701 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5702 {
5703 if (temp1)
5704 delete arg1;
5705 }
5706 return resultobj;
5707 fail:
5708 {
5709 if (temp1)
5710 delete arg1;
5711 }
5712 return NULL;
5713 }
5714
5715
5716 static PyObject *_wrap_new_IconBundleFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5717 PyObject *resultobj;
5718 wxIcon *arg1 = 0 ;
5719 wxIconBundle *result;
5720 PyObject * obj0 = 0 ;
5721 char *kwnames[] = {
5722 (char *) "icon", NULL
5723 };
5724
5725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconBundleFromIcon",kwnames,&obj0)) goto fail;
5726 {
5727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5728 if (SWIG_arg_fail(1)) SWIG_fail;
5729 if (arg1 == NULL) {
5730 SWIG_null_ref("wxIcon");
5731 }
5732 if (SWIG_arg_fail(1)) SWIG_fail;
5733 }
5734 {
5735 PyThreadState* __tstate = wxPyBeginAllowThreads();
5736 result = (wxIconBundle *)new wxIconBundle((wxIcon const &)*arg1);
5737
5738 wxPyEndAllowThreads(__tstate);
5739 if (PyErr_Occurred()) SWIG_fail;
5740 }
5741 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5742 return resultobj;
5743 fail:
5744 return NULL;
5745 }
5746
5747
5748 static PyObject *_wrap_delete_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
5749 PyObject *resultobj;
5750 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5751 PyObject * obj0 = 0 ;
5752 char *kwnames[] = {
5753 (char *) "self", NULL
5754 };
5755
5756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconBundle",kwnames,&obj0)) goto fail;
5757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5758 if (SWIG_arg_fail(1)) SWIG_fail;
5759 {
5760 PyThreadState* __tstate = wxPyBeginAllowThreads();
5761 delete arg1;
5762
5763 wxPyEndAllowThreads(__tstate);
5764 if (PyErr_Occurred()) SWIG_fail;
5765 }
5766 Py_INCREF(Py_None); resultobj = Py_None;
5767 return resultobj;
5768 fail:
5769 return NULL;
5770 }
5771
5772
5773 static PyObject *_wrap_IconBundle_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5774 PyObject *resultobj;
5775 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5776 wxIcon *arg2 = 0 ;
5777 PyObject * obj0 = 0 ;
5778 PyObject * obj1 = 0 ;
5779 char *kwnames[] = {
5780 (char *) "self",(char *) "icon", NULL
5781 };
5782
5783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_AddIcon",kwnames,&obj0,&obj1)) goto fail;
5784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5785 if (SWIG_arg_fail(1)) SWIG_fail;
5786 {
5787 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5788 if (SWIG_arg_fail(2)) SWIG_fail;
5789 if (arg2 == NULL) {
5790 SWIG_null_ref("wxIcon");
5791 }
5792 if (SWIG_arg_fail(2)) SWIG_fail;
5793 }
5794 {
5795 PyThreadState* __tstate = wxPyBeginAllowThreads();
5796 (arg1)->AddIcon((wxIcon const &)*arg2);
5797
5798 wxPyEndAllowThreads(__tstate);
5799 if (PyErr_Occurred()) SWIG_fail;
5800 }
5801 Py_INCREF(Py_None); resultobj = Py_None;
5802 return resultobj;
5803 fail:
5804 return NULL;
5805 }
5806
5807
5808 static PyObject *_wrap_IconBundle_AddIconFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
5809 PyObject *resultobj;
5810 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5811 wxString *arg2 = 0 ;
5812 long arg3 ;
5813 bool temp2 = false ;
5814 PyObject * obj0 = 0 ;
5815 PyObject * obj1 = 0 ;
5816 PyObject * obj2 = 0 ;
5817 char *kwnames[] = {
5818 (char *) "self",(char *) "file",(char *) "type", NULL
5819 };
5820
5821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IconBundle_AddIconFromFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
5822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5823 if (SWIG_arg_fail(1)) SWIG_fail;
5824 {
5825 arg2 = wxString_in_helper(obj1);
5826 if (arg2 == NULL) SWIG_fail;
5827 temp2 = true;
5828 }
5829 {
5830 arg3 = (long)(SWIG_As_long(obj2));
5831 if (SWIG_arg_fail(3)) SWIG_fail;
5832 }
5833 {
5834 PyThreadState* __tstate = wxPyBeginAllowThreads();
5835 (arg1)->AddIcon((wxString const &)*arg2,arg3);
5836
5837 wxPyEndAllowThreads(__tstate);
5838 if (PyErr_Occurred()) SWIG_fail;
5839 }
5840 Py_INCREF(Py_None); resultobj = Py_None;
5841 {
5842 if (temp2)
5843 delete arg2;
5844 }
5845 return resultobj;
5846 fail:
5847 {
5848 if (temp2)
5849 delete arg2;
5850 }
5851 return NULL;
5852 }
5853
5854
5855 static PyObject *_wrap_IconBundle_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5856 PyObject *resultobj;
5857 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5858 wxSize *arg2 = 0 ;
5859 wxIcon *result;
5860 wxSize temp2 ;
5861 PyObject * obj0 = 0 ;
5862 PyObject * obj1 = 0 ;
5863 char *kwnames[] = {
5864 (char *) "self",(char *) "size", NULL
5865 };
5866
5867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_GetIcon",kwnames,&obj0,&obj1)) goto fail;
5868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5869 if (SWIG_arg_fail(1)) SWIG_fail;
5870 {
5871 arg2 = &temp2;
5872 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5873 }
5874 {
5875 PyThreadState* __tstate = wxPyBeginAllowThreads();
5876 {
5877 wxIcon const &_result_ref = ((wxIconBundle const *)arg1)->GetIcon((wxSize const &)*arg2);
5878 result = (wxIcon *) &_result_ref;
5879 }
5880
5881 wxPyEndAllowThreads(__tstate);
5882 if (PyErr_Occurred()) SWIG_fail;
5883 }
5884 {
5885 wxIcon* resultptr = new wxIcon(*result);
5886 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxIcon, 1);
5887 }
5888 return resultobj;
5889 fail:
5890 return NULL;
5891 }
5892
5893
5894 static PyObject * IconBundle_swigregister(PyObject *, PyObject *args) {
5895 PyObject *obj;
5896 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5897 SWIG_TypeClientData(SWIGTYPE_p_wxIconBundle, obj);
5898 Py_INCREF(obj);
5899 return Py_BuildValue((char *)"");
5900 }
5901 static PyObject *_wrap_new_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
5902 PyObject *resultobj;
5903 wxString *arg1 = 0 ;
5904 long arg2 ;
5905 int arg3 = (int) 0 ;
5906 int arg4 = (int) 0 ;
5907 wxCursor *result;
5908 bool temp1 = false ;
5909 PyObject * obj0 = 0 ;
5910 PyObject * obj1 = 0 ;
5911 PyObject * obj2 = 0 ;
5912 PyObject * obj3 = 0 ;
5913 char *kwnames[] = {
5914 (char *) "cursorName",(char *) "type",(char *) "hotSpotX",(char *) "hotSpotY", NULL
5915 };
5916
5917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Cursor",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5918 {
5919 arg1 = wxString_in_helper(obj0);
5920 if (arg1 == NULL) SWIG_fail;
5921 temp1 = true;
5922 }
5923 {
5924 arg2 = (long)(SWIG_As_long(obj1));
5925 if (SWIG_arg_fail(2)) SWIG_fail;
5926 }
5927 if (obj2) {
5928 {
5929 arg3 = (int)(SWIG_As_int(obj2));
5930 if (SWIG_arg_fail(3)) SWIG_fail;
5931 }
5932 }
5933 if (obj3) {
5934 {
5935 arg4 = (int)(SWIG_As_int(obj3));
5936 if (SWIG_arg_fail(4)) SWIG_fail;
5937 }
5938 }
5939 {
5940 if (!wxPyCheckForApp()) SWIG_fail;
5941 PyThreadState* __tstate = wxPyBeginAllowThreads();
5942 result = (wxCursor *)new_wxCursor((wxString const &)*arg1,arg2,arg3,arg4);
5943
5944 wxPyEndAllowThreads(__tstate);
5945 if (PyErr_Occurred()) SWIG_fail;
5946 }
5947 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
5948 {
5949 if (temp1)
5950 delete arg1;
5951 }
5952 return resultobj;
5953 fail:
5954 {
5955 if (temp1)
5956 delete arg1;
5957 }
5958 return NULL;
5959 }
5960
5961
5962 static PyObject *_wrap_delete_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
5963 PyObject *resultobj;
5964 wxCursor *arg1 = (wxCursor *) 0 ;
5965 PyObject * obj0 = 0 ;
5966 char *kwnames[] = {
5967 (char *) "self", NULL
5968 };
5969
5970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Cursor",kwnames,&obj0)) goto fail;
5971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5972 if (SWIG_arg_fail(1)) SWIG_fail;
5973 {
5974 PyThreadState* __tstate = wxPyBeginAllowThreads();
5975 delete arg1;
5976
5977 wxPyEndAllowThreads(__tstate);
5978 if (PyErr_Occurred()) SWIG_fail;
5979 }
5980 Py_INCREF(Py_None); resultobj = Py_None;
5981 return resultobj;
5982 fail:
5983 return NULL;
5984 }
5985
5986
5987 static PyObject *_wrap_new_StockCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5988 PyObject *resultobj;
5989 int arg1 ;
5990 wxCursor *result;
5991 PyObject * obj0 = 0 ;
5992 char *kwnames[] = {
5993 (char *) "id", NULL
5994 };
5995
5996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_StockCursor",kwnames,&obj0)) goto fail;
5997 {
5998 arg1 = (int)(SWIG_As_int(obj0));
5999 if (SWIG_arg_fail(1)) SWIG_fail;
6000 }
6001 {
6002 if (!wxPyCheckForApp()) SWIG_fail;
6003 PyThreadState* __tstate = wxPyBeginAllowThreads();
6004 result = (wxCursor *)new wxCursor(arg1);
6005
6006 wxPyEndAllowThreads(__tstate);
6007 if (PyErr_Occurred()) SWIG_fail;
6008 }
6009 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6010 return resultobj;
6011 fail:
6012 return NULL;
6013 }
6014
6015
6016 static PyObject *_wrap_new_CursorFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
6017 PyObject *resultobj;
6018 wxImage *arg1 = 0 ;
6019 wxCursor *result;
6020 PyObject * obj0 = 0 ;
6021 char *kwnames[] = {
6022 (char *) "image", NULL
6023 };
6024
6025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CursorFromImage",kwnames,&obj0)) goto fail;
6026 {
6027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
6028 if (SWIG_arg_fail(1)) SWIG_fail;
6029 if (arg1 == NULL) {
6030 SWIG_null_ref("wxImage");
6031 }
6032 if (SWIG_arg_fail(1)) SWIG_fail;
6033 }
6034 {
6035 if (!wxPyCheckForApp()) SWIG_fail;
6036 PyThreadState* __tstate = wxPyBeginAllowThreads();
6037 result = (wxCursor *)new wxCursor((wxImage const &)*arg1);
6038
6039 wxPyEndAllowThreads(__tstate);
6040 if (PyErr_Occurred()) SWIG_fail;
6041 }
6042 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6043 return resultobj;
6044 fail:
6045 return NULL;
6046 }
6047
6048
6049 static PyObject *_wrap_Cursor_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
6050 PyObject *resultobj;
6051 wxCursor *arg1 = (wxCursor *) 0 ;
6052 bool result;
6053 PyObject * obj0 = 0 ;
6054 char *kwnames[] = {
6055 (char *) "self", NULL
6056 };
6057
6058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_Ok",kwnames,&obj0)) goto fail;
6059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6060 if (SWIG_arg_fail(1)) SWIG_fail;
6061 {
6062 PyThreadState* __tstate = wxPyBeginAllowThreads();
6063 result = (bool)(arg1)->Ok();
6064
6065 wxPyEndAllowThreads(__tstate);
6066 if (PyErr_Occurred()) SWIG_fail;
6067 }
6068 {
6069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6070 }
6071 return resultobj;
6072 fail:
6073 return NULL;
6074 }
6075
6076
6077 static PyObject * Cursor_swigregister(PyObject *, PyObject *args) {
6078 PyObject *obj;
6079 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6080 SWIG_TypeClientData(SWIGTYPE_p_wxCursor, obj);
6081 Py_INCREF(obj);
6082 return Py_BuildValue((char *)"");
6083 }
6084 static PyObject *_wrap_new_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6085 PyObject *resultobj;
6086 int arg1 = (int) 0 ;
6087 int arg2 = (int) 0 ;
6088 int arg3 = (int) 0 ;
6089 int arg4 = (int) 0 ;
6090 wxRegion *result;
6091 PyObject * obj0 = 0 ;
6092 PyObject * obj1 = 0 ;
6093 PyObject * obj2 = 0 ;
6094 PyObject * obj3 = 0 ;
6095 char *kwnames[] = {
6096 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6097 };
6098
6099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Region",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6100 if (obj0) {
6101 {
6102 arg1 = (int)(SWIG_As_int(obj0));
6103 if (SWIG_arg_fail(1)) SWIG_fail;
6104 }
6105 }
6106 if (obj1) {
6107 {
6108 arg2 = (int)(SWIG_As_int(obj1));
6109 if (SWIG_arg_fail(2)) SWIG_fail;
6110 }
6111 }
6112 if (obj2) {
6113 {
6114 arg3 = (int)(SWIG_As_int(obj2));
6115 if (SWIG_arg_fail(3)) SWIG_fail;
6116 }
6117 }
6118 if (obj3) {
6119 {
6120 arg4 = (int)(SWIG_As_int(obj3));
6121 if (SWIG_arg_fail(4)) SWIG_fail;
6122 }
6123 }
6124 {
6125 if (!wxPyCheckForApp()) SWIG_fail;
6126 PyThreadState* __tstate = wxPyBeginAllowThreads();
6127 result = (wxRegion *)new wxRegion(arg1,arg2,arg3,arg4);
6128
6129 wxPyEndAllowThreads(__tstate);
6130 if (PyErr_Occurred()) SWIG_fail;
6131 }
6132 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6133 return resultobj;
6134 fail:
6135 return NULL;
6136 }
6137
6138
6139 static PyObject *_wrap_new_RegionFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
6140 PyObject *resultobj;
6141 wxBitmap *arg1 = 0 ;
6142 wxRegion *result;
6143 PyObject * obj0 = 0 ;
6144 char *kwnames[] = {
6145 (char *) "bmp", NULL
6146 };
6147
6148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionFromBitmap",kwnames,&obj0)) goto fail;
6149 {
6150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6151 if (SWIG_arg_fail(1)) SWIG_fail;
6152 if (arg1 == NULL) {
6153 SWIG_null_ref("wxBitmap");
6154 }
6155 if (SWIG_arg_fail(1)) SWIG_fail;
6156 }
6157 {
6158 if (!wxPyCheckForApp()) SWIG_fail;
6159 PyThreadState* __tstate = wxPyBeginAllowThreads();
6160 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1);
6161
6162 wxPyEndAllowThreads(__tstate);
6163 if (PyErr_Occurred()) SWIG_fail;
6164 }
6165 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6166 return resultobj;
6167 fail:
6168 return NULL;
6169 }
6170
6171
6172 static PyObject *_wrap_new_RegionFromBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
6173 PyObject *resultobj;
6174 wxBitmap *arg1 = 0 ;
6175 wxColour *arg2 = 0 ;
6176 int arg3 = (int) 0 ;
6177 wxRegion *result;
6178 wxColour temp2 ;
6179 PyObject * obj0 = 0 ;
6180 PyObject * obj1 = 0 ;
6181 PyObject * obj2 = 0 ;
6182 char *kwnames[] = {
6183 (char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
6184 };
6185
6186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_RegionFromBitmapColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
6187 {
6188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6189 if (SWIG_arg_fail(1)) SWIG_fail;
6190 if (arg1 == NULL) {
6191 SWIG_null_ref("wxBitmap");
6192 }
6193 if (SWIG_arg_fail(1)) SWIG_fail;
6194 }
6195 {
6196 arg2 = &temp2;
6197 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6198 }
6199 if (obj2) {
6200 {
6201 arg3 = (int)(SWIG_As_int(obj2));
6202 if (SWIG_arg_fail(3)) SWIG_fail;
6203 }
6204 }
6205 {
6206 if (!wxPyCheckForApp()) SWIG_fail;
6207 PyThreadState* __tstate = wxPyBeginAllowThreads();
6208 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1,(wxColour const &)*arg2,arg3);
6209
6210 wxPyEndAllowThreads(__tstate);
6211 if (PyErr_Occurred()) SWIG_fail;
6212 }
6213 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6214 return resultobj;
6215 fail:
6216 return NULL;
6217 }
6218
6219
6220 static PyObject *_wrap_new_RegionFromPoints(PyObject *, PyObject *args, PyObject *kwargs) {
6221 PyObject *resultobj;
6222 int arg1 ;
6223 wxPoint *arg2 = (wxPoint *) 0 ;
6224 int arg3 = (int) wxWINDING_RULE ;
6225 wxRegion *result;
6226 PyObject * obj0 = 0 ;
6227 PyObject * obj1 = 0 ;
6228 char *kwnames[] = {
6229 (char *) "points",(char *) "fillStyle", NULL
6230 };
6231
6232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_RegionFromPoints",kwnames,&obj0,&obj1)) goto fail;
6233 {
6234 arg2 = wxPoint_LIST_helper(obj0, &arg1);
6235 if (arg2 == NULL) SWIG_fail;
6236 }
6237 if (obj1) {
6238 {
6239 arg3 = (int)(SWIG_As_int(obj1));
6240 if (SWIG_arg_fail(3)) SWIG_fail;
6241 }
6242 }
6243 {
6244 if (!wxPyCheckForApp()) SWIG_fail;
6245 PyThreadState* __tstate = wxPyBeginAllowThreads();
6246 result = (wxRegion *)new wxRegion(arg1,arg2,arg3);
6247
6248 wxPyEndAllowThreads(__tstate);
6249 if (PyErr_Occurred()) SWIG_fail;
6250 }
6251 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6252 {
6253 if (arg2) delete [] arg2;
6254 }
6255 return resultobj;
6256 fail:
6257 {
6258 if (arg2) delete [] arg2;
6259 }
6260 return NULL;
6261 }
6262
6263
6264 static PyObject *_wrap_delete_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6265 PyObject *resultobj;
6266 wxRegion *arg1 = (wxRegion *) 0 ;
6267 PyObject * obj0 = 0 ;
6268 char *kwnames[] = {
6269 (char *) "self", NULL
6270 };
6271
6272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Region",kwnames,&obj0)) goto fail;
6273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6274 if (SWIG_arg_fail(1)) SWIG_fail;
6275 {
6276 PyThreadState* __tstate = wxPyBeginAllowThreads();
6277 delete arg1;
6278
6279 wxPyEndAllowThreads(__tstate);
6280 if (PyErr_Occurred()) SWIG_fail;
6281 }
6282 Py_INCREF(Py_None); resultobj = Py_None;
6283 return resultobj;
6284 fail:
6285 return NULL;
6286 }
6287
6288
6289 static PyObject *_wrap_Region_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
6290 PyObject *resultobj;
6291 wxRegion *arg1 = (wxRegion *) 0 ;
6292 PyObject * obj0 = 0 ;
6293 char *kwnames[] = {
6294 (char *) "self", NULL
6295 };
6296
6297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_Clear",kwnames,&obj0)) goto fail;
6298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6299 if (SWIG_arg_fail(1)) SWIG_fail;
6300 {
6301 PyThreadState* __tstate = wxPyBeginAllowThreads();
6302 (arg1)->Clear();
6303
6304 wxPyEndAllowThreads(__tstate);
6305 if (PyErr_Occurred()) SWIG_fail;
6306 }
6307 Py_INCREF(Py_None); resultobj = Py_None;
6308 return resultobj;
6309 fail:
6310 return NULL;
6311 }
6312
6313
6314 static PyObject *_wrap_Region_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
6315 PyObject *resultobj;
6316 wxRegion *arg1 = (wxRegion *) 0 ;
6317 int arg2 ;
6318 int arg3 ;
6319 bool result;
6320 PyObject * obj0 = 0 ;
6321 PyObject * obj1 = 0 ;
6322 PyObject * obj2 = 0 ;
6323 char *kwnames[] = {
6324 (char *) "self",(char *) "x",(char *) "y", NULL
6325 };
6326
6327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Offset",kwnames,&obj0,&obj1,&obj2)) goto fail;
6328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6329 if (SWIG_arg_fail(1)) SWIG_fail;
6330 {
6331 arg2 = (int)(SWIG_As_int(obj1));
6332 if (SWIG_arg_fail(2)) SWIG_fail;
6333 }
6334 {
6335 arg3 = (int)(SWIG_As_int(obj2));
6336 if (SWIG_arg_fail(3)) SWIG_fail;
6337 }
6338 {
6339 PyThreadState* __tstate = wxPyBeginAllowThreads();
6340 result = (bool)(arg1)->Offset(arg2,arg3);
6341
6342 wxPyEndAllowThreads(__tstate);
6343 if (PyErr_Occurred()) SWIG_fail;
6344 }
6345 {
6346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6347 }
6348 return resultobj;
6349 fail:
6350 return NULL;
6351 }
6352
6353
6354 static PyObject *_wrap_Region_Contains(PyObject *, PyObject *args, PyObject *kwargs) {
6355 PyObject *resultobj;
6356 wxRegion *arg1 = (wxRegion *) 0 ;
6357 int arg2 ;
6358 int arg3 ;
6359 wxRegionContain result;
6360 PyObject * obj0 = 0 ;
6361 PyObject * obj1 = 0 ;
6362 PyObject * obj2 = 0 ;
6363 char *kwnames[] = {
6364 (char *) "self",(char *) "x",(char *) "y", NULL
6365 };
6366
6367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Contains",kwnames,&obj0,&obj1,&obj2)) goto fail;
6368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6369 if (SWIG_arg_fail(1)) SWIG_fail;
6370 {
6371 arg2 = (int)(SWIG_As_int(obj1));
6372 if (SWIG_arg_fail(2)) SWIG_fail;
6373 }
6374 {
6375 arg3 = (int)(SWIG_As_int(obj2));
6376 if (SWIG_arg_fail(3)) SWIG_fail;
6377 }
6378 {
6379 PyThreadState* __tstate = wxPyBeginAllowThreads();
6380 result = (wxRegionContain)(arg1)->Contains(arg2,arg3);
6381
6382 wxPyEndAllowThreads(__tstate);
6383 if (PyErr_Occurred()) SWIG_fail;
6384 }
6385 resultobj = SWIG_From_int((result));
6386 return resultobj;
6387 fail:
6388 return NULL;
6389 }
6390
6391
6392 static PyObject *_wrap_Region_ContainsPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6393 PyObject *resultobj;
6394 wxRegion *arg1 = (wxRegion *) 0 ;
6395 wxPoint *arg2 = 0 ;
6396 wxRegionContain result;
6397 wxPoint temp2 ;
6398 PyObject * obj0 = 0 ;
6399 PyObject * obj1 = 0 ;
6400 char *kwnames[] = {
6401 (char *) "self",(char *) "pt", NULL
6402 };
6403
6404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsPoint",kwnames,&obj0,&obj1)) goto fail;
6405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6406 if (SWIG_arg_fail(1)) SWIG_fail;
6407 {
6408 arg2 = &temp2;
6409 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6410 }
6411 {
6412 PyThreadState* __tstate = wxPyBeginAllowThreads();
6413 result = (wxRegionContain)(arg1)->Contains((wxPoint const &)*arg2);
6414
6415 wxPyEndAllowThreads(__tstate);
6416 if (PyErr_Occurred()) SWIG_fail;
6417 }
6418 resultobj = SWIG_From_int((result));
6419 return resultobj;
6420 fail:
6421 return NULL;
6422 }
6423
6424
6425 static PyObject *_wrap_Region_ContainsRect(PyObject *, PyObject *args, PyObject *kwargs) {
6426 PyObject *resultobj;
6427 wxRegion *arg1 = (wxRegion *) 0 ;
6428 wxRect *arg2 = 0 ;
6429 wxRegionContain result;
6430 wxRect temp2 ;
6431 PyObject * obj0 = 0 ;
6432 PyObject * obj1 = 0 ;
6433 char *kwnames[] = {
6434 (char *) "self",(char *) "rect", NULL
6435 };
6436
6437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsRect",kwnames,&obj0,&obj1)) goto fail;
6438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6439 if (SWIG_arg_fail(1)) SWIG_fail;
6440 {
6441 arg2 = &temp2;
6442 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6443 }
6444 {
6445 PyThreadState* __tstate = wxPyBeginAllowThreads();
6446 result = (wxRegionContain)(arg1)->Contains((wxRect const &)*arg2);
6447
6448 wxPyEndAllowThreads(__tstate);
6449 if (PyErr_Occurred()) SWIG_fail;
6450 }
6451 resultobj = SWIG_From_int((result));
6452 return resultobj;
6453 fail:
6454 return NULL;
6455 }
6456
6457
6458 static PyObject *_wrap_Region_ContainsRectDim(PyObject *, PyObject *args, PyObject *kwargs) {
6459 PyObject *resultobj;
6460 wxRegion *arg1 = (wxRegion *) 0 ;
6461 int arg2 ;
6462 int arg3 ;
6463 int arg4 ;
6464 int arg5 ;
6465 wxRegionContain result;
6466 PyObject * obj0 = 0 ;
6467 PyObject * obj1 = 0 ;
6468 PyObject * obj2 = 0 ;
6469 PyObject * obj3 = 0 ;
6470 PyObject * obj4 = 0 ;
6471 char *kwnames[] = {
6472 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
6473 };
6474
6475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_ContainsRectDim",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6477 if (SWIG_arg_fail(1)) SWIG_fail;
6478 {
6479 arg2 = (int)(SWIG_As_int(obj1));
6480 if (SWIG_arg_fail(2)) SWIG_fail;
6481 }
6482 {
6483 arg3 = (int)(SWIG_As_int(obj2));
6484 if (SWIG_arg_fail(3)) SWIG_fail;
6485 }
6486 {
6487 arg4 = (int)(SWIG_As_int(obj3));
6488 if (SWIG_arg_fail(4)) SWIG_fail;
6489 }
6490 {
6491 arg5 = (int)(SWIG_As_int(obj4));
6492 if (SWIG_arg_fail(5)) SWIG_fail;
6493 }
6494 {
6495 PyThreadState* __tstate = wxPyBeginAllowThreads();
6496 result = (wxRegionContain)(arg1)->Contains(arg2,arg3,arg4,arg5);
6497
6498 wxPyEndAllowThreads(__tstate);
6499 if (PyErr_Occurred()) SWIG_fail;
6500 }
6501 resultobj = SWIG_From_int((result));
6502 return resultobj;
6503 fail:
6504 return NULL;
6505 }
6506
6507
6508 static PyObject *_wrap_Region_GetBox(PyObject *, PyObject *args, PyObject *kwargs) {
6509 PyObject *resultobj;
6510 wxRegion *arg1 = (wxRegion *) 0 ;
6511 wxRect result;
6512 PyObject * obj0 = 0 ;
6513 char *kwnames[] = {
6514 (char *) "self", NULL
6515 };
6516
6517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_GetBox",kwnames,&obj0)) goto fail;
6518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6519 if (SWIG_arg_fail(1)) SWIG_fail;
6520 {
6521 PyThreadState* __tstate = wxPyBeginAllowThreads();
6522 result = (arg1)->GetBox();
6523
6524 wxPyEndAllowThreads(__tstate);
6525 if (PyErr_Occurred()) SWIG_fail;
6526 }
6527 {
6528 wxRect * resultptr;
6529 resultptr = new wxRect((wxRect &)(result));
6530 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6531 }
6532 return resultobj;
6533 fail:
6534 return NULL;
6535 }
6536
6537
6538 static PyObject *_wrap_Region_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
6539 PyObject *resultobj;
6540 wxRegion *arg1 = (wxRegion *) 0 ;
6541 int arg2 ;
6542 int arg3 ;
6543 int arg4 ;
6544 int arg5 ;
6545 bool result;
6546 PyObject * obj0 = 0 ;
6547 PyObject * obj1 = 0 ;
6548 PyObject * obj2 = 0 ;
6549 PyObject * obj3 = 0 ;
6550 PyObject * obj4 = 0 ;
6551 char *kwnames[] = {
6552 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6553 };
6554
6555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Intersect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6557 if (SWIG_arg_fail(1)) SWIG_fail;
6558 {
6559 arg2 = (int)(SWIG_As_int(obj1));
6560 if (SWIG_arg_fail(2)) SWIG_fail;
6561 }
6562 {
6563 arg3 = (int)(SWIG_As_int(obj2));
6564 if (SWIG_arg_fail(3)) SWIG_fail;
6565 }
6566 {
6567 arg4 = (int)(SWIG_As_int(obj3));
6568 if (SWIG_arg_fail(4)) SWIG_fail;
6569 }
6570 {
6571 arg5 = (int)(SWIG_As_int(obj4));
6572 if (SWIG_arg_fail(5)) SWIG_fail;
6573 }
6574 {
6575 PyThreadState* __tstate = wxPyBeginAllowThreads();
6576 result = (bool)(arg1)->Intersect(arg2,arg3,arg4,arg5);
6577
6578 wxPyEndAllowThreads(__tstate);
6579 if (PyErr_Occurred()) SWIG_fail;
6580 }
6581 {
6582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6583 }
6584 return resultobj;
6585 fail:
6586 return NULL;
6587 }
6588
6589
6590 static PyObject *_wrap_Region_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6591 PyObject *resultobj;
6592 wxRegion *arg1 = (wxRegion *) 0 ;
6593 wxRect *arg2 = 0 ;
6594 bool result;
6595 wxRect temp2 ;
6596 PyObject * obj0 = 0 ;
6597 PyObject * obj1 = 0 ;
6598 char *kwnames[] = {
6599 (char *) "self",(char *) "rect", NULL
6600 };
6601
6602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6604 if (SWIG_arg_fail(1)) SWIG_fail;
6605 {
6606 arg2 = &temp2;
6607 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6608 }
6609 {
6610 PyThreadState* __tstate = wxPyBeginAllowThreads();
6611 result = (bool)(arg1)->Intersect((wxRect const &)*arg2);
6612
6613 wxPyEndAllowThreads(__tstate);
6614 if (PyErr_Occurred()) SWIG_fail;
6615 }
6616 {
6617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6618 }
6619 return resultobj;
6620 fail:
6621 return NULL;
6622 }
6623
6624
6625 static PyObject *_wrap_Region_IntersectRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6626 PyObject *resultobj;
6627 wxRegion *arg1 = (wxRegion *) 0 ;
6628 wxRegion *arg2 = 0 ;
6629 bool result;
6630 PyObject * obj0 = 0 ;
6631 PyObject * obj1 = 0 ;
6632 char *kwnames[] = {
6633 (char *) "self",(char *) "region", NULL
6634 };
6635
6636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRegion",kwnames,&obj0,&obj1)) goto fail;
6637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6638 if (SWIG_arg_fail(1)) SWIG_fail;
6639 {
6640 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6641 if (SWIG_arg_fail(2)) SWIG_fail;
6642 if (arg2 == NULL) {
6643 SWIG_null_ref("wxRegion");
6644 }
6645 if (SWIG_arg_fail(2)) SWIG_fail;
6646 }
6647 {
6648 PyThreadState* __tstate = wxPyBeginAllowThreads();
6649 result = (bool)(arg1)->Intersect((wxRegion const &)*arg2);
6650
6651 wxPyEndAllowThreads(__tstate);
6652 if (PyErr_Occurred()) SWIG_fail;
6653 }
6654 {
6655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6656 }
6657 return resultobj;
6658 fail:
6659 return NULL;
6660 }
6661
6662
6663 static PyObject *_wrap_Region_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
6664 PyObject *resultobj;
6665 wxRegion *arg1 = (wxRegion *) 0 ;
6666 bool result;
6667 PyObject * obj0 = 0 ;
6668 char *kwnames[] = {
6669 (char *) "self", NULL
6670 };
6671
6672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_IsEmpty",kwnames,&obj0)) goto fail;
6673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6674 if (SWIG_arg_fail(1)) SWIG_fail;
6675 {
6676 PyThreadState* __tstate = wxPyBeginAllowThreads();
6677 result = (bool)(arg1)->IsEmpty();
6678
6679 wxPyEndAllowThreads(__tstate);
6680 if (PyErr_Occurred()) SWIG_fail;
6681 }
6682 {
6683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6684 }
6685 return resultobj;
6686 fail:
6687 return NULL;
6688 }
6689
6690
6691 static PyObject *_wrap_Region_Union(PyObject *, PyObject *args, PyObject *kwargs) {
6692 PyObject *resultobj;
6693 wxRegion *arg1 = (wxRegion *) 0 ;
6694 int arg2 ;
6695 int arg3 ;
6696 int arg4 ;
6697 int arg5 ;
6698 bool result;
6699 PyObject * obj0 = 0 ;
6700 PyObject * obj1 = 0 ;
6701 PyObject * obj2 = 0 ;
6702 PyObject * obj3 = 0 ;
6703 PyObject * obj4 = 0 ;
6704 char *kwnames[] = {
6705 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6706 };
6707
6708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Union",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6710 if (SWIG_arg_fail(1)) SWIG_fail;
6711 {
6712 arg2 = (int)(SWIG_As_int(obj1));
6713 if (SWIG_arg_fail(2)) SWIG_fail;
6714 }
6715 {
6716 arg3 = (int)(SWIG_As_int(obj2));
6717 if (SWIG_arg_fail(3)) SWIG_fail;
6718 }
6719 {
6720 arg4 = (int)(SWIG_As_int(obj3));
6721 if (SWIG_arg_fail(4)) SWIG_fail;
6722 }
6723 {
6724 arg5 = (int)(SWIG_As_int(obj4));
6725 if (SWIG_arg_fail(5)) SWIG_fail;
6726 }
6727 {
6728 PyThreadState* __tstate = wxPyBeginAllowThreads();
6729 result = (bool)(arg1)->Union(arg2,arg3,arg4,arg5);
6730
6731 wxPyEndAllowThreads(__tstate);
6732 if (PyErr_Occurred()) SWIG_fail;
6733 }
6734 {
6735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6736 }
6737 return resultobj;
6738 fail:
6739 return NULL;
6740 }
6741
6742
6743 static PyObject *_wrap_Region_UnionRect(PyObject *, PyObject *args, PyObject *kwargs) {
6744 PyObject *resultobj;
6745 wxRegion *arg1 = (wxRegion *) 0 ;
6746 wxRect *arg2 = 0 ;
6747 bool result;
6748 wxRect temp2 ;
6749 PyObject * obj0 = 0 ;
6750 PyObject * obj1 = 0 ;
6751 char *kwnames[] = {
6752 (char *) "self",(char *) "rect", NULL
6753 };
6754
6755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRect",kwnames,&obj0,&obj1)) goto fail;
6756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6757 if (SWIG_arg_fail(1)) SWIG_fail;
6758 {
6759 arg2 = &temp2;
6760 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6761 }
6762 {
6763 PyThreadState* __tstate = wxPyBeginAllowThreads();
6764 result = (bool)(arg1)->Union((wxRect const &)*arg2);
6765
6766 wxPyEndAllowThreads(__tstate);
6767 if (PyErr_Occurred()) SWIG_fail;
6768 }
6769 {
6770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6771 }
6772 return resultobj;
6773 fail:
6774 return NULL;
6775 }
6776
6777
6778 static PyObject *_wrap_Region_UnionRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6779 PyObject *resultobj;
6780 wxRegion *arg1 = (wxRegion *) 0 ;
6781 wxRegion *arg2 = 0 ;
6782 bool result;
6783 PyObject * obj0 = 0 ;
6784 PyObject * obj1 = 0 ;
6785 char *kwnames[] = {
6786 (char *) "self",(char *) "region", NULL
6787 };
6788
6789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRegion",kwnames,&obj0,&obj1)) goto fail;
6790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6791 if (SWIG_arg_fail(1)) SWIG_fail;
6792 {
6793 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6794 if (SWIG_arg_fail(2)) SWIG_fail;
6795 if (arg2 == NULL) {
6796 SWIG_null_ref("wxRegion");
6797 }
6798 if (SWIG_arg_fail(2)) SWIG_fail;
6799 }
6800 {
6801 PyThreadState* __tstate = wxPyBeginAllowThreads();
6802 result = (bool)(arg1)->Union((wxRegion const &)*arg2);
6803
6804 wxPyEndAllowThreads(__tstate);
6805 if (PyErr_Occurred()) SWIG_fail;
6806 }
6807 {
6808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6809 }
6810 return resultobj;
6811 fail:
6812 return NULL;
6813 }
6814
6815
6816 static PyObject *_wrap_Region_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
6817 PyObject *resultobj;
6818 wxRegion *arg1 = (wxRegion *) 0 ;
6819 int arg2 ;
6820 int arg3 ;
6821 int arg4 ;
6822 int arg5 ;
6823 bool result;
6824 PyObject * obj0 = 0 ;
6825 PyObject * obj1 = 0 ;
6826 PyObject * obj2 = 0 ;
6827 PyObject * obj3 = 0 ;
6828 PyObject * obj4 = 0 ;
6829 char *kwnames[] = {
6830 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6831 };
6832
6833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Subtract",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6835 if (SWIG_arg_fail(1)) SWIG_fail;
6836 {
6837 arg2 = (int)(SWIG_As_int(obj1));
6838 if (SWIG_arg_fail(2)) SWIG_fail;
6839 }
6840 {
6841 arg3 = (int)(SWIG_As_int(obj2));
6842 if (SWIG_arg_fail(3)) SWIG_fail;
6843 }
6844 {
6845 arg4 = (int)(SWIG_As_int(obj3));
6846 if (SWIG_arg_fail(4)) SWIG_fail;
6847 }
6848 {
6849 arg5 = (int)(SWIG_As_int(obj4));
6850 if (SWIG_arg_fail(5)) SWIG_fail;
6851 }
6852 {
6853 PyThreadState* __tstate = wxPyBeginAllowThreads();
6854 result = (bool)(arg1)->Subtract(arg2,arg3,arg4,arg5);
6855
6856 wxPyEndAllowThreads(__tstate);
6857 if (PyErr_Occurred()) SWIG_fail;
6858 }
6859 {
6860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6861 }
6862 return resultobj;
6863 fail:
6864 return NULL;
6865 }
6866
6867
6868 static PyObject *_wrap_Region_SubtractRect(PyObject *, PyObject *args, PyObject *kwargs) {
6869 PyObject *resultobj;
6870 wxRegion *arg1 = (wxRegion *) 0 ;
6871 wxRect *arg2 = 0 ;
6872 bool result;
6873 wxRect temp2 ;
6874 PyObject * obj0 = 0 ;
6875 PyObject * obj1 = 0 ;
6876 char *kwnames[] = {
6877 (char *) "self",(char *) "rect", NULL
6878 };
6879
6880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRect",kwnames,&obj0,&obj1)) goto fail;
6881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6882 if (SWIG_arg_fail(1)) SWIG_fail;
6883 {
6884 arg2 = &temp2;
6885 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6886 }
6887 {
6888 PyThreadState* __tstate = wxPyBeginAllowThreads();
6889 result = (bool)(arg1)->Subtract((wxRect const &)*arg2);
6890
6891 wxPyEndAllowThreads(__tstate);
6892 if (PyErr_Occurred()) SWIG_fail;
6893 }
6894 {
6895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6896 }
6897 return resultobj;
6898 fail:
6899 return NULL;
6900 }
6901
6902
6903 static PyObject *_wrap_Region_SubtractRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6904 PyObject *resultobj;
6905 wxRegion *arg1 = (wxRegion *) 0 ;
6906 wxRegion *arg2 = 0 ;
6907 bool result;
6908 PyObject * obj0 = 0 ;
6909 PyObject * obj1 = 0 ;
6910 char *kwnames[] = {
6911 (char *) "self",(char *) "region", NULL
6912 };
6913
6914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRegion",kwnames,&obj0,&obj1)) goto fail;
6915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6916 if (SWIG_arg_fail(1)) SWIG_fail;
6917 {
6918 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6919 if (SWIG_arg_fail(2)) SWIG_fail;
6920 if (arg2 == NULL) {
6921 SWIG_null_ref("wxRegion");
6922 }
6923 if (SWIG_arg_fail(2)) SWIG_fail;
6924 }
6925 {
6926 PyThreadState* __tstate = wxPyBeginAllowThreads();
6927 result = (bool)(arg1)->Subtract((wxRegion const &)*arg2);
6928
6929 wxPyEndAllowThreads(__tstate);
6930 if (PyErr_Occurred()) SWIG_fail;
6931 }
6932 {
6933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6934 }
6935 return resultobj;
6936 fail:
6937 return NULL;
6938 }
6939
6940
6941 static PyObject *_wrap_Region_Xor(PyObject *, PyObject *args, PyObject *kwargs) {
6942 PyObject *resultobj;
6943 wxRegion *arg1 = (wxRegion *) 0 ;
6944 int arg2 ;
6945 int arg3 ;
6946 int arg4 ;
6947 int arg5 ;
6948 bool result;
6949 PyObject * obj0 = 0 ;
6950 PyObject * obj1 = 0 ;
6951 PyObject * obj2 = 0 ;
6952 PyObject * obj3 = 0 ;
6953 PyObject * obj4 = 0 ;
6954 char *kwnames[] = {
6955 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6956 };
6957
6958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Xor",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6960 if (SWIG_arg_fail(1)) SWIG_fail;
6961 {
6962 arg2 = (int)(SWIG_As_int(obj1));
6963 if (SWIG_arg_fail(2)) SWIG_fail;
6964 }
6965 {
6966 arg3 = (int)(SWIG_As_int(obj2));
6967 if (SWIG_arg_fail(3)) SWIG_fail;
6968 }
6969 {
6970 arg4 = (int)(SWIG_As_int(obj3));
6971 if (SWIG_arg_fail(4)) SWIG_fail;
6972 }
6973 {
6974 arg5 = (int)(SWIG_As_int(obj4));
6975 if (SWIG_arg_fail(5)) SWIG_fail;
6976 }
6977 {
6978 PyThreadState* __tstate = wxPyBeginAllowThreads();
6979 result = (bool)(arg1)->Xor(arg2,arg3,arg4,arg5);
6980
6981 wxPyEndAllowThreads(__tstate);
6982 if (PyErr_Occurred()) SWIG_fail;
6983 }
6984 {
6985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6986 }
6987 return resultobj;
6988 fail:
6989 return NULL;
6990 }
6991
6992
6993 static PyObject *_wrap_Region_XorRect(PyObject *, PyObject *args, PyObject *kwargs) {
6994 PyObject *resultobj;
6995 wxRegion *arg1 = (wxRegion *) 0 ;
6996 wxRect *arg2 = 0 ;
6997 bool result;
6998 wxRect temp2 ;
6999 PyObject * obj0 = 0 ;
7000 PyObject * obj1 = 0 ;
7001 char *kwnames[] = {
7002 (char *) "self",(char *) "rect", NULL
7003 };
7004
7005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRect",kwnames,&obj0,&obj1)) goto fail;
7006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7007 if (SWIG_arg_fail(1)) SWIG_fail;
7008 {
7009 arg2 = &temp2;
7010 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7011 }
7012 {
7013 PyThreadState* __tstate = wxPyBeginAllowThreads();
7014 result = (bool)(arg1)->Xor((wxRect const &)*arg2);
7015
7016 wxPyEndAllowThreads(__tstate);
7017 if (PyErr_Occurred()) SWIG_fail;
7018 }
7019 {
7020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7021 }
7022 return resultobj;
7023 fail:
7024 return NULL;
7025 }
7026
7027
7028 static PyObject *_wrap_Region_XorRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7029 PyObject *resultobj;
7030 wxRegion *arg1 = (wxRegion *) 0 ;
7031 wxRegion *arg2 = 0 ;
7032 bool result;
7033 PyObject * obj0 = 0 ;
7034 PyObject * obj1 = 0 ;
7035 char *kwnames[] = {
7036 (char *) "self",(char *) "region", NULL
7037 };
7038
7039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRegion",kwnames,&obj0,&obj1)) goto fail;
7040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7041 if (SWIG_arg_fail(1)) SWIG_fail;
7042 {
7043 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7044 if (SWIG_arg_fail(2)) SWIG_fail;
7045 if (arg2 == NULL) {
7046 SWIG_null_ref("wxRegion");
7047 }
7048 if (SWIG_arg_fail(2)) SWIG_fail;
7049 }
7050 {
7051 PyThreadState* __tstate = wxPyBeginAllowThreads();
7052 result = (bool)(arg1)->Xor((wxRegion const &)*arg2);
7053
7054 wxPyEndAllowThreads(__tstate);
7055 if (PyErr_Occurred()) SWIG_fail;
7056 }
7057 {
7058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7059 }
7060 return resultobj;
7061 fail:
7062 return NULL;
7063 }
7064
7065
7066 static PyObject *_wrap_Region_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7067 PyObject *resultobj;
7068 wxRegion *arg1 = (wxRegion *) 0 ;
7069 SwigValueWrapper<wxBitmap > result;
7070 PyObject * obj0 = 0 ;
7071 char *kwnames[] = {
7072 (char *) "self", NULL
7073 };
7074
7075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_ConvertToBitmap",kwnames,&obj0)) goto fail;
7076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7077 if (SWIG_arg_fail(1)) SWIG_fail;
7078 {
7079 PyThreadState* __tstate = wxPyBeginAllowThreads();
7080 result = (arg1)->ConvertToBitmap();
7081
7082 wxPyEndAllowThreads(__tstate);
7083 if (PyErr_Occurred()) SWIG_fail;
7084 }
7085 {
7086 wxBitmap * resultptr;
7087 resultptr = new wxBitmap((wxBitmap &)(result));
7088 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
7089 }
7090 return resultobj;
7091 fail:
7092 return NULL;
7093 }
7094
7095
7096 static PyObject *_wrap_Region_UnionBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7097 PyObject *resultobj;
7098 wxRegion *arg1 = (wxRegion *) 0 ;
7099 wxBitmap *arg2 = 0 ;
7100 bool result;
7101 PyObject * obj0 = 0 ;
7102 PyObject * obj1 = 0 ;
7103 char *kwnames[] = {
7104 (char *) "self",(char *) "bmp", NULL
7105 };
7106
7107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionBitmap",kwnames,&obj0,&obj1)) goto fail;
7108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7109 if (SWIG_arg_fail(1)) SWIG_fail;
7110 {
7111 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7112 if (SWIG_arg_fail(2)) SWIG_fail;
7113 if (arg2 == NULL) {
7114 SWIG_null_ref("wxBitmap");
7115 }
7116 if (SWIG_arg_fail(2)) SWIG_fail;
7117 }
7118 {
7119 PyThreadState* __tstate = wxPyBeginAllowThreads();
7120 result = (bool)(arg1)->Union((wxBitmap const &)*arg2);
7121
7122 wxPyEndAllowThreads(__tstate);
7123 if (PyErr_Occurred()) SWIG_fail;
7124 }
7125 {
7126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7127 }
7128 return resultobj;
7129 fail:
7130 return NULL;
7131 }
7132
7133
7134 static PyObject *_wrap_Region_UnionBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
7135 PyObject *resultobj;
7136 wxRegion *arg1 = (wxRegion *) 0 ;
7137 wxBitmap *arg2 = 0 ;
7138 wxColour *arg3 = 0 ;
7139 int arg4 = (int) 0 ;
7140 bool result;
7141 wxColour temp3 ;
7142 PyObject * obj0 = 0 ;
7143 PyObject * obj1 = 0 ;
7144 PyObject * obj2 = 0 ;
7145 PyObject * obj3 = 0 ;
7146 char *kwnames[] = {
7147 (char *) "self",(char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
7148 };
7149
7150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Region_UnionBitmapColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7152 if (SWIG_arg_fail(1)) SWIG_fail;
7153 {
7154 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7155 if (SWIG_arg_fail(2)) SWIG_fail;
7156 if (arg2 == NULL) {
7157 SWIG_null_ref("wxBitmap");
7158 }
7159 if (SWIG_arg_fail(2)) SWIG_fail;
7160 }
7161 {
7162 arg3 = &temp3;
7163 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
7164 }
7165 if (obj3) {
7166 {
7167 arg4 = (int)(SWIG_As_int(obj3));
7168 if (SWIG_arg_fail(4)) SWIG_fail;
7169 }
7170 }
7171 {
7172 PyThreadState* __tstate = wxPyBeginAllowThreads();
7173 result = (bool)(arg1)->Union((wxBitmap const &)*arg2,(wxColour const &)*arg3,arg4);
7174
7175 wxPyEndAllowThreads(__tstate);
7176 if (PyErr_Occurred()) SWIG_fail;
7177 }
7178 {
7179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7180 }
7181 return resultobj;
7182 fail:
7183 return NULL;
7184 }
7185
7186
7187 static PyObject * Region_swigregister(PyObject *, PyObject *args) {
7188 PyObject *obj;
7189 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7190 SWIG_TypeClientData(SWIGTYPE_p_wxRegion, obj);
7191 Py_INCREF(obj);
7192 return Py_BuildValue((char *)"");
7193 }
7194 static PyObject *_wrap_new_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7195 PyObject *resultobj;
7196 wxRegion *arg1 = 0 ;
7197 wxRegionIterator *result;
7198 PyObject * obj0 = 0 ;
7199 char *kwnames[] = {
7200 (char *) "region", NULL
7201 };
7202
7203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionIterator",kwnames,&obj0)) goto fail;
7204 {
7205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7206 if (SWIG_arg_fail(1)) SWIG_fail;
7207 if (arg1 == NULL) {
7208 SWIG_null_ref("wxRegion");
7209 }
7210 if (SWIG_arg_fail(1)) SWIG_fail;
7211 }
7212 {
7213 if (!wxPyCheckForApp()) SWIG_fail;
7214 PyThreadState* __tstate = wxPyBeginAllowThreads();
7215 result = (wxRegionIterator *)new wxRegionIterator((wxRegion const &)*arg1);
7216
7217 wxPyEndAllowThreads(__tstate);
7218 if (PyErr_Occurred()) SWIG_fail;
7219 }
7220 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegionIterator, 1);
7221 return resultobj;
7222 fail:
7223 return NULL;
7224 }
7225
7226
7227 static PyObject *_wrap_delete_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7228 PyObject *resultobj;
7229 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7230 PyObject * obj0 = 0 ;
7231 char *kwnames[] = {
7232 (char *) "self", NULL
7233 };
7234
7235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RegionIterator",kwnames,&obj0)) goto fail;
7236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7237 if (SWIG_arg_fail(1)) SWIG_fail;
7238 {
7239 PyThreadState* __tstate = wxPyBeginAllowThreads();
7240 delete arg1;
7241
7242 wxPyEndAllowThreads(__tstate);
7243 if (PyErr_Occurred()) SWIG_fail;
7244 }
7245 Py_INCREF(Py_None); resultobj = Py_None;
7246 return resultobj;
7247 fail:
7248 return NULL;
7249 }
7250
7251
7252 static PyObject *_wrap_RegionIterator_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
7253 PyObject *resultobj;
7254 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7255 int result;
7256 PyObject * obj0 = 0 ;
7257 char *kwnames[] = {
7258 (char *) "self", NULL
7259 };
7260
7261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetX",kwnames,&obj0)) goto fail;
7262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7263 if (SWIG_arg_fail(1)) SWIG_fail;
7264 {
7265 PyThreadState* __tstate = wxPyBeginAllowThreads();
7266 result = (int)(arg1)->GetX();
7267
7268 wxPyEndAllowThreads(__tstate);
7269 if (PyErr_Occurred()) SWIG_fail;
7270 }
7271 {
7272 resultobj = SWIG_From_int((int)(result));
7273 }
7274 return resultobj;
7275 fail:
7276 return NULL;
7277 }
7278
7279
7280 static PyObject *_wrap_RegionIterator_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
7281 PyObject *resultobj;
7282 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7283 int result;
7284 PyObject * obj0 = 0 ;
7285 char *kwnames[] = {
7286 (char *) "self", NULL
7287 };
7288
7289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetY",kwnames,&obj0)) goto fail;
7290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7291 if (SWIG_arg_fail(1)) SWIG_fail;
7292 {
7293 PyThreadState* __tstate = wxPyBeginAllowThreads();
7294 result = (int)(arg1)->GetY();
7295
7296 wxPyEndAllowThreads(__tstate);
7297 if (PyErr_Occurred()) SWIG_fail;
7298 }
7299 {
7300 resultobj = SWIG_From_int((int)(result));
7301 }
7302 return resultobj;
7303 fail:
7304 return NULL;
7305 }
7306
7307
7308 static PyObject *_wrap_RegionIterator_GetW(PyObject *, PyObject *args, PyObject *kwargs) {
7309 PyObject *resultobj;
7310 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7311 int result;
7312 PyObject * obj0 = 0 ;
7313 char *kwnames[] = {
7314 (char *) "self", NULL
7315 };
7316
7317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetW",kwnames,&obj0)) goto fail;
7318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7319 if (SWIG_arg_fail(1)) SWIG_fail;
7320 {
7321 PyThreadState* __tstate = wxPyBeginAllowThreads();
7322 result = (int)(arg1)->GetW();
7323
7324 wxPyEndAllowThreads(__tstate);
7325 if (PyErr_Occurred()) SWIG_fail;
7326 }
7327 {
7328 resultobj = SWIG_From_int((int)(result));
7329 }
7330 return resultobj;
7331 fail:
7332 return NULL;
7333 }
7334
7335
7336 static PyObject *_wrap_RegionIterator_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
7337 PyObject *resultobj;
7338 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7339 int result;
7340 PyObject * obj0 = 0 ;
7341 char *kwnames[] = {
7342 (char *) "self", NULL
7343 };
7344
7345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetWidth",kwnames,&obj0)) goto fail;
7346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7347 if (SWIG_arg_fail(1)) SWIG_fail;
7348 {
7349 PyThreadState* __tstate = wxPyBeginAllowThreads();
7350 result = (int)(arg1)->GetWidth();
7351
7352 wxPyEndAllowThreads(__tstate);
7353 if (PyErr_Occurred()) SWIG_fail;
7354 }
7355 {
7356 resultobj = SWIG_From_int((int)(result));
7357 }
7358 return resultobj;
7359 fail:
7360 return NULL;
7361 }
7362
7363
7364 static PyObject *_wrap_RegionIterator_GetH(PyObject *, PyObject *args, PyObject *kwargs) {
7365 PyObject *resultobj;
7366 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7367 int result;
7368 PyObject * obj0 = 0 ;
7369 char *kwnames[] = {
7370 (char *) "self", NULL
7371 };
7372
7373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetH",kwnames,&obj0)) goto fail;
7374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7375 if (SWIG_arg_fail(1)) SWIG_fail;
7376 {
7377 PyThreadState* __tstate = wxPyBeginAllowThreads();
7378 result = (int)(arg1)->GetH();
7379
7380 wxPyEndAllowThreads(__tstate);
7381 if (PyErr_Occurred()) SWIG_fail;
7382 }
7383 {
7384 resultobj = SWIG_From_int((int)(result));
7385 }
7386 return resultobj;
7387 fail:
7388 return NULL;
7389 }
7390
7391
7392 static PyObject *_wrap_RegionIterator_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
7393 PyObject *resultobj;
7394 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7395 int result;
7396 PyObject * obj0 = 0 ;
7397 char *kwnames[] = {
7398 (char *) "self", NULL
7399 };
7400
7401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetHeight",kwnames,&obj0)) goto fail;
7402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7403 if (SWIG_arg_fail(1)) SWIG_fail;
7404 {
7405 PyThreadState* __tstate = wxPyBeginAllowThreads();
7406 result = (int)(arg1)->GetHeight();
7407
7408 wxPyEndAllowThreads(__tstate);
7409 if (PyErr_Occurred()) SWIG_fail;
7410 }
7411 {
7412 resultobj = SWIG_From_int((int)(result));
7413 }
7414 return resultobj;
7415 fail:
7416 return NULL;
7417 }
7418
7419
7420 static PyObject *_wrap_RegionIterator_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
7421 PyObject *resultobj;
7422 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7423 wxRect result;
7424 PyObject * obj0 = 0 ;
7425 char *kwnames[] = {
7426 (char *) "self", NULL
7427 };
7428
7429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetRect",kwnames,&obj0)) goto fail;
7430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7431 if (SWIG_arg_fail(1)) SWIG_fail;
7432 {
7433 PyThreadState* __tstate = wxPyBeginAllowThreads();
7434 result = (arg1)->GetRect();
7435
7436 wxPyEndAllowThreads(__tstate);
7437 if (PyErr_Occurred()) SWIG_fail;
7438 }
7439 {
7440 wxRect * resultptr;
7441 resultptr = new wxRect((wxRect &)(result));
7442 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
7443 }
7444 return resultobj;
7445 fail:
7446 return NULL;
7447 }
7448
7449
7450 static PyObject *_wrap_RegionIterator_HaveRects(PyObject *, PyObject *args, PyObject *kwargs) {
7451 PyObject *resultobj;
7452 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7453 bool result;
7454 PyObject * obj0 = 0 ;
7455 char *kwnames[] = {
7456 (char *) "self", NULL
7457 };
7458
7459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_HaveRects",kwnames,&obj0)) goto fail;
7460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7461 if (SWIG_arg_fail(1)) SWIG_fail;
7462 {
7463 PyThreadState* __tstate = wxPyBeginAllowThreads();
7464 result = (bool)(arg1)->HaveRects();
7465
7466 wxPyEndAllowThreads(__tstate);
7467 if (PyErr_Occurred()) SWIG_fail;
7468 }
7469 {
7470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7471 }
7472 return resultobj;
7473 fail:
7474 return NULL;
7475 }
7476
7477
7478 static PyObject *_wrap_RegionIterator_Reset(PyObject *, PyObject *args, PyObject *kwargs) {
7479 PyObject *resultobj;
7480 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7481 PyObject * obj0 = 0 ;
7482 char *kwnames[] = {
7483 (char *) "self", NULL
7484 };
7485
7486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Reset",kwnames,&obj0)) goto fail;
7487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7488 if (SWIG_arg_fail(1)) SWIG_fail;
7489 {
7490 PyThreadState* __tstate = wxPyBeginAllowThreads();
7491 (arg1)->Reset();
7492
7493 wxPyEndAllowThreads(__tstate);
7494 if (PyErr_Occurred()) SWIG_fail;
7495 }
7496 Py_INCREF(Py_None); resultobj = Py_None;
7497 return resultobj;
7498 fail:
7499 return NULL;
7500 }
7501
7502
7503 static PyObject *_wrap_RegionIterator_Next(PyObject *, PyObject *args, PyObject *kwargs) {
7504 PyObject *resultobj;
7505 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7506 PyObject * obj0 = 0 ;
7507 char *kwnames[] = {
7508 (char *) "self", NULL
7509 };
7510
7511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Next",kwnames,&obj0)) goto fail;
7512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7513 if (SWIG_arg_fail(1)) SWIG_fail;
7514 {
7515 PyThreadState* __tstate = wxPyBeginAllowThreads();
7516 wxRegionIterator_Next(arg1);
7517
7518 wxPyEndAllowThreads(__tstate);
7519 if (PyErr_Occurred()) SWIG_fail;
7520 }
7521 Py_INCREF(Py_None); resultobj = Py_None;
7522 return resultobj;
7523 fail:
7524 return NULL;
7525 }
7526
7527
7528 static PyObject *_wrap_RegionIterator___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
7529 PyObject *resultobj;
7530 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7531 bool result;
7532 PyObject * obj0 = 0 ;
7533 char *kwnames[] = {
7534 (char *) "self", NULL
7535 };
7536
7537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator___nonzero__",kwnames,&obj0)) goto fail;
7538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7539 if (SWIG_arg_fail(1)) SWIG_fail;
7540 {
7541 PyThreadState* __tstate = wxPyBeginAllowThreads();
7542 result = (bool)wxRegionIterator___nonzero__(arg1);
7543
7544 wxPyEndAllowThreads(__tstate);
7545 if (PyErr_Occurred()) SWIG_fail;
7546 }
7547 {
7548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7549 }
7550 return resultobj;
7551 fail:
7552 return NULL;
7553 }
7554
7555
7556 static PyObject * RegionIterator_swigregister(PyObject *, PyObject *args) {
7557 PyObject *obj;
7558 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7559 SWIG_TypeClientData(SWIGTYPE_p_wxRegionIterator, obj);
7560 Py_INCREF(obj);
7561 return Py_BuildValue((char *)"");
7562 }
7563 static PyObject *_wrap_new_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7564 PyObject *resultobj;
7565 wxNativeFontInfo *result;
7566 char *kwnames[] = {
7567 NULL
7568 };
7569
7570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeFontInfo",kwnames)) goto fail;
7571 {
7572 PyThreadState* __tstate = wxPyBeginAllowThreads();
7573 result = (wxNativeFontInfo *)new wxNativeFontInfo();
7574
7575 wxPyEndAllowThreads(__tstate);
7576 if (PyErr_Occurred()) SWIG_fail;
7577 }
7578 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 1);
7579 return resultobj;
7580 fail:
7581 return NULL;
7582 }
7583
7584
7585 static PyObject *_wrap_delete_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7586 PyObject *resultobj;
7587 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7588 PyObject * obj0 = 0 ;
7589 char *kwnames[] = {
7590 (char *) "self", NULL
7591 };
7592
7593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeFontInfo",kwnames,&obj0)) goto fail;
7594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7595 if (SWIG_arg_fail(1)) SWIG_fail;
7596 {
7597 PyThreadState* __tstate = wxPyBeginAllowThreads();
7598 delete arg1;
7599
7600 wxPyEndAllowThreads(__tstate);
7601 if (PyErr_Occurred()) SWIG_fail;
7602 }
7603 Py_INCREF(Py_None); resultobj = Py_None;
7604 return resultobj;
7605 fail:
7606 return NULL;
7607 }
7608
7609
7610 static PyObject *_wrap_NativeFontInfo_Init(PyObject *, PyObject *args, PyObject *kwargs) {
7611 PyObject *resultobj;
7612 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7613 PyObject * obj0 = 0 ;
7614 char *kwnames[] = {
7615 (char *) "self", NULL
7616 };
7617
7618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_Init",kwnames,&obj0)) goto fail;
7619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7620 if (SWIG_arg_fail(1)) SWIG_fail;
7621 {
7622 PyThreadState* __tstate = wxPyBeginAllowThreads();
7623 (arg1)->Init();
7624
7625 wxPyEndAllowThreads(__tstate);
7626 if (PyErr_Occurred()) SWIG_fail;
7627 }
7628 Py_INCREF(Py_None); resultobj = Py_None;
7629 return resultobj;
7630 fail:
7631 return NULL;
7632 }
7633
7634
7635 static PyObject *_wrap_NativeFontInfo_InitFromFont(PyObject *, PyObject *args, PyObject *kwargs) {
7636 PyObject *resultobj;
7637 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7638 wxFont *arg2 = 0 ;
7639 PyObject * obj0 = 0 ;
7640 PyObject * obj1 = 0 ;
7641 char *kwnames[] = {
7642 (char *) "self",(char *) "font", NULL
7643 };
7644
7645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_InitFromFont",kwnames,&obj0,&obj1)) goto fail;
7646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7647 if (SWIG_arg_fail(1)) SWIG_fail;
7648 {
7649 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
7650 if (SWIG_arg_fail(2)) SWIG_fail;
7651 if (arg2 == NULL) {
7652 SWIG_null_ref("wxFont");
7653 }
7654 if (SWIG_arg_fail(2)) SWIG_fail;
7655 }
7656 {
7657 PyThreadState* __tstate = wxPyBeginAllowThreads();
7658 (arg1)->InitFromFont((wxFont const &)*arg2);
7659
7660 wxPyEndAllowThreads(__tstate);
7661 if (PyErr_Occurred()) SWIG_fail;
7662 }
7663 Py_INCREF(Py_None); resultobj = Py_None;
7664 return resultobj;
7665 fail:
7666 return NULL;
7667 }
7668
7669
7670 static PyObject *_wrap_NativeFontInfo_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
7671 PyObject *resultobj;
7672 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7673 int result;
7674 PyObject * obj0 = 0 ;
7675 char *kwnames[] = {
7676 (char *) "self", NULL
7677 };
7678
7679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetPointSize",kwnames,&obj0)) goto fail;
7680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7681 if (SWIG_arg_fail(1)) SWIG_fail;
7682 {
7683 PyThreadState* __tstate = wxPyBeginAllowThreads();
7684 result = (int)((wxNativeFontInfo const *)arg1)->GetPointSize();
7685
7686 wxPyEndAllowThreads(__tstate);
7687 if (PyErr_Occurred()) SWIG_fail;
7688 }
7689 {
7690 resultobj = SWIG_From_int((int)(result));
7691 }
7692 return resultobj;
7693 fail:
7694 return NULL;
7695 }
7696
7697
7698 static PyObject *_wrap_NativeFontInfo_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
7699 PyObject *resultobj;
7700 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7701 wxFontStyle result;
7702 PyObject * obj0 = 0 ;
7703 char *kwnames[] = {
7704 (char *) "self", NULL
7705 };
7706
7707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetStyle",kwnames,&obj0)) goto fail;
7708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7709 if (SWIG_arg_fail(1)) SWIG_fail;
7710 {
7711 PyThreadState* __tstate = wxPyBeginAllowThreads();
7712 result = (wxFontStyle)((wxNativeFontInfo const *)arg1)->GetStyle();
7713
7714 wxPyEndAllowThreads(__tstate);
7715 if (PyErr_Occurred()) SWIG_fail;
7716 }
7717 resultobj = SWIG_From_int((result));
7718 return resultobj;
7719 fail:
7720 return NULL;
7721 }
7722
7723
7724 static PyObject *_wrap_NativeFontInfo_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
7725 PyObject *resultobj;
7726 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7727 wxFontWeight result;
7728 PyObject * obj0 = 0 ;
7729 char *kwnames[] = {
7730 (char *) "self", NULL
7731 };
7732
7733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetWeight",kwnames,&obj0)) goto fail;
7734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7735 if (SWIG_arg_fail(1)) SWIG_fail;
7736 {
7737 PyThreadState* __tstate = wxPyBeginAllowThreads();
7738 result = (wxFontWeight)((wxNativeFontInfo const *)arg1)->GetWeight();
7739
7740 wxPyEndAllowThreads(__tstate);
7741 if (PyErr_Occurred()) SWIG_fail;
7742 }
7743 resultobj = SWIG_From_int((result));
7744 return resultobj;
7745 fail:
7746 return NULL;
7747 }
7748
7749
7750 static PyObject *_wrap_NativeFontInfo_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
7751 PyObject *resultobj;
7752 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7753 bool result;
7754 PyObject * obj0 = 0 ;
7755 char *kwnames[] = {
7756 (char *) "self", NULL
7757 };
7758
7759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetUnderlined",kwnames,&obj0)) goto fail;
7760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7761 if (SWIG_arg_fail(1)) SWIG_fail;
7762 {
7763 PyThreadState* __tstate = wxPyBeginAllowThreads();
7764 result = (bool)((wxNativeFontInfo const *)arg1)->GetUnderlined();
7765
7766 wxPyEndAllowThreads(__tstate);
7767 if (PyErr_Occurred()) SWIG_fail;
7768 }
7769 {
7770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7771 }
7772 return resultobj;
7773 fail:
7774 return NULL;
7775 }
7776
7777
7778 static PyObject *_wrap_NativeFontInfo_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
7779 PyObject *resultobj;
7780 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7781 wxString result;
7782 PyObject * obj0 = 0 ;
7783 char *kwnames[] = {
7784 (char *) "self", NULL
7785 };
7786
7787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFaceName",kwnames,&obj0)) goto fail;
7788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7789 if (SWIG_arg_fail(1)) SWIG_fail;
7790 {
7791 PyThreadState* __tstate = wxPyBeginAllowThreads();
7792 result = ((wxNativeFontInfo const *)arg1)->GetFaceName();
7793
7794 wxPyEndAllowThreads(__tstate);
7795 if (PyErr_Occurred()) SWIG_fail;
7796 }
7797 {
7798 #if wxUSE_UNICODE
7799 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7800 #else
7801 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7802 #endif
7803 }
7804 return resultobj;
7805 fail:
7806 return NULL;
7807 }
7808
7809
7810 static PyObject *_wrap_NativeFontInfo_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
7811 PyObject *resultobj;
7812 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7813 wxFontFamily result;
7814 PyObject * obj0 = 0 ;
7815 char *kwnames[] = {
7816 (char *) "self", NULL
7817 };
7818
7819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFamily",kwnames,&obj0)) goto fail;
7820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7821 if (SWIG_arg_fail(1)) SWIG_fail;
7822 {
7823 PyThreadState* __tstate = wxPyBeginAllowThreads();
7824 result = (wxFontFamily)((wxNativeFontInfo const *)arg1)->GetFamily();
7825
7826 wxPyEndAllowThreads(__tstate);
7827 if (PyErr_Occurred()) SWIG_fail;
7828 }
7829 resultobj = SWIG_From_int((result));
7830 return resultobj;
7831 fail:
7832 return NULL;
7833 }
7834
7835
7836 static PyObject *_wrap_NativeFontInfo_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
7837 PyObject *resultobj;
7838 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7839 wxFontEncoding result;
7840 PyObject * obj0 = 0 ;
7841 char *kwnames[] = {
7842 (char *) "self", NULL
7843 };
7844
7845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetEncoding",kwnames,&obj0)) goto fail;
7846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7847 if (SWIG_arg_fail(1)) SWIG_fail;
7848 {
7849 PyThreadState* __tstate = wxPyBeginAllowThreads();
7850 result = (wxFontEncoding)((wxNativeFontInfo const *)arg1)->GetEncoding();
7851
7852 wxPyEndAllowThreads(__tstate);
7853 if (PyErr_Occurred()) SWIG_fail;
7854 }
7855 resultobj = SWIG_From_int((result));
7856 return resultobj;
7857 fail:
7858 return NULL;
7859 }
7860
7861
7862 static PyObject *_wrap_NativeFontInfo_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
7863 PyObject *resultobj;
7864 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7865 int arg2 ;
7866 PyObject * obj0 = 0 ;
7867 PyObject * obj1 = 0 ;
7868 char *kwnames[] = {
7869 (char *) "self",(char *) "pointsize", NULL
7870 };
7871
7872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
7873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7874 if (SWIG_arg_fail(1)) SWIG_fail;
7875 {
7876 arg2 = (int)(SWIG_As_int(obj1));
7877 if (SWIG_arg_fail(2)) SWIG_fail;
7878 }
7879 {
7880 PyThreadState* __tstate = wxPyBeginAllowThreads();
7881 (arg1)->SetPointSize(arg2);
7882
7883 wxPyEndAllowThreads(__tstate);
7884 if (PyErr_Occurred()) SWIG_fail;
7885 }
7886 Py_INCREF(Py_None); resultobj = Py_None;
7887 return resultobj;
7888 fail:
7889 return NULL;
7890 }
7891
7892
7893 static PyObject *_wrap_NativeFontInfo_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
7894 PyObject *resultobj;
7895 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7896 wxFontStyle arg2 ;
7897 PyObject * obj0 = 0 ;
7898 PyObject * obj1 = 0 ;
7899 char *kwnames[] = {
7900 (char *) "self",(char *) "style", NULL
7901 };
7902
7903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetStyle",kwnames,&obj0,&obj1)) goto fail;
7904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7905 if (SWIG_arg_fail(1)) SWIG_fail;
7906 {
7907 arg2 = (wxFontStyle)(SWIG_As_int(obj1));
7908 if (SWIG_arg_fail(2)) SWIG_fail;
7909 }
7910 {
7911 PyThreadState* __tstate = wxPyBeginAllowThreads();
7912 (arg1)->SetStyle((wxFontStyle )arg2);
7913
7914 wxPyEndAllowThreads(__tstate);
7915 if (PyErr_Occurred()) SWIG_fail;
7916 }
7917 Py_INCREF(Py_None); resultobj = Py_None;
7918 return resultobj;
7919 fail:
7920 return NULL;
7921 }
7922
7923
7924 static PyObject *_wrap_NativeFontInfo_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
7925 PyObject *resultobj;
7926 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7927 wxFontWeight arg2 ;
7928 PyObject * obj0 = 0 ;
7929 PyObject * obj1 = 0 ;
7930 char *kwnames[] = {
7931 (char *) "self",(char *) "weight", NULL
7932 };
7933
7934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetWeight",kwnames,&obj0,&obj1)) goto fail;
7935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7936 if (SWIG_arg_fail(1)) SWIG_fail;
7937 {
7938 arg2 = (wxFontWeight)(SWIG_As_int(obj1));
7939 if (SWIG_arg_fail(2)) SWIG_fail;
7940 }
7941 {
7942 PyThreadState* __tstate = wxPyBeginAllowThreads();
7943 (arg1)->SetWeight((wxFontWeight )arg2);
7944
7945 wxPyEndAllowThreads(__tstate);
7946 if (PyErr_Occurred()) SWIG_fail;
7947 }
7948 Py_INCREF(Py_None); resultobj = Py_None;
7949 return resultobj;
7950 fail:
7951 return NULL;
7952 }
7953
7954
7955 static PyObject *_wrap_NativeFontInfo_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
7956 PyObject *resultobj;
7957 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7958 bool arg2 ;
7959 PyObject * obj0 = 0 ;
7960 PyObject * obj1 = 0 ;
7961 char *kwnames[] = {
7962 (char *) "self",(char *) "underlined", NULL
7963 };
7964
7965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
7966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7967 if (SWIG_arg_fail(1)) SWIG_fail;
7968 {
7969 arg2 = (bool)(SWIG_As_bool(obj1));
7970 if (SWIG_arg_fail(2)) SWIG_fail;
7971 }
7972 {
7973 PyThreadState* __tstate = wxPyBeginAllowThreads();
7974 (arg1)->SetUnderlined(arg2);
7975
7976 wxPyEndAllowThreads(__tstate);
7977 if (PyErr_Occurred()) SWIG_fail;
7978 }
7979 Py_INCREF(Py_None); resultobj = Py_None;
7980 return resultobj;
7981 fail:
7982 return NULL;
7983 }
7984
7985
7986 static PyObject *_wrap_NativeFontInfo_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
7987 PyObject *resultobj;
7988 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7989 wxString arg2 ;
7990 PyObject * obj0 = 0 ;
7991 PyObject * obj1 = 0 ;
7992 char *kwnames[] = {
7993 (char *) "self",(char *) "facename", NULL
7994 };
7995
7996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
7997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7998 if (SWIG_arg_fail(1)) SWIG_fail;
7999 {
8000 wxString* sptr = wxString_in_helper(obj1);
8001 if (sptr == NULL) SWIG_fail;
8002 arg2 = *sptr;
8003 delete sptr;
8004 }
8005 {
8006 PyThreadState* __tstate = wxPyBeginAllowThreads();
8007 (arg1)->SetFaceName(arg2);
8008
8009 wxPyEndAllowThreads(__tstate);
8010 if (PyErr_Occurred()) SWIG_fail;
8011 }
8012 Py_INCREF(Py_None); resultobj = Py_None;
8013 return resultobj;
8014 fail:
8015 return NULL;
8016 }
8017
8018
8019 static PyObject *_wrap_NativeFontInfo_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
8020 PyObject *resultobj;
8021 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8022 wxFontFamily arg2 ;
8023 PyObject * obj0 = 0 ;
8024 PyObject * obj1 = 0 ;
8025 char *kwnames[] = {
8026 (char *) "self",(char *) "family", NULL
8027 };
8028
8029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFamily",kwnames,&obj0,&obj1)) goto fail;
8030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8031 if (SWIG_arg_fail(1)) SWIG_fail;
8032 {
8033 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
8034 if (SWIG_arg_fail(2)) SWIG_fail;
8035 }
8036 {
8037 PyThreadState* __tstate = wxPyBeginAllowThreads();
8038 (arg1)->SetFamily((wxFontFamily )arg2);
8039
8040 wxPyEndAllowThreads(__tstate);
8041 if (PyErr_Occurred()) SWIG_fail;
8042 }
8043 Py_INCREF(Py_None); resultobj = Py_None;
8044 return resultobj;
8045 fail:
8046 return NULL;
8047 }
8048
8049
8050 static PyObject *_wrap_NativeFontInfo_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8051 PyObject *resultobj;
8052 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8053 wxFontEncoding arg2 ;
8054 PyObject * obj0 = 0 ;
8055 PyObject * obj1 = 0 ;
8056 char *kwnames[] = {
8057 (char *) "self",(char *) "encoding", NULL
8058 };
8059
8060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
8061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8062 if (SWIG_arg_fail(1)) SWIG_fail;
8063 {
8064 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8065 if (SWIG_arg_fail(2)) SWIG_fail;
8066 }
8067 {
8068 PyThreadState* __tstate = wxPyBeginAllowThreads();
8069 (arg1)->SetEncoding((wxFontEncoding )arg2);
8070
8071 wxPyEndAllowThreads(__tstate);
8072 if (PyErr_Occurred()) SWIG_fail;
8073 }
8074 Py_INCREF(Py_None); resultobj = Py_None;
8075 return resultobj;
8076 fail:
8077 return NULL;
8078 }
8079
8080
8081 static PyObject *_wrap_NativeFontInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
8082 PyObject *resultobj;
8083 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8084 wxString *arg2 = 0 ;
8085 bool result;
8086 bool temp2 = false ;
8087 PyObject * obj0 = 0 ;
8088 PyObject * obj1 = 0 ;
8089 char *kwnames[] = {
8090 (char *) "self",(char *) "s", NULL
8091 };
8092
8093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
8094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8095 if (SWIG_arg_fail(1)) SWIG_fail;
8096 {
8097 arg2 = wxString_in_helper(obj1);
8098 if (arg2 == NULL) SWIG_fail;
8099 temp2 = true;
8100 }
8101 {
8102 PyThreadState* __tstate = wxPyBeginAllowThreads();
8103 result = (bool)(arg1)->FromString((wxString const &)*arg2);
8104
8105 wxPyEndAllowThreads(__tstate);
8106 if (PyErr_Occurred()) SWIG_fail;
8107 }
8108 {
8109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8110 }
8111 {
8112 if (temp2)
8113 delete arg2;
8114 }
8115 return resultobj;
8116 fail:
8117 {
8118 if (temp2)
8119 delete arg2;
8120 }
8121 return NULL;
8122 }
8123
8124
8125 static PyObject *_wrap_NativeFontInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
8126 PyObject *resultobj;
8127 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8128 wxString result;
8129 PyObject * obj0 = 0 ;
8130 char *kwnames[] = {
8131 (char *) "self", NULL
8132 };
8133
8134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToString",kwnames,&obj0)) goto fail;
8135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8136 if (SWIG_arg_fail(1)) SWIG_fail;
8137 {
8138 PyThreadState* __tstate = wxPyBeginAllowThreads();
8139 result = ((wxNativeFontInfo const *)arg1)->ToString();
8140
8141 wxPyEndAllowThreads(__tstate);
8142 if (PyErr_Occurred()) SWIG_fail;
8143 }
8144 {
8145 #if wxUSE_UNICODE
8146 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8147 #else
8148 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8149 #endif
8150 }
8151 return resultobj;
8152 fail:
8153 return NULL;
8154 }
8155
8156
8157 static PyObject *_wrap_NativeFontInfo___str__(PyObject *, PyObject *args, PyObject *kwargs) {
8158 PyObject *resultobj;
8159 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8160 wxString result;
8161 PyObject * obj0 = 0 ;
8162 char *kwnames[] = {
8163 (char *) "self", NULL
8164 };
8165
8166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo___str__",kwnames,&obj0)) goto fail;
8167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8168 if (SWIG_arg_fail(1)) SWIG_fail;
8169 {
8170 PyThreadState* __tstate = wxPyBeginAllowThreads();
8171 result = wxNativeFontInfo___str__(arg1);
8172
8173 wxPyEndAllowThreads(__tstate);
8174 if (PyErr_Occurred()) SWIG_fail;
8175 }
8176 {
8177 #if wxUSE_UNICODE
8178 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8179 #else
8180 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8181 #endif
8182 }
8183 return resultobj;
8184 fail:
8185 return NULL;
8186 }
8187
8188
8189 static PyObject *_wrap_NativeFontInfo_FromUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8190 PyObject *resultobj;
8191 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8192 wxString *arg2 = 0 ;
8193 bool result;
8194 bool temp2 = false ;
8195 PyObject * obj0 = 0 ;
8196 PyObject * obj1 = 0 ;
8197 char *kwnames[] = {
8198 (char *) "self",(char *) "s", NULL
8199 };
8200
8201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromUserString",kwnames,&obj0,&obj1)) goto fail;
8202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8203 if (SWIG_arg_fail(1)) SWIG_fail;
8204 {
8205 arg2 = wxString_in_helper(obj1);
8206 if (arg2 == NULL) SWIG_fail;
8207 temp2 = true;
8208 }
8209 {
8210 PyThreadState* __tstate = wxPyBeginAllowThreads();
8211 result = (bool)(arg1)->FromUserString((wxString const &)*arg2);
8212
8213 wxPyEndAllowThreads(__tstate);
8214 if (PyErr_Occurred()) SWIG_fail;
8215 }
8216 {
8217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8218 }
8219 {
8220 if (temp2)
8221 delete arg2;
8222 }
8223 return resultobj;
8224 fail:
8225 {
8226 if (temp2)
8227 delete arg2;
8228 }
8229 return NULL;
8230 }
8231
8232
8233 static PyObject *_wrap_NativeFontInfo_ToUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8234 PyObject *resultobj;
8235 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8236 wxString result;
8237 PyObject * obj0 = 0 ;
8238 char *kwnames[] = {
8239 (char *) "self", NULL
8240 };
8241
8242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToUserString",kwnames,&obj0)) goto fail;
8243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8244 if (SWIG_arg_fail(1)) SWIG_fail;
8245 {
8246 PyThreadState* __tstate = wxPyBeginAllowThreads();
8247 result = ((wxNativeFontInfo const *)arg1)->ToUserString();
8248
8249 wxPyEndAllowThreads(__tstate);
8250 if (PyErr_Occurred()) SWIG_fail;
8251 }
8252 {
8253 #if wxUSE_UNICODE
8254 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8255 #else
8256 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8257 #endif
8258 }
8259 return resultobj;
8260 fail:
8261 return NULL;
8262 }
8263
8264
8265 static PyObject * NativeFontInfo_swigregister(PyObject *, PyObject *args) {
8266 PyObject *obj;
8267 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8268 SWIG_TypeClientData(SWIGTYPE_p_wxNativeFontInfo, obj);
8269 Py_INCREF(obj);
8270 return Py_BuildValue((char *)"");
8271 }
8272 static PyObject *_wrap_NativeEncodingInfo_facename_set(PyObject *, PyObject *args, PyObject *kwargs) {
8273 PyObject *resultobj;
8274 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8275 wxString *arg2 = (wxString *) 0 ;
8276 bool temp2 = false ;
8277 PyObject * obj0 = 0 ;
8278 PyObject * obj1 = 0 ;
8279 char *kwnames[] = {
8280 (char *) "self",(char *) "facename", NULL
8281 };
8282
8283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_facename_set",kwnames,&obj0,&obj1)) goto fail;
8284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8285 if (SWIG_arg_fail(1)) SWIG_fail;
8286 {
8287 arg2 = wxString_in_helper(obj1);
8288 if (arg2 == NULL) SWIG_fail;
8289 temp2 = true;
8290 }
8291 if (arg1) (arg1)->facename = *arg2;
8292
8293 Py_INCREF(Py_None); resultobj = Py_None;
8294 {
8295 if (temp2)
8296 delete arg2;
8297 }
8298 return resultobj;
8299 fail:
8300 {
8301 if (temp2)
8302 delete arg2;
8303 }
8304 return NULL;
8305 }
8306
8307
8308 static PyObject *_wrap_NativeEncodingInfo_facename_get(PyObject *, PyObject *args, PyObject *kwargs) {
8309 PyObject *resultobj;
8310 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8311 wxString *result;
8312 PyObject * obj0 = 0 ;
8313 char *kwnames[] = {
8314 (char *) "self", NULL
8315 };
8316
8317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_facename_get",kwnames,&obj0)) goto fail;
8318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8319 if (SWIG_arg_fail(1)) SWIG_fail;
8320 result = (wxString *)& ((arg1)->facename);
8321
8322 {
8323 #if wxUSE_UNICODE
8324 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8325 #else
8326 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8327 #endif
8328 }
8329 return resultobj;
8330 fail:
8331 return NULL;
8332 }
8333
8334
8335 static PyObject *_wrap_NativeEncodingInfo_encoding_set(PyObject *, PyObject *args, PyObject *kwargs) {
8336 PyObject *resultobj;
8337 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8338 wxFontEncoding arg2 ;
8339 PyObject * obj0 = 0 ;
8340 PyObject * obj1 = 0 ;
8341 char *kwnames[] = {
8342 (char *) "self",(char *) "encoding", NULL
8343 };
8344
8345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_encoding_set",kwnames,&obj0,&obj1)) goto fail;
8346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8347 if (SWIG_arg_fail(1)) SWIG_fail;
8348 {
8349 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8350 if (SWIG_arg_fail(2)) SWIG_fail;
8351 }
8352 if (arg1) (arg1)->encoding = (wxFontEncoding )arg2;
8353
8354 Py_INCREF(Py_None); resultobj = Py_None;
8355 return resultobj;
8356 fail:
8357 return NULL;
8358 }
8359
8360
8361 static PyObject *_wrap_NativeEncodingInfo_encoding_get(PyObject *, PyObject *args, PyObject *kwargs) {
8362 PyObject *resultobj;
8363 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8364 wxFontEncoding result;
8365 PyObject * obj0 = 0 ;
8366 char *kwnames[] = {
8367 (char *) "self", NULL
8368 };
8369
8370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_encoding_get",kwnames,&obj0)) goto fail;
8371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8372 if (SWIG_arg_fail(1)) SWIG_fail;
8373 result = (wxFontEncoding) ((arg1)->encoding);
8374
8375 resultobj = SWIG_From_int((result));
8376 return resultobj;
8377 fail:
8378 return NULL;
8379 }
8380
8381
8382 static PyObject *_wrap_new_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8383 PyObject *resultobj;
8384 wxNativeEncodingInfo *result;
8385 char *kwnames[] = {
8386 NULL
8387 };
8388
8389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeEncodingInfo",kwnames)) goto fail;
8390 {
8391 PyThreadState* __tstate = wxPyBeginAllowThreads();
8392 result = (wxNativeEncodingInfo *)new wxNativeEncodingInfo();
8393
8394 wxPyEndAllowThreads(__tstate);
8395 if (PyErr_Occurred()) SWIG_fail;
8396 }
8397 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 1);
8398 return resultobj;
8399 fail:
8400 return NULL;
8401 }
8402
8403
8404 static PyObject *_wrap_delete_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8405 PyObject *resultobj;
8406 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8407 PyObject * obj0 = 0 ;
8408 char *kwnames[] = {
8409 (char *) "self", NULL
8410 };
8411
8412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeEncodingInfo",kwnames,&obj0)) goto fail;
8413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8414 if (SWIG_arg_fail(1)) SWIG_fail;
8415 {
8416 PyThreadState* __tstate = wxPyBeginAllowThreads();
8417 delete arg1;
8418
8419 wxPyEndAllowThreads(__tstate);
8420 if (PyErr_Occurred()) SWIG_fail;
8421 }
8422 Py_INCREF(Py_None); resultobj = Py_None;
8423 return resultobj;
8424 fail:
8425 return NULL;
8426 }
8427
8428
8429 static PyObject *_wrap_NativeEncodingInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
8430 PyObject *resultobj;
8431 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8432 wxString *arg2 = 0 ;
8433 bool result;
8434 bool temp2 = false ;
8435 PyObject * obj0 = 0 ;
8436 PyObject * obj1 = 0 ;
8437 char *kwnames[] = {
8438 (char *) "self",(char *) "s", NULL
8439 };
8440
8441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
8442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8443 if (SWIG_arg_fail(1)) SWIG_fail;
8444 {
8445 arg2 = wxString_in_helper(obj1);
8446 if (arg2 == NULL) SWIG_fail;
8447 temp2 = true;
8448 }
8449 {
8450 PyThreadState* __tstate = wxPyBeginAllowThreads();
8451 result = (bool)(arg1)->FromString((wxString const &)*arg2);
8452
8453 wxPyEndAllowThreads(__tstate);
8454 if (PyErr_Occurred()) SWIG_fail;
8455 }
8456 {
8457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8458 }
8459 {
8460 if (temp2)
8461 delete arg2;
8462 }
8463 return resultobj;
8464 fail:
8465 {
8466 if (temp2)
8467 delete arg2;
8468 }
8469 return NULL;
8470 }
8471
8472
8473 static PyObject *_wrap_NativeEncodingInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
8474 PyObject *resultobj;
8475 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8476 wxString result;
8477 PyObject * obj0 = 0 ;
8478 char *kwnames[] = {
8479 (char *) "self", NULL
8480 };
8481
8482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_ToString",kwnames,&obj0)) goto fail;
8483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8484 if (SWIG_arg_fail(1)) SWIG_fail;
8485 {
8486 PyThreadState* __tstate = wxPyBeginAllowThreads();
8487 result = ((wxNativeEncodingInfo const *)arg1)->ToString();
8488
8489 wxPyEndAllowThreads(__tstate);
8490 if (PyErr_Occurred()) SWIG_fail;
8491 }
8492 {
8493 #if wxUSE_UNICODE
8494 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8495 #else
8496 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8497 #endif
8498 }
8499 return resultobj;
8500 fail:
8501 return NULL;
8502 }
8503
8504
8505 static PyObject * NativeEncodingInfo_swigregister(PyObject *, PyObject *args) {
8506 PyObject *obj;
8507 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8508 SWIG_TypeClientData(SWIGTYPE_p_wxNativeEncodingInfo, obj);
8509 Py_INCREF(obj);
8510 return Py_BuildValue((char *)"");
8511 }
8512 static PyObject *_wrap_GetNativeFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8513 PyObject *resultobj;
8514 wxFontEncoding arg1 ;
8515 wxNativeEncodingInfo *result;
8516 PyObject * obj0 = 0 ;
8517 char *kwnames[] = {
8518 (char *) "encoding", NULL
8519 };
8520
8521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetNativeFontEncoding",kwnames,&obj0)) goto fail;
8522 {
8523 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8524 if (SWIG_arg_fail(1)) SWIG_fail;
8525 }
8526 {
8527 PyThreadState* __tstate = wxPyBeginAllowThreads();
8528 result = (wxNativeEncodingInfo *)wxGetNativeFontEncoding((wxFontEncoding )arg1);
8529
8530 wxPyEndAllowThreads(__tstate);
8531 if (PyErr_Occurred()) SWIG_fail;
8532 }
8533 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 0);
8534 return resultobj;
8535 fail:
8536 return NULL;
8537 }
8538
8539
8540 static PyObject *_wrap_TestFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8541 PyObject *resultobj;
8542 wxNativeEncodingInfo *arg1 = 0 ;
8543 bool result;
8544 PyObject * obj0 = 0 ;
8545 char *kwnames[] = {
8546 (char *) "info", NULL
8547 };
8548
8549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TestFontEncoding",kwnames,&obj0)) goto fail;
8550 {
8551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8552 if (SWIG_arg_fail(1)) SWIG_fail;
8553 if (arg1 == NULL) {
8554 SWIG_null_ref("wxNativeEncodingInfo");
8555 }
8556 if (SWIG_arg_fail(1)) SWIG_fail;
8557 }
8558 {
8559 PyThreadState* __tstate = wxPyBeginAllowThreads();
8560 result = (bool)wxTestFontEncoding((wxNativeEncodingInfo const &)*arg1);
8561
8562 wxPyEndAllowThreads(__tstate);
8563 if (PyErr_Occurred()) SWIG_fail;
8564 }
8565 {
8566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8567 }
8568 return resultobj;
8569 fail:
8570 return NULL;
8571 }
8572
8573
8574 static PyObject *_wrap_new_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
8575 PyObject *resultobj;
8576 wxFontMapper *result;
8577 char *kwnames[] = {
8578 NULL
8579 };
8580
8581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontMapper",kwnames)) goto fail;
8582 {
8583 PyThreadState* __tstate = wxPyBeginAllowThreads();
8584 result = (wxFontMapper *)new wxFontMapper();
8585
8586 wxPyEndAllowThreads(__tstate);
8587 if (PyErr_Occurred()) SWIG_fail;
8588 }
8589 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 1);
8590 return resultobj;
8591 fail:
8592 return NULL;
8593 }
8594
8595
8596 static PyObject *_wrap_delete_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
8597 PyObject *resultobj;
8598 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8599 PyObject * obj0 = 0 ;
8600 char *kwnames[] = {
8601 (char *) "self", NULL
8602 };
8603
8604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontMapper",kwnames,&obj0)) goto fail;
8605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8606 if (SWIG_arg_fail(1)) SWIG_fail;
8607 {
8608 PyThreadState* __tstate = wxPyBeginAllowThreads();
8609 delete arg1;
8610
8611 wxPyEndAllowThreads(__tstate);
8612 if (PyErr_Occurred()) SWIG_fail;
8613 }
8614 Py_INCREF(Py_None); resultobj = Py_None;
8615 return resultobj;
8616 fail:
8617 return NULL;
8618 }
8619
8620
8621 static PyObject *_wrap_FontMapper_Get(PyObject *, PyObject *args, PyObject *kwargs) {
8622 PyObject *resultobj;
8623 wxFontMapper *result;
8624 char *kwnames[] = {
8625 NULL
8626 };
8627
8628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_Get",kwnames)) goto fail;
8629 {
8630 PyThreadState* __tstate = wxPyBeginAllowThreads();
8631 result = (wxFontMapper *)wxFontMapper::Get();
8632
8633 wxPyEndAllowThreads(__tstate);
8634 if (PyErr_Occurred()) SWIG_fail;
8635 }
8636 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
8637 return resultobj;
8638 fail:
8639 return NULL;
8640 }
8641
8642
8643 static PyObject *_wrap_FontMapper_Set(PyObject *, PyObject *args, PyObject *kwargs) {
8644 PyObject *resultobj;
8645 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8646 wxFontMapper *result;
8647 PyObject * obj0 = 0 ;
8648 char *kwnames[] = {
8649 (char *) "mapper", NULL
8650 };
8651
8652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_Set",kwnames,&obj0)) goto fail;
8653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8654 if (SWIG_arg_fail(1)) SWIG_fail;
8655 {
8656 PyThreadState* __tstate = wxPyBeginAllowThreads();
8657 result = (wxFontMapper *)wxFontMapper::Set(arg1);
8658
8659 wxPyEndAllowThreads(__tstate);
8660 if (PyErr_Occurred()) SWIG_fail;
8661 }
8662 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
8663 return resultobj;
8664 fail:
8665 return NULL;
8666 }
8667
8668
8669 static PyObject *_wrap_FontMapper_CharsetToEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8670 PyObject *resultobj;
8671 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8672 wxString *arg2 = 0 ;
8673 bool arg3 = (bool) true ;
8674 wxFontEncoding result;
8675 bool temp2 = false ;
8676 PyObject * obj0 = 0 ;
8677 PyObject * obj1 = 0 ;
8678 PyObject * obj2 = 0 ;
8679 char *kwnames[] = {
8680 (char *) "self",(char *) "charset",(char *) "interactive", NULL
8681 };
8682
8683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_CharsetToEncoding",kwnames,&obj0,&obj1,&obj2)) goto fail;
8684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8685 if (SWIG_arg_fail(1)) SWIG_fail;
8686 {
8687 arg2 = wxString_in_helper(obj1);
8688 if (arg2 == NULL) SWIG_fail;
8689 temp2 = true;
8690 }
8691 if (obj2) {
8692 {
8693 arg3 = (bool)(SWIG_As_bool(obj2));
8694 if (SWIG_arg_fail(3)) SWIG_fail;
8695 }
8696 }
8697 {
8698 PyThreadState* __tstate = wxPyBeginAllowThreads();
8699 result = (wxFontEncoding)(arg1)->CharsetToEncoding((wxString const &)*arg2,arg3);
8700
8701 wxPyEndAllowThreads(__tstate);
8702 if (PyErr_Occurred()) SWIG_fail;
8703 }
8704 resultobj = SWIG_From_int((result));
8705 {
8706 if (temp2)
8707 delete arg2;
8708 }
8709 return resultobj;
8710 fail:
8711 {
8712 if (temp2)
8713 delete arg2;
8714 }
8715 return NULL;
8716 }
8717
8718
8719 static PyObject *_wrap_FontMapper_GetSupportedEncodingsCount(PyObject *, PyObject *args, PyObject *kwargs) {
8720 PyObject *resultobj;
8721 size_t result;
8722 char *kwnames[] = {
8723 NULL
8724 };
8725
8726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetSupportedEncodingsCount",kwnames)) goto fail;
8727 {
8728 PyThreadState* __tstate = wxPyBeginAllowThreads();
8729 result = (size_t)wxFontMapper::GetSupportedEncodingsCount();
8730
8731 wxPyEndAllowThreads(__tstate);
8732 if (PyErr_Occurred()) SWIG_fail;
8733 }
8734 {
8735 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
8736 }
8737 return resultobj;
8738 fail:
8739 return NULL;
8740 }
8741
8742
8743 static PyObject *_wrap_FontMapper_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8744 PyObject *resultobj;
8745 size_t arg1 ;
8746 wxFontEncoding result;
8747 PyObject * obj0 = 0 ;
8748 char *kwnames[] = {
8749 (char *) "n", NULL
8750 };
8751
8752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncoding",kwnames,&obj0)) goto fail;
8753 {
8754 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8755 if (SWIG_arg_fail(1)) SWIG_fail;
8756 }
8757 {
8758 PyThreadState* __tstate = wxPyBeginAllowThreads();
8759 result = (wxFontEncoding)wxFontMapper::GetEncoding(arg1);
8760
8761 wxPyEndAllowThreads(__tstate);
8762 if (PyErr_Occurred()) SWIG_fail;
8763 }
8764 resultobj = SWIG_From_int((result));
8765 return resultobj;
8766 fail:
8767 return NULL;
8768 }
8769
8770
8771 static PyObject *_wrap_FontMapper_GetEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
8772 PyObject *resultobj;
8773 wxFontEncoding arg1 ;
8774 wxString result;
8775 PyObject * obj0 = 0 ;
8776 char *kwnames[] = {
8777 (char *) "encoding", NULL
8778 };
8779
8780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingName",kwnames,&obj0)) goto fail;
8781 {
8782 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8783 if (SWIG_arg_fail(1)) SWIG_fail;
8784 }
8785 {
8786 PyThreadState* __tstate = wxPyBeginAllowThreads();
8787 result = wxFontMapper::GetEncodingName((wxFontEncoding )arg1);
8788
8789 wxPyEndAllowThreads(__tstate);
8790 if (PyErr_Occurred()) SWIG_fail;
8791 }
8792 {
8793 #if wxUSE_UNICODE
8794 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8795 #else
8796 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8797 #endif
8798 }
8799 return resultobj;
8800 fail:
8801 return NULL;
8802 }
8803
8804
8805 static PyObject *_wrap_FontMapper_GetEncodingDescription(PyObject *, PyObject *args, PyObject *kwargs) {
8806 PyObject *resultobj;
8807 wxFontEncoding arg1 ;
8808 wxString result;
8809 PyObject * obj0 = 0 ;
8810 char *kwnames[] = {
8811 (char *) "encoding", NULL
8812 };
8813
8814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingDescription",kwnames,&obj0)) goto fail;
8815 {
8816 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8817 if (SWIG_arg_fail(1)) SWIG_fail;
8818 }
8819 {
8820 PyThreadState* __tstate = wxPyBeginAllowThreads();
8821 result = wxFontMapper::GetEncodingDescription((wxFontEncoding )arg1);
8822
8823 wxPyEndAllowThreads(__tstate);
8824 if (PyErr_Occurred()) SWIG_fail;
8825 }
8826 {
8827 #if wxUSE_UNICODE
8828 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8829 #else
8830 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8831 #endif
8832 }
8833 return resultobj;
8834 fail:
8835 return NULL;
8836 }
8837
8838
8839 static PyObject *_wrap_FontMapper_GetEncodingFromName(PyObject *, PyObject *args, PyObject *kwargs) {
8840 PyObject *resultobj;
8841 wxString *arg1 = 0 ;
8842 wxFontEncoding result;
8843 bool temp1 = false ;
8844 PyObject * obj0 = 0 ;
8845 char *kwnames[] = {
8846 (char *) "name", NULL
8847 };
8848
8849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingFromName",kwnames,&obj0)) goto fail;
8850 {
8851 arg1 = wxString_in_helper(obj0);
8852 if (arg1 == NULL) SWIG_fail;
8853 temp1 = true;
8854 }
8855 {
8856 PyThreadState* __tstate = wxPyBeginAllowThreads();
8857 result = (wxFontEncoding)wxFontMapper::GetEncodingFromName((wxString const &)*arg1);
8858
8859 wxPyEndAllowThreads(__tstate);
8860 if (PyErr_Occurred()) SWIG_fail;
8861 }
8862 resultobj = SWIG_From_int((result));
8863 {
8864 if (temp1)
8865 delete arg1;
8866 }
8867 return resultobj;
8868 fail:
8869 {
8870 if (temp1)
8871 delete arg1;
8872 }
8873 return NULL;
8874 }
8875
8876
8877 static PyObject *_wrap_FontMapper_SetConfig(PyObject *, PyObject *args, PyObject *kwargs) {
8878 PyObject *resultobj;
8879 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8880 wxConfigBase *arg2 = (wxConfigBase *) 0 ;
8881 PyObject * obj0 = 0 ;
8882 PyObject * obj1 = 0 ;
8883 char *kwnames[] = {
8884 (char *) "self",(char *) "config", NULL
8885 };
8886
8887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfig",kwnames,&obj0,&obj1)) goto fail;
8888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8889 if (SWIG_arg_fail(1)) SWIG_fail;
8890 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
8891 if (SWIG_arg_fail(2)) SWIG_fail;
8892 {
8893 PyThreadState* __tstate = wxPyBeginAllowThreads();
8894 (arg1)->SetConfig(arg2);
8895
8896 wxPyEndAllowThreads(__tstate);
8897 if (PyErr_Occurred()) SWIG_fail;
8898 }
8899 Py_INCREF(Py_None); resultobj = Py_None;
8900 return resultobj;
8901 fail:
8902 return NULL;
8903 }
8904
8905
8906 static PyObject *_wrap_FontMapper_SetConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
8907 PyObject *resultobj;
8908 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8909 wxString *arg2 = 0 ;
8910 bool temp2 = false ;
8911 PyObject * obj0 = 0 ;
8912 PyObject * obj1 = 0 ;
8913 char *kwnames[] = {
8914 (char *) "self",(char *) "prefix", NULL
8915 };
8916
8917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfigPath",kwnames,&obj0,&obj1)) goto fail;
8918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8919 if (SWIG_arg_fail(1)) SWIG_fail;
8920 {
8921 arg2 = wxString_in_helper(obj1);
8922 if (arg2 == NULL) SWIG_fail;
8923 temp2 = true;
8924 }
8925 {
8926 PyThreadState* __tstate = wxPyBeginAllowThreads();
8927 (arg1)->SetConfigPath((wxString const &)*arg2);
8928
8929 wxPyEndAllowThreads(__tstate);
8930 if (PyErr_Occurred()) SWIG_fail;
8931 }
8932 Py_INCREF(Py_None); resultobj = Py_None;
8933 {
8934 if (temp2)
8935 delete arg2;
8936 }
8937 return resultobj;
8938 fail:
8939 {
8940 if (temp2)
8941 delete arg2;
8942 }
8943 return NULL;
8944 }
8945
8946
8947 static PyObject *_wrap_FontMapper_GetDefaultConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
8948 PyObject *resultobj;
8949 wxString result;
8950 char *kwnames[] = {
8951 NULL
8952 };
8953
8954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetDefaultConfigPath",kwnames)) goto fail;
8955 {
8956 PyThreadState* __tstate = wxPyBeginAllowThreads();
8957 result = wxFontMapper::GetDefaultConfigPath();
8958
8959 wxPyEndAllowThreads(__tstate);
8960 if (PyErr_Occurred()) SWIG_fail;
8961 }
8962 {
8963 #if wxUSE_UNICODE
8964 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8965 #else
8966 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8967 #endif
8968 }
8969 return resultobj;
8970 fail:
8971 return NULL;
8972 }
8973
8974
8975 static PyObject *_wrap_FontMapper_GetAltForEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8976 PyObject *resultobj;
8977 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8978 wxFontEncoding arg2 ;
8979 wxString const &arg3_defvalue = wxPyEmptyString ;
8980 wxString *arg3 = (wxString *) &arg3_defvalue ;
8981 bool arg4 = (bool) true ;
8982 PyObject *result;
8983 bool temp3 = false ;
8984 PyObject * obj0 = 0 ;
8985 PyObject * obj1 = 0 ;
8986 PyObject * obj2 = 0 ;
8987 PyObject * obj3 = 0 ;
8988 char *kwnames[] = {
8989 (char *) "self",(char *) "encoding",(char *) "facename",(char *) "interactive", NULL
8990 };
8991
8992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:FontMapper_GetAltForEncoding",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8994 if (SWIG_arg_fail(1)) SWIG_fail;
8995 {
8996 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8997 if (SWIG_arg_fail(2)) SWIG_fail;
8998 }
8999 if (obj2) {
9000 {
9001 arg3 = wxString_in_helper(obj2);
9002 if (arg3 == NULL) SWIG_fail;
9003 temp3 = true;
9004 }
9005 }
9006 if (obj3) {
9007 {
9008 arg4 = (bool)(SWIG_As_bool(obj3));
9009 if (SWIG_arg_fail(4)) SWIG_fail;
9010 }
9011 }
9012 {
9013 PyThreadState* __tstate = wxPyBeginAllowThreads();
9014 result = (PyObject *)wxFontMapper_GetAltForEncoding(arg1,(wxFontEncoding )arg2,(wxString const &)*arg3,arg4);
9015
9016 wxPyEndAllowThreads(__tstate);
9017 if (PyErr_Occurred()) SWIG_fail;
9018 }
9019 resultobj = result;
9020 {
9021 if (temp3)
9022 delete arg3;
9023 }
9024 return resultobj;
9025 fail:
9026 {
9027 if (temp3)
9028 delete arg3;
9029 }
9030 return NULL;
9031 }
9032
9033
9034 static PyObject *_wrap_FontMapper_IsEncodingAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
9035 PyObject *resultobj;
9036 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9037 wxFontEncoding arg2 ;
9038 wxString const &arg3_defvalue = wxPyEmptyString ;
9039 wxString *arg3 = (wxString *) &arg3_defvalue ;
9040 bool result;
9041 bool temp3 = false ;
9042 PyObject * obj0 = 0 ;
9043 PyObject * obj1 = 0 ;
9044 PyObject * obj2 = 0 ;
9045 char *kwnames[] = {
9046 (char *) "self",(char *) "encoding",(char *) "facename", NULL
9047 };
9048
9049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_IsEncodingAvailable",kwnames,&obj0,&obj1,&obj2)) goto fail;
9050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9051 if (SWIG_arg_fail(1)) SWIG_fail;
9052 {
9053 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9054 if (SWIG_arg_fail(2)) SWIG_fail;
9055 }
9056 if (obj2) {
9057 {
9058 arg3 = wxString_in_helper(obj2);
9059 if (arg3 == NULL) SWIG_fail;
9060 temp3 = true;
9061 }
9062 }
9063 {
9064 PyThreadState* __tstate = wxPyBeginAllowThreads();
9065 result = (bool)(arg1)->IsEncodingAvailable((wxFontEncoding )arg2,(wxString const &)*arg3);
9066
9067 wxPyEndAllowThreads(__tstate);
9068 if (PyErr_Occurred()) SWIG_fail;
9069 }
9070 {
9071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9072 }
9073 {
9074 if (temp3)
9075 delete arg3;
9076 }
9077 return resultobj;
9078 fail:
9079 {
9080 if (temp3)
9081 delete arg3;
9082 }
9083 return NULL;
9084 }
9085
9086
9087 static PyObject *_wrap_FontMapper_SetDialogParent(PyObject *, PyObject *args, PyObject *kwargs) {
9088 PyObject *resultobj;
9089 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9090 wxWindow *arg2 = (wxWindow *) 0 ;
9091 PyObject * obj0 = 0 ;
9092 PyObject * obj1 = 0 ;
9093 char *kwnames[] = {
9094 (char *) "self",(char *) "parent", NULL
9095 };
9096
9097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogParent",kwnames,&obj0,&obj1)) goto fail;
9098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9099 if (SWIG_arg_fail(1)) SWIG_fail;
9100 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
9101 if (SWIG_arg_fail(2)) SWIG_fail;
9102 {
9103 PyThreadState* __tstate = wxPyBeginAllowThreads();
9104 (arg1)->SetDialogParent(arg2);
9105
9106 wxPyEndAllowThreads(__tstate);
9107 if (PyErr_Occurred()) SWIG_fail;
9108 }
9109 Py_INCREF(Py_None); resultobj = Py_None;
9110 return resultobj;
9111 fail:
9112 return NULL;
9113 }
9114
9115
9116 static PyObject *_wrap_FontMapper_SetDialogTitle(PyObject *, PyObject *args, PyObject *kwargs) {
9117 PyObject *resultobj;
9118 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9119 wxString *arg2 = 0 ;
9120 bool temp2 = false ;
9121 PyObject * obj0 = 0 ;
9122 PyObject * obj1 = 0 ;
9123 char *kwnames[] = {
9124 (char *) "self",(char *) "title", NULL
9125 };
9126
9127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogTitle",kwnames,&obj0,&obj1)) goto fail;
9128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9129 if (SWIG_arg_fail(1)) SWIG_fail;
9130 {
9131 arg2 = wxString_in_helper(obj1);
9132 if (arg2 == NULL) SWIG_fail;
9133 temp2 = true;
9134 }
9135 {
9136 PyThreadState* __tstate = wxPyBeginAllowThreads();
9137 (arg1)->SetDialogTitle((wxString const &)*arg2);
9138
9139 wxPyEndAllowThreads(__tstate);
9140 if (PyErr_Occurred()) SWIG_fail;
9141 }
9142 Py_INCREF(Py_None); resultobj = Py_None;
9143 {
9144 if (temp2)
9145 delete arg2;
9146 }
9147 return resultobj;
9148 fail:
9149 {
9150 if (temp2)
9151 delete arg2;
9152 }
9153 return NULL;
9154 }
9155
9156
9157 static PyObject * FontMapper_swigregister(PyObject *, PyObject *args) {
9158 PyObject *obj;
9159 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9160 SWIG_TypeClientData(SWIGTYPE_p_wxFontMapper, obj);
9161 Py_INCREF(obj);
9162 return Py_BuildValue((char *)"");
9163 }
9164 static PyObject *_wrap_new_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9165 PyObject *resultobj;
9166 int arg1 ;
9167 int arg2 ;
9168 int arg3 ;
9169 int arg4 ;
9170 bool arg5 = (bool) false ;
9171 wxString const &arg6_defvalue = wxPyEmptyString ;
9172 wxString *arg6 = (wxString *) &arg6_defvalue ;
9173 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9174 wxFont *result;
9175 bool temp6 = false ;
9176 PyObject * obj0 = 0 ;
9177 PyObject * obj1 = 0 ;
9178 PyObject * obj2 = 0 ;
9179 PyObject * obj3 = 0 ;
9180 PyObject * obj4 = 0 ;
9181 PyObject * obj5 = 0 ;
9182 PyObject * obj6 = 0 ;
9183 char *kwnames[] = {
9184 (char *) "pointSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "face",(char *) "encoding", NULL
9185 };
9186
9187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_Font",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9188 {
9189 arg1 = (int)(SWIG_As_int(obj0));
9190 if (SWIG_arg_fail(1)) SWIG_fail;
9191 }
9192 {
9193 arg2 = (int)(SWIG_As_int(obj1));
9194 if (SWIG_arg_fail(2)) SWIG_fail;
9195 }
9196 {
9197 arg3 = (int)(SWIG_As_int(obj2));
9198 if (SWIG_arg_fail(3)) SWIG_fail;
9199 }
9200 {
9201 arg4 = (int)(SWIG_As_int(obj3));
9202 if (SWIG_arg_fail(4)) SWIG_fail;
9203 }
9204 if (obj4) {
9205 {
9206 arg5 = (bool)(SWIG_As_bool(obj4));
9207 if (SWIG_arg_fail(5)) SWIG_fail;
9208 }
9209 }
9210 if (obj5) {
9211 {
9212 arg6 = wxString_in_helper(obj5);
9213 if (arg6 == NULL) SWIG_fail;
9214 temp6 = true;
9215 }
9216 }
9217 if (obj6) {
9218 {
9219 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
9220 if (SWIG_arg_fail(7)) SWIG_fail;
9221 }
9222 }
9223 {
9224 if (!wxPyCheckForApp()) SWIG_fail;
9225 PyThreadState* __tstate = wxPyBeginAllowThreads();
9226 result = (wxFont *)new wxFont(arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
9227
9228 wxPyEndAllowThreads(__tstate);
9229 if (PyErr_Occurred()) SWIG_fail;
9230 }
9231 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9232 {
9233 if (temp6)
9234 delete arg6;
9235 }
9236 return resultobj;
9237 fail:
9238 {
9239 if (temp6)
9240 delete arg6;
9241 }
9242 return NULL;
9243 }
9244
9245
9246 static PyObject *_wrap_delete_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9247 PyObject *resultobj;
9248 wxFont *arg1 = (wxFont *) 0 ;
9249 PyObject * obj0 = 0 ;
9250 char *kwnames[] = {
9251 (char *) "self", NULL
9252 };
9253
9254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Font",kwnames,&obj0)) goto fail;
9255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9256 if (SWIG_arg_fail(1)) SWIG_fail;
9257 {
9258 PyThreadState* __tstate = wxPyBeginAllowThreads();
9259 delete arg1;
9260
9261 wxPyEndAllowThreads(__tstate);
9262 if (PyErr_Occurred()) SWIG_fail;
9263 }
9264 Py_INCREF(Py_None); resultobj = Py_None;
9265 return resultobj;
9266 fail:
9267 return NULL;
9268 }
9269
9270
9271 static PyObject *_wrap_new_FontFromNativeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9272 PyObject *resultobj;
9273 wxNativeFontInfo *arg1 = 0 ;
9274 wxFont *result;
9275 PyObject * obj0 = 0 ;
9276 char *kwnames[] = {
9277 (char *) "info", NULL
9278 };
9279
9280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfo",kwnames,&obj0)) goto fail;
9281 {
9282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
9283 if (SWIG_arg_fail(1)) SWIG_fail;
9284 if (arg1 == NULL) {
9285 SWIG_null_ref("wxNativeFontInfo");
9286 }
9287 if (SWIG_arg_fail(1)) SWIG_fail;
9288 }
9289 {
9290 if (!wxPyCheckForApp()) SWIG_fail;
9291 PyThreadState* __tstate = wxPyBeginAllowThreads();
9292 result = (wxFont *)new wxFont((wxNativeFontInfo const &)*arg1);
9293
9294 wxPyEndAllowThreads(__tstate);
9295 if (PyErr_Occurred()) SWIG_fail;
9296 }
9297 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9298 return resultobj;
9299 fail:
9300 return NULL;
9301 }
9302
9303
9304 static PyObject *_wrap_new_FontFromNativeInfoString(PyObject *, PyObject *args, PyObject *kwargs) {
9305 PyObject *resultobj;
9306 wxString *arg1 = 0 ;
9307 wxFont *result;
9308 bool temp1 = false ;
9309 PyObject * obj0 = 0 ;
9310 char *kwnames[] = {
9311 (char *) "info", NULL
9312 };
9313
9314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfoString",kwnames,&obj0)) goto fail;
9315 {
9316 arg1 = wxString_in_helper(obj0);
9317 if (arg1 == NULL) SWIG_fail;
9318 temp1 = true;
9319 }
9320 {
9321 if (!wxPyCheckForApp()) SWIG_fail;
9322 PyThreadState* __tstate = wxPyBeginAllowThreads();
9323 result = (wxFont *)new_wxFont((wxString const &)*arg1);
9324
9325 wxPyEndAllowThreads(__tstate);
9326 if (PyErr_Occurred()) SWIG_fail;
9327 }
9328 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9329 {
9330 if (temp1)
9331 delete arg1;
9332 }
9333 return resultobj;
9334 fail:
9335 {
9336 if (temp1)
9337 delete arg1;
9338 }
9339 return NULL;
9340 }
9341
9342
9343 static PyObject *_wrap_new_Font2(PyObject *, PyObject *args, PyObject *kwargs) {
9344 PyObject *resultobj;
9345 int arg1 ;
9346 wxFontFamily arg2 ;
9347 int arg3 = (int) wxFONTFLAG_DEFAULT ;
9348 wxString const &arg4_defvalue = wxPyEmptyString ;
9349 wxString *arg4 = (wxString *) &arg4_defvalue ;
9350 wxFontEncoding arg5 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9351 wxFont *result;
9352 bool temp4 = false ;
9353 PyObject * obj0 = 0 ;
9354 PyObject * obj1 = 0 ;
9355 PyObject * obj2 = 0 ;
9356 PyObject * obj3 = 0 ;
9357 PyObject * obj4 = 0 ;
9358 char *kwnames[] = {
9359 (char *) "pointSize",(char *) "family",(char *) "flags",(char *) "face",(char *) "encoding", NULL
9360 };
9361
9362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_Font2",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
9363 {
9364 arg1 = (int)(SWIG_As_int(obj0));
9365 if (SWIG_arg_fail(1)) SWIG_fail;
9366 }
9367 {
9368 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
9369 if (SWIG_arg_fail(2)) SWIG_fail;
9370 }
9371 if (obj2) {
9372 {
9373 arg3 = (int)(SWIG_As_int(obj2));
9374 if (SWIG_arg_fail(3)) SWIG_fail;
9375 }
9376 }
9377 if (obj3) {
9378 {
9379 arg4 = wxString_in_helper(obj3);
9380 if (arg4 == NULL) SWIG_fail;
9381 temp4 = true;
9382 }
9383 }
9384 if (obj4) {
9385 {
9386 arg5 = (wxFontEncoding)(SWIG_As_int(obj4));
9387 if (SWIG_arg_fail(5)) SWIG_fail;
9388 }
9389 }
9390 {
9391 if (!wxPyCheckForApp()) SWIG_fail;
9392 PyThreadState* __tstate = wxPyBeginAllowThreads();
9393 result = (wxFont *)new_wxFont(arg1,(wxFontFamily )arg2,arg3,(wxString const &)*arg4,(wxFontEncoding )arg5);
9394
9395 wxPyEndAllowThreads(__tstate);
9396 if (PyErr_Occurred()) SWIG_fail;
9397 }
9398 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9399 {
9400 if (temp4)
9401 delete arg4;
9402 }
9403 return resultobj;
9404 fail:
9405 {
9406 if (temp4)
9407 delete arg4;
9408 }
9409 return NULL;
9410 }
9411
9412
9413 static PyObject *_wrap_new_FontFromPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
9414 PyObject *resultobj;
9415 wxSize *arg1 = 0 ;
9416 int arg2 ;
9417 int arg3 ;
9418 int arg4 ;
9419 bool arg5 = (bool) false ;
9420 wxString const &arg6_defvalue = wxEmptyString ;
9421 wxString *arg6 = (wxString *) &arg6_defvalue ;
9422 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9423 wxFont *result;
9424 wxSize temp1 ;
9425 bool temp6 = false ;
9426 PyObject * obj0 = 0 ;
9427 PyObject * obj1 = 0 ;
9428 PyObject * obj2 = 0 ;
9429 PyObject * obj3 = 0 ;
9430 PyObject * obj4 = 0 ;
9431 PyObject * obj5 = 0 ;
9432 PyObject * obj6 = 0 ;
9433 char *kwnames[] = {
9434 (char *) "pixelSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underlined",(char *) "face",(char *) "encoding", NULL
9435 };
9436
9437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_FontFromPixelSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9438 {
9439 arg1 = &temp1;
9440 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
9441 }
9442 {
9443 arg2 = (int)(SWIG_As_int(obj1));
9444 if (SWIG_arg_fail(2)) SWIG_fail;
9445 }
9446 {
9447 arg3 = (int)(SWIG_As_int(obj2));
9448 if (SWIG_arg_fail(3)) SWIG_fail;
9449 }
9450 {
9451 arg4 = (int)(SWIG_As_int(obj3));
9452 if (SWIG_arg_fail(4)) SWIG_fail;
9453 }
9454 if (obj4) {
9455 {
9456 arg5 = (bool)(SWIG_As_bool(obj4));
9457 if (SWIG_arg_fail(5)) SWIG_fail;
9458 }
9459 }
9460 if (obj5) {
9461 {
9462 arg6 = wxString_in_helper(obj5);
9463 if (arg6 == NULL) SWIG_fail;
9464 temp6 = true;
9465 }
9466 }
9467 if (obj6) {
9468 {
9469 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
9470 if (SWIG_arg_fail(7)) SWIG_fail;
9471 }
9472 }
9473 {
9474 if (!wxPyCheckForApp()) SWIG_fail;
9475 PyThreadState* __tstate = wxPyBeginAllowThreads();
9476 result = (wxFont *)new_wxFont((wxSize const &)*arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
9477
9478 wxPyEndAllowThreads(__tstate);
9479 if (PyErr_Occurred()) SWIG_fail;
9480 }
9481 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9482 {
9483 if (temp6)
9484 delete arg6;
9485 }
9486 return resultobj;
9487 fail:
9488 {
9489 if (temp6)
9490 delete arg6;
9491 }
9492 return NULL;
9493 }
9494
9495
9496 static PyObject *_wrap_Font_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
9497 PyObject *resultobj;
9498 wxFont *arg1 = (wxFont *) 0 ;
9499 bool result;
9500 PyObject * obj0 = 0 ;
9501 char *kwnames[] = {
9502 (char *) "self", NULL
9503 };
9504
9505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_Ok",kwnames,&obj0)) goto fail;
9506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9507 if (SWIG_arg_fail(1)) SWIG_fail;
9508 {
9509 PyThreadState* __tstate = wxPyBeginAllowThreads();
9510 result = (bool)((wxFont const *)arg1)->Ok();
9511
9512 wxPyEndAllowThreads(__tstate);
9513 if (PyErr_Occurred()) SWIG_fail;
9514 }
9515 {
9516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9517 }
9518 return resultobj;
9519 fail:
9520 return NULL;
9521 }
9522
9523
9524 static PyObject *_wrap_Font___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
9525 PyObject *resultobj;
9526 wxFont *arg1 = (wxFont *) 0 ;
9527 wxFont *arg2 = (wxFont *) 0 ;
9528 bool result;
9529 PyObject * obj0 = 0 ;
9530 PyObject * obj1 = 0 ;
9531 char *kwnames[] = {
9532 (char *) "self",(char *) "other", NULL
9533 };
9534
9535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___eq__",kwnames,&obj0,&obj1)) goto fail;
9536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9537 if (SWIG_arg_fail(1)) SWIG_fail;
9538 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9539 if (SWIG_arg_fail(2)) SWIG_fail;
9540 {
9541 PyThreadState* __tstate = wxPyBeginAllowThreads();
9542 result = (bool)wxFont___eq__(arg1,(wxFont const *)arg2);
9543
9544 wxPyEndAllowThreads(__tstate);
9545 if (PyErr_Occurred()) SWIG_fail;
9546 }
9547 {
9548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9549 }
9550 return resultobj;
9551 fail:
9552 return NULL;
9553 }
9554
9555
9556 static PyObject *_wrap_Font___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
9557 PyObject *resultobj;
9558 wxFont *arg1 = (wxFont *) 0 ;
9559 wxFont *arg2 = (wxFont *) 0 ;
9560 bool result;
9561 PyObject * obj0 = 0 ;
9562 PyObject * obj1 = 0 ;
9563 char *kwnames[] = {
9564 (char *) "self",(char *) "other", NULL
9565 };
9566
9567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___ne__",kwnames,&obj0,&obj1)) goto fail;
9568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9569 if (SWIG_arg_fail(1)) SWIG_fail;
9570 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9571 if (SWIG_arg_fail(2)) SWIG_fail;
9572 {
9573 PyThreadState* __tstate = wxPyBeginAllowThreads();
9574 result = (bool)wxFont___ne__(arg1,(wxFont const *)arg2);
9575
9576 wxPyEndAllowThreads(__tstate);
9577 if (PyErr_Occurred()) SWIG_fail;
9578 }
9579 {
9580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9581 }
9582 return resultobj;
9583 fail:
9584 return NULL;
9585 }
9586
9587
9588 static PyObject *_wrap_Font_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
9589 PyObject *resultobj;
9590 wxFont *arg1 = (wxFont *) 0 ;
9591 int result;
9592 PyObject * obj0 = 0 ;
9593 char *kwnames[] = {
9594 (char *) "self", NULL
9595 };
9596
9597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPointSize",kwnames,&obj0)) goto fail;
9598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9599 if (SWIG_arg_fail(1)) SWIG_fail;
9600 {
9601 PyThreadState* __tstate = wxPyBeginAllowThreads();
9602 result = (int)((wxFont const *)arg1)->GetPointSize();
9603
9604 wxPyEndAllowThreads(__tstate);
9605 if (PyErr_Occurred()) SWIG_fail;
9606 }
9607 {
9608 resultobj = SWIG_From_int((int)(result));
9609 }
9610 return resultobj;
9611 fail:
9612 return NULL;
9613 }
9614
9615
9616 static PyObject *_wrap_Font_GetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
9617 PyObject *resultobj;
9618 wxFont *arg1 = (wxFont *) 0 ;
9619 wxSize result;
9620 PyObject * obj0 = 0 ;
9621 char *kwnames[] = {
9622 (char *) "self", NULL
9623 };
9624
9625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPixelSize",kwnames,&obj0)) goto fail;
9626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9627 if (SWIG_arg_fail(1)) SWIG_fail;
9628 {
9629 PyThreadState* __tstate = wxPyBeginAllowThreads();
9630 result = ((wxFont const *)arg1)->GetPixelSize();
9631
9632 wxPyEndAllowThreads(__tstate);
9633 if (PyErr_Occurred()) SWIG_fail;
9634 }
9635 {
9636 wxSize * resultptr;
9637 resultptr = new wxSize((wxSize &)(result));
9638 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
9639 }
9640 return resultobj;
9641 fail:
9642 return NULL;
9643 }
9644
9645
9646 static PyObject *_wrap_Font_IsUsingSizeInPixels(PyObject *, PyObject *args, PyObject *kwargs) {
9647 PyObject *resultobj;
9648 wxFont *arg1 = (wxFont *) 0 ;
9649 bool result;
9650 PyObject * obj0 = 0 ;
9651 char *kwnames[] = {
9652 (char *) "self", NULL
9653 };
9654
9655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsUsingSizeInPixels",kwnames,&obj0)) goto fail;
9656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9657 if (SWIG_arg_fail(1)) SWIG_fail;
9658 {
9659 PyThreadState* __tstate = wxPyBeginAllowThreads();
9660 result = (bool)((wxFont const *)arg1)->IsUsingSizeInPixels();
9661
9662 wxPyEndAllowThreads(__tstate);
9663 if (PyErr_Occurred()) SWIG_fail;
9664 }
9665 {
9666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9667 }
9668 return resultobj;
9669 fail:
9670 return NULL;
9671 }
9672
9673
9674 static PyObject *_wrap_Font_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
9675 PyObject *resultobj;
9676 wxFont *arg1 = (wxFont *) 0 ;
9677 int result;
9678 PyObject * obj0 = 0 ;
9679 char *kwnames[] = {
9680 (char *) "self", NULL
9681 };
9682
9683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamily",kwnames,&obj0)) goto fail;
9684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9685 if (SWIG_arg_fail(1)) SWIG_fail;
9686 {
9687 PyThreadState* __tstate = wxPyBeginAllowThreads();
9688 result = (int)((wxFont const *)arg1)->GetFamily();
9689
9690 wxPyEndAllowThreads(__tstate);
9691 if (PyErr_Occurred()) SWIG_fail;
9692 }
9693 {
9694 resultobj = SWIG_From_int((int)(result));
9695 }
9696 return resultobj;
9697 fail:
9698 return NULL;
9699 }
9700
9701
9702 static PyObject *_wrap_Font_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
9703 PyObject *resultobj;
9704 wxFont *arg1 = (wxFont *) 0 ;
9705 int result;
9706 PyObject * obj0 = 0 ;
9707 char *kwnames[] = {
9708 (char *) "self", NULL
9709 };
9710
9711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyle",kwnames,&obj0)) goto fail;
9712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9713 if (SWIG_arg_fail(1)) SWIG_fail;
9714 {
9715 PyThreadState* __tstate = wxPyBeginAllowThreads();
9716 result = (int)((wxFont const *)arg1)->GetStyle();
9717
9718 wxPyEndAllowThreads(__tstate);
9719 if (PyErr_Occurred()) SWIG_fail;
9720 }
9721 {
9722 resultobj = SWIG_From_int((int)(result));
9723 }
9724 return resultobj;
9725 fail:
9726 return NULL;
9727 }
9728
9729
9730 static PyObject *_wrap_Font_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
9731 PyObject *resultobj;
9732 wxFont *arg1 = (wxFont *) 0 ;
9733 int result;
9734 PyObject * obj0 = 0 ;
9735 char *kwnames[] = {
9736 (char *) "self", NULL
9737 };
9738
9739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeight",kwnames,&obj0)) goto fail;
9740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9741 if (SWIG_arg_fail(1)) SWIG_fail;
9742 {
9743 PyThreadState* __tstate = wxPyBeginAllowThreads();
9744 result = (int)((wxFont const *)arg1)->GetWeight();
9745
9746 wxPyEndAllowThreads(__tstate);
9747 if (PyErr_Occurred()) SWIG_fail;
9748 }
9749 {
9750 resultobj = SWIG_From_int((int)(result));
9751 }
9752 return resultobj;
9753 fail:
9754 return NULL;
9755 }
9756
9757
9758 static PyObject *_wrap_Font_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
9759 PyObject *resultobj;
9760 wxFont *arg1 = (wxFont *) 0 ;
9761 bool result;
9762 PyObject * obj0 = 0 ;
9763 char *kwnames[] = {
9764 (char *) "self", NULL
9765 };
9766
9767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetUnderlined",kwnames,&obj0)) goto fail;
9768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9769 if (SWIG_arg_fail(1)) SWIG_fail;
9770 {
9771 PyThreadState* __tstate = wxPyBeginAllowThreads();
9772 result = (bool)((wxFont const *)arg1)->GetUnderlined();
9773
9774 wxPyEndAllowThreads(__tstate);
9775 if (PyErr_Occurred()) SWIG_fail;
9776 }
9777 {
9778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9779 }
9780 return resultobj;
9781 fail:
9782 return NULL;
9783 }
9784
9785
9786 static PyObject *_wrap_Font_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
9787 PyObject *resultobj;
9788 wxFont *arg1 = (wxFont *) 0 ;
9789 wxString result;
9790 PyObject * obj0 = 0 ;
9791 char *kwnames[] = {
9792 (char *) "self", NULL
9793 };
9794
9795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFaceName",kwnames,&obj0)) goto fail;
9796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9797 if (SWIG_arg_fail(1)) SWIG_fail;
9798 {
9799 PyThreadState* __tstate = wxPyBeginAllowThreads();
9800 result = ((wxFont const *)arg1)->GetFaceName();
9801
9802 wxPyEndAllowThreads(__tstate);
9803 if (PyErr_Occurred()) SWIG_fail;
9804 }
9805 {
9806 #if wxUSE_UNICODE
9807 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9808 #else
9809 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9810 #endif
9811 }
9812 return resultobj;
9813 fail:
9814 return NULL;
9815 }
9816
9817
9818 static PyObject *_wrap_Font_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9819 PyObject *resultobj;
9820 wxFont *arg1 = (wxFont *) 0 ;
9821 wxFontEncoding result;
9822 PyObject * obj0 = 0 ;
9823 char *kwnames[] = {
9824 (char *) "self", NULL
9825 };
9826
9827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetEncoding",kwnames,&obj0)) goto fail;
9828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9829 if (SWIG_arg_fail(1)) SWIG_fail;
9830 {
9831 PyThreadState* __tstate = wxPyBeginAllowThreads();
9832 result = (wxFontEncoding)((wxFont const *)arg1)->GetEncoding();
9833
9834 wxPyEndAllowThreads(__tstate);
9835 if (PyErr_Occurred()) SWIG_fail;
9836 }
9837 resultobj = SWIG_From_int((result));
9838 return resultobj;
9839 fail:
9840 return NULL;
9841 }
9842
9843
9844 static PyObject *_wrap_Font_GetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9845 PyObject *resultobj;
9846 wxFont *arg1 = (wxFont *) 0 ;
9847 wxNativeFontInfo *result;
9848 PyObject * obj0 = 0 ;
9849 char *kwnames[] = {
9850 (char *) "self", NULL
9851 };
9852
9853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfo",kwnames,&obj0)) goto fail;
9854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9855 if (SWIG_arg_fail(1)) SWIG_fail;
9856 {
9857 PyThreadState* __tstate = wxPyBeginAllowThreads();
9858 result = (wxNativeFontInfo *)((wxFont const *)arg1)->GetNativeFontInfo();
9859
9860 wxPyEndAllowThreads(__tstate);
9861 if (PyErr_Occurred()) SWIG_fail;
9862 }
9863 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 0);
9864 return resultobj;
9865 fail:
9866 return NULL;
9867 }
9868
9869
9870 static PyObject *_wrap_Font_IsFixedWidth(PyObject *, PyObject *args, PyObject *kwargs) {
9871 PyObject *resultobj;
9872 wxFont *arg1 = (wxFont *) 0 ;
9873 bool result;
9874 PyObject * obj0 = 0 ;
9875 char *kwnames[] = {
9876 (char *) "self", NULL
9877 };
9878
9879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsFixedWidth",kwnames,&obj0)) goto fail;
9880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9881 if (SWIG_arg_fail(1)) SWIG_fail;
9882 {
9883 PyThreadState* __tstate = wxPyBeginAllowThreads();
9884 result = (bool)((wxFont const *)arg1)->IsFixedWidth();
9885
9886 wxPyEndAllowThreads(__tstate);
9887 if (PyErr_Occurred()) SWIG_fail;
9888 }
9889 {
9890 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9891 }
9892 return resultobj;
9893 fail:
9894 return NULL;
9895 }
9896
9897
9898 static PyObject *_wrap_Font_GetNativeFontInfoDesc(PyObject *, PyObject *args, PyObject *kwargs) {
9899 PyObject *resultobj;
9900 wxFont *arg1 = (wxFont *) 0 ;
9901 wxString result;
9902 PyObject * obj0 = 0 ;
9903 char *kwnames[] = {
9904 (char *) "self", NULL
9905 };
9906
9907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoDesc",kwnames,&obj0)) goto fail;
9908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9909 if (SWIG_arg_fail(1)) SWIG_fail;
9910 {
9911 PyThreadState* __tstate = wxPyBeginAllowThreads();
9912 result = ((wxFont const *)arg1)->GetNativeFontInfoDesc();
9913
9914 wxPyEndAllowThreads(__tstate);
9915 if (PyErr_Occurred()) SWIG_fail;
9916 }
9917 {
9918 #if wxUSE_UNICODE
9919 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9920 #else
9921 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9922 #endif
9923 }
9924 return resultobj;
9925 fail:
9926 return NULL;
9927 }
9928
9929
9930 static PyObject *_wrap_Font_GetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
9931 PyObject *resultobj;
9932 wxFont *arg1 = (wxFont *) 0 ;
9933 wxString result;
9934 PyObject * obj0 = 0 ;
9935 char *kwnames[] = {
9936 (char *) "self", NULL
9937 };
9938
9939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoUserDesc",kwnames,&obj0)) goto fail;
9940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9941 if (SWIG_arg_fail(1)) SWIG_fail;
9942 {
9943 PyThreadState* __tstate = wxPyBeginAllowThreads();
9944 result = ((wxFont const *)arg1)->GetNativeFontInfoUserDesc();
9945
9946 wxPyEndAllowThreads(__tstate);
9947 if (PyErr_Occurred()) SWIG_fail;
9948 }
9949 {
9950 #if wxUSE_UNICODE
9951 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9952 #else
9953 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9954 #endif
9955 }
9956 return resultobj;
9957 fail:
9958 return NULL;
9959 }
9960
9961
9962 static PyObject *_wrap_Font_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
9963 PyObject *resultobj;
9964 wxFont *arg1 = (wxFont *) 0 ;
9965 int arg2 ;
9966 PyObject * obj0 = 0 ;
9967 PyObject * obj1 = 0 ;
9968 char *kwnames[] = {
9969 (char *) "self",(char *) "pointSize", NULL
9970 };
9971
9972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
9973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9974 if (SWIG_arg_fail(1)) SWIG_fail;
9975 {
9976 arg2 = (int)(SWIG_As_int(obj1));
9977 if (SWIG_arg_fail(2)) SWIG_fail;
9978 }
9979 {
9980 PyThreadState* __tstate = wxPyBeginAllowThreads();
9981 (arg1)->SetPointSize(arg2);
9982
9983 wxPyEndAllowThreads(__tstate);
9984 if (PyErr_Occurred()) SWIG_fail;
9985 }
9986 Py_INCREF(Py_None); resultobj = Py_None;
9987 return resultobj;
9988 fail:
9989 return NULL;
9990 }
9991
9992
9993 static PyObject *_wrap_Font_SetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
9994 PyObject *resultobj;
9995 wxFont *arg1 = (wxFont *) 0 ;
9996 wxSize *arg2 = 0 ;
9997 wxSize temp2 ;
9998 PyObject * obj0 = 0 ;
9999 PyObject * obj1 = 0 ;
10000 char *kwnames[] = {
10001 (char *) "self",(char *) "pixelSize", NULL
10002 };
10003
10004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPixelSize",kwnames,&obj0,&obj1)) goto fail;
10005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10006 if (SWIG_arg_fail(1)) SWIG_fail;
10007 {
10008 arg2 = &temp2;
10009 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
10010 }
10011 {
10012 PyThreadState* __tstate = wxPyBeginAllowThreads();
10013 (arg1)->SetPixelSize((wxSize const &)*arg2);
10014
10015 wxPyEndAllowThreads(__tstate);
10016 if (PyErr_Occurred()) SWIG_fail;
10017 }
10018 Py_INCREF(Py_None); resultobj = Py_None;
10019 return resultobj;
10020 fail:
10021 return NULL;
10022 }
10023
10024
10025 static PyObject *_wrap_Font_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
10026 PyObject *resultobj;
10027 wxFont *arg1 = (wxFont *) 0 ;
10028 int arg2 ;
10029 PyObject * obj0 = 0 ;
10030 PyObject * obj1 = 0 ;
10031 char *kwnames[] = {
10032 (char *) "self",(char *) "family", NULL
10033 };
10034
10035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFamily",kwnames,&obj0,&obj1)) goto fail;
10036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10037 if (SWIG_arg_fail(1)) SWIG_fail;
10038 {
10039 arg2 = (int)(SWIG_As_int(obj1));
10040 if (SWIG_arg_fail(2)) SWIG_fail;
10041 }
10042 {
10043 PyThreadState* __tstate = wxPyBeginAllowThreads();
10044 (arg1)->SetFamily(arg2);
10045
10046 wxPyEndAllowThreads(__tstate);
10047 if (PyErr_Occurred()) SWIG_fail;
10048 }
10049 Py_INCREF(Py_None); resultobj = Py_None;
10050 return resultobj;
10051 fail:
10052 return NULL;
10053 }
10054
10055
10056 static PyObject *_wrap_Font_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
10057 PyObject *resultobj;
10058 wxFont *arg1 = (wxFont *) 0 ;
10059 int arg2 ;
10060 PyObject * obj0 = 0 ;
10061 PyObject * obj1 = 0 ;
10062 char *kwnames[] = {
10063 (char *) "self",(char *) "style", NULL
10064 };
10065
10066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetStyle",kwnames,&obj0,&obj1)) goto fail;
10067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10068 if (SWIG_arg_fail(1)) SWIG_fail;
10069 {
10070 arg2 = (int)(SWIG_As_int(obj1));
10071 if (SWIG_arg_fail(2)) SWIG_fail;
10072 }
10073 {
10074 PyThreadState* __tstate = wxPyBeginAllowThreads();
10075 (arg1)->SetStyle(arg2);
10076
10077 wxPyEndAllowThreads(__tstate);
10078 if (PyErr_Occurred()) SWIG_fail;
10079 }
10080 Py_INCREF(Py_None); resultobj = Py_None;
10081 return resultobj;
10082 fail:
10083 return NULL;
10084 }
10085
10086
10087 static PyObject *_wrap_Font_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
10088 PyObject *resultobj;
10089 wxFont *arg1 = (wxFont *) 0 ;
10090 int arg2 ;
10091 PyObject * obj0 = 0 ;
10092 PyObject * obj1 = 0 ;
10093 char *kwnames[] = {
10094 (char *) "self",(char *) "weight", NULL
10095 };
10096
10097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetWeight",kwnames,&obj0,&obj1)) goto fail;
10098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10099 if (SWIG_arg_fail(1)) SWIG_fail;
10100 {
10101 arg2 = (int)(SWIG_As_int(obj1));
10102 if (SWIG_arg_fail(2)) SWIG_fail;
10103 }
10104 {
10105 PyThreadState* __tstate = wxPyBeginAllowThreads();
10106 (arg1)->SetWeight(arg2);
10107
10108 wxPyEndAllowThreads(__tstate);
10109 if (PyErr_Occurred()) SWIG_fail;
10110 }
10111 Py_INCREF(Py_None); resultobj = Py_None;
10112 return resultobj;
10113 fail:
10114 return NULL;
10115 }
10116
10117
10118 static PyObject *_wrap_Font_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
10119 PyObject *resultobj;
10120 wxFont *arg1 = (wxFont *) 0 ;
10121 wxString *arg2 = 0 ;
10122 bool temp2 = false ;
10123 PyObject * obj0 = 0 ;
10124 PyObject * obj1 = 0 ;
10125 char *kwnames[] = {
10126 (char *) "self",(char *) "faceName", NULL
10127 };
10128
10129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
10130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10131 if (SWIG_arg_fail(1)) SWIG_fail;
10132 {
10133 arg2 = wxString_in_helper(obj1);
10134 if (arg2 == NULL) SWIG_fail;
10135 temp2 = true;
10136 }
10137 {
10138 PyThreadState* __tstate = wxPyBeginAllowThreads();
10139 (arg1)->SetFaceName((wxString const &)*arg2);
10140
10141 wxPyEndAllowThreads(__tstate);
10142 if (PyErr_Occurred()) SWIG_fail;
10143 }
10144 Py_INCREF(Py_None); resultobj = Py_None;
10145 {
10146 if (temp2)
10147 delete arg2;
10148 }
10149 return resultobj;
10150 fail:
10151 {
10152 if (temp2)
10153 delete arg2;
10154 }
10155 return NULL;
10156 }
10157
10158
10159 static PyObject *_wrap_Font_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
10160 PyObject *resultobj;
10161 wxFont *arg1 = (wxFont *) 0 ;
10162 bool arg2 ;
10163 PyObject * obj0 = 0 ;
10164 PyObject * obj1 = 0 ;
10165 char *kwnames[] = {
10166 (char *) "self",(char *) "underlined", NULL
10167 };
10168
10169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
10170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10171 if (SWIG_arg_fail(1)) SWIG_fail;
10172 {
10173 arg2 = (bool)(SWIG_As_bool(obj1));
10174 if (SWIG_arg_fail(2)) SWIG_fail;
10175 }
10176 {
10177 PyThreadState* __tstate = wxPyBeginAllowThreads();
10178 (arg1)->SetUnderlined(arg2);
10179
10180 wxPyEndAllowThreads(__tstate);
10181 if (PyErr_Occurred()) SWIG_fail;
10182 }
10183 Py_INCREF(Py_None); resultobj = Py_None;
10184 return resultobj;
10185 fail:
10186 return NULL;
10187 }
10188
10189
10190 static PyObject *_wrap_Font_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10191 PyObject *resultobj;
10192 wxFont *arg1 = (wxFont *) 0 ;
10193 wxFontEncoding arg2 ;
10194 PyObject * obj0 = 0 ;
10195 PyObject * obj1 = 0 ;
10196 char *kwnames[] = {
10197 (char *) "self",(char *) "encoding", NULL
10198 };
10199
10200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
10201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10202 if (SWIG_arg_fail(1)) SWIG_fail;
10203 {
10204 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
10205 if (SWIG_arg_fail(2)) SWIG_fail;
10206 }
10207 {
10208 PyThreadState* __tstate = wxPyBeginAllowThreads();
10209 (arg1)->SetEncoding((wxFontEncoding )arg2);
10210
10211 wxPyEndAllowThreads(__tstate);
10212 if (PyErr_Occurred()) SWIG_fail;
10213 }
10214 Py_INCREF(Py_None); resultobj = Py_None;
10215 return resultobj;
10216 fail:
10217 return NULL;
10218 }
10219
10220
10221 static PyObject *_wrap_Font_SetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10222 PyObject *resultobj;
10223 wxFont *arg1 = (wxFont *) 0 ;
10224 wxNativeFontInfo *arg2 = 0 ;
10225 PyObject * obj0 = 0 ;
10226 PyObject * obj1 = 0 ;
10227 char *kwnames[] = {
10228 (char *) "self",(char *) "info", NULL
10229 };
10230
10231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfo",kwnames,&obj0,&obj1)) goto fail;
10232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10233 if (SWIG_arg_fail(1)) SWIG_fail;
10234 {
10235 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
10236 if (SWIG_arg_fail(2)) SWIG_fail;
10237 if (arg2 == NULL) {
10238 SWIG_null_ref("wxNativeFontInfo");
10239 }
10240 if (SWIG_arg_fail(2)) SWIG_fail;
10241 }
10242 {
10243 PyThreadState* __tstate = wxPyBeginAllowThreads();
10244 (arg1)->SetNativeFontInfo((wxNativeFontInfo const &)*arg2);
10245
10246 wxPyEndAllowThreads(__tstate);
10247 if (PyErr_Occurred()) SWIG_fail;
10248 }
10249 Py_INCREF(Py_None); resultobj = Py_None;
10250 return resultobj;
10251 fail:
10252 return NULL;
10253 }
10254
10255
10256 static PyObject *_wrap_Font_SetNativeFontInfoFromString(PyObject *, PyObject *args, PyObject *kwargs) {
10257 PyObject *resultobj;
10258 wxFont *arg1 = (wxFont *) 0 ;
10259 wxString *arg2 = 0 ;
10260 bool temp2 = false ;
10261 PyObject * obj0 = 0 ;
10262 PyObject * obj1 = 0 ;
10263 char *kwnames[] = {
10264 (char *) "self",(char *) "info", NULL
10265 };
10266
10267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoFromString",kwnames,&obj0,&obj1)) 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 arg2 = wxString_in_helper(obj1);
10272 if (arg2 == NULL) SWIG_fail;
10273 temp2 = true;
10274 }
10275 {
10276 PyThreadState* __tstate = wxPyBeginAllowThreads();
10277 (arg1)->SetNativeFontInfo((wxString const &)*arg2);
10278
10279 wxPyEndAllowThreads(__tstate);
10280 if (PyErr_Occurred()) SWIG_fail;
10281 }
10282 Py_INCREF(Py_None); resultobj = Py_None;
10283 {
10284 if (temp2)
10285 delete arg2;
10286 }
10287 return resultobj;
10288 fail:
10289 {
10290 if (temp2)
10291 delete arg2;
10292 }
10293 return NULL;
10294 }
10295
10296
10297 static PyObject *_wrap_Font_SetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10298 PyObject *resultobj;
10299 wxFont *arg1 = (wxFont *) 0 ;
10300 wxString *arg2 = 0 ;
10301 bool temp2 = false ;
10302 PyObject * obj0 = 0 ;
10303 PyObject * obj1 = 0 ;
10304 char *kwnames[] = {
10305 (char *) "self",(char *) "info", NULL
10306 };
10307
10308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoUserDesc",kwnames,&obj0,&obj1)) goto fail;
10309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10310 if (SWIG_arg_fail(1)) SWIG_fail;
10311 {
10312 arg2 = wxString_in_helper(obj1);
10313 if (arg2 == NULL) SWIG_fail;
10314 temp2 = true;
10315 }
10316 {
10317 PyThreadState* __tstate = wxPyBeginAllowThreads();
10318 (arg1)->SetNativeFontInfoUserDesc((wxString const &)*arg2);
10319
10320 wxPyEndAllowThreads(__tstate);
10321 if (PyErr_Occurred()) SWIG_fail;
10322 }
10323 Py_INCREF(Py_None); resultobj = Py_None;
10324 {
10325 if (temp2)
10326 delete arg2;
10327 }
10328 return resultobj;
10329 fail:
10330 {
10331 if (temp2)
10332 delete arg2;
10333 }
10334 return NULL;
10335 }
10336
10337
10338 static PyObject *_wrap_Font_GetFamilyString(PyObject *, PyObject *args, PyObject *kwargs) {
10339 PyObject *resultobj;
10340 wxFont *arg1 = (wxFont *) 0 ;
10341 wxString result;
10342 PyObject * obj0 = 0 ;
10343 char *kwnames[] = {
10344 (char *) "self", NULL
10345 };
10346
10347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamilyString",kwnames,&obj0)) goto fail;
10348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10349 if (SWIG_arg_fail(1)) SWIG_fail;
10350 {
10351 PyThreadState* __tstate = wxPyBeginAllowThreads();
10352 result = ((wxFont const *)arg1)->GetFamilyString();
10353
10354 wxPyEndAllowThreads(__tstate);
10355 if (PyErr_Occurred()) SWIG_fail;
10356 }
10357 {
10358 #if wxUSE_UNICODE
10359 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10360 #else
10361 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10362 #endif
10363 }
10364 return resultobj;
10365 fail:
10366 return NULL;
10367 }
10368
10369
10370 static PyObject *_wrap_Font_GetStyleString(PyObject *, PyObject *args, PyObject *kwargs) {
10371 PyObject *resultobj;
10372 wxFont *arg1 = (wxFont *) 0 ;
10373 wxString result;
10374 PyObject * obj0 = 0 ;
10375 char *kwnames[] = {
10376 (char *) "self", NULL
10377 };
10378
10379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyleString",kwnames,&obj0)) goto fail;
10380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10381 if (SWIG_arg_fail(1)) SWIG_fail;
10382 {
10383 PyThreadState* __tstate = wxPyBeginAllowThreads();
10384 result = ((wxFont const *)arg1)->GetStyleString();
10385
10386 wxPyEndAllowThreads(__tstate);
10387 if (PyErr_Occurred()) SWIG_fail;
10388 }
10389 {
10390 #if wxUSE_UNICODE
10391 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10392 #else
10393 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10394 #endif
10395 }
10396 return resultobj;
10397 fail:
10398 return NULL;
10399 }
10400
10401
10402 static PyObject *_wrap_Font_GetWeightString(PyObject *, PyObject *args, PyObject *kwargs) {
10403 PyObject *resultobj;
10404 wxFont *arg1 = (wxFont *) 0 ;
10405 wxString result;
10406 PyObject * obj0 = 0 ;
10407 char *kwnames[] = {
10408 (char *) "self", NULL
10409 };
10410
10411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeightString",kwnames,&obj0)) goto fail;
10412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10413 if (SWIG_arg_fail(1)) SWIG_fail;
10414 {
10415 PyThreadState* __tstate = wxPyBeginAllowThreads();
10416 result = ((wxFont const *)arg1)->GetWeightString();
10417
10418 wxPyEndAllowThreads(__tstate);
10419 if (PyErr_Occurred()) SWIG_fail;
10420 }
10421 {
10422 #if wxUSE_UNICODE
10423 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10424 #else
10425 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10426 #endif
10427 }
10428 return resultobj;
10429 fail:
10430 return NULL;
10431 }
10432
10433
10434 static PyObject *_wrap_Font_SetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
10435 PyObject *resultobj;
10436 wxFont *arg1 = (wxFont *) 0 ;
10437 bool arg2 = (bool) true ;
10438 PyObject * obj0 = 0 ;
10439 PyObject * obj1 = 0 ;
10440 char *kwnames[] = {
10441 (char *) "self",(char *) "no", NULL
10442 };
10443
10444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Font_SetNoAntiAliasing",kwnames,&obj0,&obj1)) goto fail;
10445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10446 if (SWIG_arg_fail(1)) SWIG_fail;
10447 if (obj1) {
10448 {
10449 arg2 = (bool)(SWIG_As_bool(obj1));
10450 if (SWIG_arg_fail(2)) SWIG_fail;
10451 }
10452 }
10453 {
10454 PyThreadState* __tstate = wxPyBeginAllowThreads();
10455 (arg1)->SetNoAntiAliasing(arg2);
10456
10457 wxPyEndAllowThreads(__tstate);
10458 if (PyErr_Occurred()) SWIG_fail;
10459 }
10460 Py_INCREF(Py_None); resultobj = Py_None;
10461 return resultobj;
10462 fail:
10463 return NULL;
10464 }
10465
10466
10467 static PyObject *_wrap_Font_GetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
10468 PyObject *resultobj;
10469 wxFont *arg1 = (wxFont *) 0 ;
10470 bool result;
10471 PyObject * obj0 = 0 ;
10472 char *kwnames[] = {
10473 (char *) "self", NULL
10474 };
10475
10476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNoAntiAliasing",kwnames,&obj0)) goto fail;
10477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10478 if (SWIG_arg_fail(1)) SWIG_fail;
10479 {
10480 PyThreadState* __tstate = wxPyBeginAllowThreads();
10481 result = (bool)((wxFont const *)arg1)->GetNoAntiAliasing();
10482
10483 wxPyEndAllowThreads(__tstate);
10484 if (PyErr_Occurred()) SWIG_fail;
10485 }
10486 {
10487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10488 }
10489 return resultobj;
10490 fail:
10491 return NULL;
10492 }
10493
10494
10495 static PyObject *_wrap_Font_GetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10496 PyObject *resultobj;
10497 wxFontEncoding result;
10498 char *kwnames[] = {
10499 NULL
10500 };
10501
10502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Font_GetDefaultEncoding",kwnames)) goto fail;
10503 {
10504 if (!wxPyCheckForApp()) SWIG_fail;
10505 PyThreadState* __tstate = wxPyBeginAllowThreads();
10506 result = (wxFontEncoding)wxFont::GetDefaultEncoding();
10507
10508 wxPyEndAllowThreads(__tstate);
10509 if (PyErr_Occurred()) SWIG_fail;
10510 }
10511 resultobj = SWIG_From_int((result));
10512 return resultobj;
10513 fail:
10514 return NULL;
10515 }
10516
10517
10518 static PyObject *_wrap_Font_SetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10519 PyObject *resultobj;
10520 wxFontEncoding arg1 ;
10521 PyObject * obj0 = 0 ;
10522 char *kwnames[] = {
10523 (char *) "encoding", NULL
10524 };
10525
10526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_SetDefaultEncoding",kwnames,&obj0)) goto fail;
10527 {
10528 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
10529 if (SWIG_arg_fail(1)) SWIG_fail;
10530 }
10531 {
10532 if (!wxPyCheckForApp()) SWIG_fail;
10533 PyThreadState* __tstate = wxPyBeginAllowThreads();
10534 wxFont::SetDefaultEncoding((wxFontEncoding )arg1);
10535
10536 wxPyEndAllowThreads(__tstate);
10537 if (PyErr_Occurred()) SWIG_fail;
10538 }
10539 Py_INCREF(Py_None); resultobj = Py_None;
10540 return resultobj;
10541 fail:
10542 return NULL;
10543 }
10544
10545
10546 static PyObject * Font_swigregister(PyObject *, PyObject *args) {
10547 PyObject *obj;
10548 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10549 SWIG_TypeClientData(SWIGTYPE_p_wxFont, obj);
10550 Py_INCREF(obj);
10551 return Py_BuildValue((char *)"");
10552 }
10553 static PyObject *_wrap_new_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
10554 PyObject *resultobj;
10555 wxPyFontEnumerator *result;
10556 char *kwnames[] = {
10557 NULL
10558 };
10559
10560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontEnumerator",kwnames)) goto fail;
10561 {
10562 if (!wxPyCheckForApp()) SWIG_fail;
10563 PyThreadState* __tstate = wxPyBeginAllowThreads();
10564 result = (wxPyFontEnumerator *)new wxPyFontEnumerator();
10565
10566 wxPyEndAllowThreads(__tstate);
10567 if (PyErr_Occurred()) SWIG_fail;
10568 }
10569 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFontEnumerator, 1);
10570 return resultobj;
10571 fail:
10572 return NULL;
10573 }
10574
10575
10576 static PyObject *_wrap_delete_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
10577 PyObject *resultobj;
10578 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10579 PyObject * obj0 = 0 ;
10580 char *kwnames[] = {
10581 (char *) "self", NULL
10582 };
10583
10584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontEnumerator",kwnames,&obj0)) goto fail;
10585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10586 if (SWIG_arg_fail(1)) SWIG_fail;
10587 {
10588 PyThreadState* __tstate = wxPyBeginAllowThreads();
10589 delete arg1;
10590
10591 wxPyEndAllowThreads(__tstate);
10592 if (PyErr_Occurred()) SWIG_fail;
10593 }
10594 Py_INCREF(Py_None); resultobj = Py_None;
10595 return resultobj;
10596 fail:
10597 return NULL;
10598 }
10599
10600
10601 static PyObject *_wrap_FontEnumerator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10602 PyObject *resultobj;
10603 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10604 PyObject *arg2 = (PyObject *) 0 ;
10605 PyObject *arg3 = (PyObject *) 0 ;
10606 bool arg4 ;
10607 PyObject * obj0 = 0 ;
10608 PyObject * obj1 = 0 ;
10609 PyObject * obj2 = 0 ;
10610 PyObject * obj3 = 0 ;
10611 char *kwnames[] = {
10612 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
10613 };
10614
10615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FontEnumerator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10617 if (SWIG_arg_fail(1)) SWIG_fail;
10618 arg2 = obj1;
10619 arg3 = obj2;
10620 {
10621 arg4 = (bool)(SWIG_As_bool(obj3));
10622 if (SWIG_arg_fail(4)) SWIG_fail;
10623 }
10624 {
10625 PyThreadState* __tstate = wxPyBeginAllowThreads();
10626 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
10627
10628 wxPyEndAllowThreads(__tstate);
10629 if (PyErr_Occurred()) SWIG_fail;
10630 }
10631 Py_INCREF(Py_None); resultobj = Py_None;
10632 return resultobj;
10633 fail:
10634 return NULL;
10635 }
10636
10637
10638 static PyObject *_wrap_FontEnumerator_EnumerateFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
10639 PyObject *resultobj;
10640 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10641 wxFontEncoding arg2 = (wxFontEncoding) wxFONTENCODING_SYSTEM ;
10642 bool arg3 = (bool) false ;
10643 bool result;
10644 PyObject * obj0 = 0 ;
10645 PyObject * obj1 = 0 ;
10646 PyObject * obj2 = 0 ;
10647 char *kwnames[] = {
10648 (char *) "self",(char *) "encoding",(char *) "fixedWidthOnly", NULL
10649 };
10650
10651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FontEnumerator_EnumerateFacenames",kwnames,&obj0,&obj1,&obj2)) goto fail;
10652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10653 if (SWIG_arg_fail(1)) SWIG_fail;
10654 if (obj1) {
10655 {
10656 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
10657 if (SWIG_arg_fail(2)) SWIG_fail;
10658 }
10659 }
10660 if (obj2) {
10661 {
10662 arg3 = (bool)(SWIG_As_bool(obj2));
10663 if (SWIG_arg_fail(3)) SWIG_fail;
10664 }
10665 }
10666 {
10667 PyThreadState* __tstate = wxPyBeginAllowThreads();
10668 result = (bool)(arg1)->EnumerateFacenames((wxFontEncoding )arg2,arg3);
10669
10670 wxPyEndAllowThreads(__tstate);
10671 if (PyErr_Occurred()) SWIG_fail;
10672 }
10673 {
10674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10675 }
10676 return resultobj;
10677 fail:
10678 return NULL;
10679 }
10680
10681
10682 static PyObject *_wrap_FontEnumerator_EnumerateEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
10683 PyObject *resultobj;
10684 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10685 wxString const &arg2_defvalue = wxPyEmptyString ;
10686 wxString *arg2 = (wxString *) &arg2_defvalue ;
10687 bool result;
10688 bool temp2 = false ;
10689 PyObject * obj0 = 0 ;
10690 PyObject * obj1 = 0 ;
10691 char *kwnames[] = {
10692 (char *) "self",(char *) "facename", NULL
10693 };
10694
10695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FontEnumerator_EnumerateEncodings",kwnames,&obj0,&obj1)) goto fail;
10696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10697 if (SWIG_arg_fail(1)) SWIG_fail;
10698 if (obj1) {
10699 {
10700 arg2 = wxString_in_helper(obj1);
10701 if (arg2 == NULL) SWIG_fail;
10702 temp2 = true;
10703 }
10704 }
10705 {
10706 PyThreadState* __tstate = wxPyBeginAllowThreads();
10707 result = (bool)(arg1)->EnumerateEncodings((wxString const &)*arg2);
10708
10709 wxPyEndAllowThreads(__tstate);
10710 if (PyErr_Occurred()) SWIG_fail;
10711 }
10712 {
10713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10714 }
10715 {
10716 if (temp2)
10717 delete arg2;
10718 }
10719 return resultobj;
10720 fail:
10721 {
10722 if (temp2)
10723 delete arg2;
10724 }
10725 return NULL;
10726 }
10727
10728
10729 static PyObject *_wrap_FontEnumerator_GetEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
10730 PyObject *resultobj;
10731 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10732 PyObject *result;
10733 PyObject * obj0 = 0 ;
10734 char *kwnames[] = {
10735 (char *) "self", NULL
10736 };
10737
10738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetEncodings",kwnames,&obj0)) goto fail;
10739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10740 if (SWIG_arg_fail(1)) SWIG_fail;
10741 {
10742 PyThreadState* __tstate = wxPyBeginAllowThreads();
10743 result = (PyObject *)wxPyFontEnumerator_GetEncodings(arg1);
10744
10745 wxPyEndAllowThreads(__tstate);
10746 if (PyErr_Occurred()) SWIG_fail;
10747 }
10748 resultobj = result;
10749 return resultobj;
10750 fail:
10751 return NULL;
10752 }
10753
10754
10755 static PyObject *_wrap_FontEnumerator_GetFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
10756 PyObject *resultobj;
10757 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10758 PyObject *result;
10759 PyObject * obj0 = 0 ;
10760 char *kwnames[] = {
10761 (char *) "self", NULL
10762 };
10763
10764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetFacenames",kwnames,&obj0)) goto fail;
10765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10766 if (SWIG_arg_fail(1)) SWIG_fail;
10767 {
10768 PyThreadState* __tstate = wxPyBeginAllowThreads();
10769 result = (PyObject *)wxPyFontEnumerator_GetFacenames(arg1);
10770
10771 wxPyEndAllowThreads(__tstate);
10772 if (PyErr_Occurred()) SWIG_fail;
10773 }
10774 resultobj = result;
10775 return resultobj;
10776 fail:
10777 return NULL;
10778 }
10779
10780
10781 static PyObject * FontEnumerator_swigregister(PyObject *, PyObject *args) {
10782 PyObject *obj;
10783 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10784 SWIG_TypeClientData(SWIGTYPE_p_wxPyFontEnumerator, obj);
10785 Py_INCREF(obj);
10786 return Py_BuildValue((char *)"");
10787 }
10788 static PyObject *_wrap_LanguageInfo_Language_set(PyObject *, PyObject *args, PyObject *kwargs) {
10789 PyObject *resultobj;
10790 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10791 int arg2 ;
10792 PyObject * obj0 = 0 ;
10793 PyObject * obj1 = 0 ;
10794 char *kwnames[] = {
10795 (char *) "self",(char *) "Language", NULL
10796 };
10797
10798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Language_set",kwnames,&obj0,&obj1)) goto fail;
10799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10800 if (SWIG_arg_fail(1)) SWIG_fail;
10801 {
10802 arg2 = (int)(SWIG_As_int(obj1));
10803 if (SWIG_arg_fail(2)) SWIG_fail;
10804 }
10805 if (arg1) (arg1)->Language = arg2;
10806
10807 Py_INCREF(Py_None); resultobj = Py_None;
10808 return resultobj;
10809 fail:
10810 return NULL;
10811 }
10812
10813
10814 static PyObject *_wrap_LanguageInfo_Language_get(PyObject *, PyObject *args, PyObject *kwargs) {
10815 PyObject *resultobj;
10816 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10817 int result;
10818 PyObject * obj0 = 0 ;
10819 char *kwnames[] = {
10820 (char *) "self", NULL
10821 };
10822
10823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Language_get",kwnames,&obj0)) goto fail;
10824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10825 if (SWIG_arg_fail(1)) SWIG_fail;
10826 result = (int) ((arg1)->Language);
10827
10828 {
10829 resultobj = SWIG_From_int((int)(result));
10830 }
10831 return resultobj;
10832 fail:
10833 return NULL;
10834 }
10835
10836
10837 static PyObject *_wrap_LanguageInfo_CanonicalName_set(PyObject *, PyObject *args, PyObject *kwargs) {
10838 PyObject *resultobj;
10839 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10840 wxString *arg2 = (wxString *) 0 ;
10841 bool temp2 = false ;
10842 PyObject * obj0 = 0 ;
10843 PyObject * obj1 = 0 ;
10844 char *kwnames[] = {
10845 (char *) "self",(char *) "CanonicalName", NULL
10846 };
10847
10848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_CanonicalName_set",kwnames,&obj0,&obj1)) goto fail;
10849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10850 if (SWIG_arg_fail(1)) SWIG_fail;
10851 {
10852 arg2 = wxString_in_helper(obj1);
10853 if (arg2 == NULL) SWIG_fail;
10854 temp2 = true;
10855 }
10856 if (arg1) (arg1)->CanonicalName = *arg2;
10857
10858 Py_INCREF(Py_None); resultobj = Py_None;
10859 {
10860 if (temp2)
10861 delete arg2;
10862 }
10863 return resultobj;
10864 fail:
10865 {
10866 if (temp2)
10867 delete arg2;
10868 }
10869 return NULL;
10870 }
10871
10872
10873 static PyObject *_wrap_LanguageInfo_CanonicalName_get(PyObject *, PyObject *args, PyObject *kwargs) {
10874 PyObject *resultobj;
10875 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10876 wxString *result;
10877 PyObject * obj0 = 0 ;
10878 char *kwnames[] = {
10879 (char *) "self", NULL
10880 };
10881
10882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_CanonicalName_get",kwnames,&obj0)) goto fail;
10883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10884 if (SWIG_arg_fail(1)) SWIG_fail;
10885 result = (wxString *)& ((arg1)->CanonicalName);
10886
10887 {
10888 #if wxUSE_UNICODE
10889 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10890 #else
10891 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10892 #endif
10893 }
10894 return resultobj;
10895 fail:
10896 return NULL;
10897 }
10898
10899
10900 static PyObject *_wrap_LanguageInfo_Description_set(PyObject *, PyObject *args, PyObject *kwargs) {
10901 PyObject *resultobj;
10902 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10903 wxString *arg2 = (wxString *) 0 ;
10904 bool temp2 = false ;
10905 PyObject * obj0 = 0 ;
10906 PyObject * obj1 = 0 ;
10907 char *kwnames[] = {
10908 (char *) "self",(char *) "Description", NULL
10909 };
10910
10911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Description_set",kwnames,&obj0,&obj1)) goto fail;
10912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10913 if (SWIG_arg_fail(1)) SWIG_fail;
10914 {
10915 arg2 = wxString_in_helper(obj1);
10916 if (arg2 == NULL) SWIG_fail;
10917 temp2 = true;
10918 }
10919 if (arg1) (arg1)->Description = *arg2;
10920
10921 Py_INCREF(Py_None); resultobj = Py_None;
10922 {
10923 if (temp2)
10924 delete arg2;
10925 }
10926 return resultobj;
10927 fail:
10928 {
10929 if (temp2)
10930 delete arg2;
10931 }
10932 return NULL;
10933 }
10934
10935
10936 static PyObject *_wrap_LanguageInfo_Description_get(PyObject *, PyObject *args, PyObject *kwargs) {
10937 PyObject *resultobj;
10938 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10939 wxString *result;
10940 PyObject * obj0 = 0 ;
10941 char *kwnames[] = {
10942 (char *) "self", NULL
10943 };
10944
10945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Description_get",kwnames,&obj0)) goto fail;
10946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10947 if (SWIG_arg_fail(1)) SWIG_fail;
10948 result = (wxString *)& ((arg1)->Description);
10949
10950 {
10951 #if wxUSE_UNICODE
10952 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10953 #else
10954 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10955 #endif
10956 }
10957 return resultobj;
10958 fail:
10959 return NULL;
10960 }
10961
10962
10963 static PyObject * LanguageInfo_swigregister(PyObject *, PyObject *args) {
10964 PyObject *obj;
10965 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10966 SWIG_TypeClientData(SWIGTYPE_p_wxLanguageInfo, obj);
10967 Py_INCREF(obj);
10968 return Py_BuildValue((char *)"");
10969 }
10970 static PyObject *_wrap_new_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
10971 PyObject *resultobj;
10972 int arg1 = (int) -1 ;
10973 int arg2 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
10974 wxLocale *result;
10975 PyObject * obj0 = 0 ;
10976 PyObject * obj1 = 0 ;
10977 char *kwnames[] = {
10978 (char *) "language",(char *) "flags", NULL
10979 };
10980
10981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Locale",kwnames,&obj0,&obj1)) goto fail;
10982 if (obj0) {
10983 {
10984 arg1 = (int)(SWIG_As_int(obj0));
10985 if (SWIG_arg_fail(1)) SWIG_fail;
10986 }
10987 }
10988 if (obj1) {
10989 {
10990 arg2 = (int)(SWIG_As_int(obj1));
10991 if (SWIG_arg_fail(2)) SWIG_fail;
10992 }
10993 }
10994 {
10995 PyThreadState* __tstate = wxPyBeginAllowThreads();
10996 result = (wxLocale *)new_wxLocale(arg1,arg2);
10997
10998 wxPyEndAllowThreads(__tstate);
10999 if (PyErr_Occurred()) SWIG_fail;
11000 }
11001 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 1);
11002 return resultobj;
11003 fail:
11004 return NULL;
11005 }
11006
11007
11008 static PyObject *_wrap_delete_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
11009 PyObject *resultobj;
11010 wxLocale *arg1 = (wxLocale *) 0 ;
11011 PyObject * obj0 = 0 ;
11012 char *kwnames[] = {
11013 (char *) "self", NULL
11014 };
11015
11016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Locale",kwnames,&obj0)) goto fail;
11017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11018 if (SWIG_arg_fail(1)) SWIG_fail;
11019 {
11020 PyThreadState* __tstate = wxPyBeginAllowThreads();
11021 delete arg1;
11022
11023 wxPyEndAllowThreads(__tstate);
11024 if (PyErr_Occurred()) SWIG_fail;
11025 }
11026 Py_INCREF(Py_None); resultobj = Py_None;
11027 return resultobj;
11028 fail:
11029 return NULL;
11030 }
11031
11032
11033 static PyObject *_wrap_Locale_Init1(PyObject *, PyObject *args, PyObject *kwargs) {
11034 PyObject *resultobj;
11035 wxLocale *arg1 = (wxLocale *) 0 ;
11036 wxString *arg2 = 0 ;
11037 wxString const &arg3_defvalue = wxPyEmptyString ;
11038 wxString *arg3 = (wxString *) &arg3_defvalue ;
11039 wxString const &arg4_defvalue = wxPyEmptyString ;
11040 wxString *arg4 = (wxString *) &arg4_defvalue ;
11041 bool arg5 = (bool) true ;
11042 bool arg6 = (bool) false ;
11043 bool result;
11044 bool temp2 = false ;
11045 bool temp3 = false ;
11046 bool temp4 = false ;
11047 PyObject * obj0 = 0 ;
11048 PyObject * obj1 = 0 ;
11049 PyObject * obj2 = 0 ;
11050 PyObject * obj3 = 0 ;
11051 PyObject * obj4 = 0 ;
11052 PyObject * obj5 = 0 ;
11053 char *kwnames[] = {
11054 (char *) "self",(char *) "szName",(char *) "szShort",(char *) "szLocale",(char *) "bLoadDefault",(char *) "bConvertEncoding", NULL
11055 };
11056
11057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Locale_Init1",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11059 if (SWIG_arg_fail(1)) SWIG_fail;
11060 {
11061 arg2 = wxString_in_helper(obj1);
11062 if (arg2 == NULL) SWIG_fail;
11063 temp2 = true;
11064 }
11065 if (obj2) {
11066 {
11067 arg3 = wxString_in_helper(obj2);
11068 if (arg3 == NULL) SWIG_fail;
11069 temp3 = true;
11070 }
11071 }
11072 if (obj3) {
11073 {
11074 arg4 = wxString_in_helper(obj3);
11075 if (arg4 == NULL) SWIG_fail;
11076 temp4 = true;
11077 }
11078 }
11079 if (obj4) {
11080 {
11081 arg5 = (bool)(SWIG_As_bool(obj4));
11082 if (SWIG_arg_fail(5)) SWIG_fail;
11083 }
11084 }
11085 if (obj5) {
11086 {
11087 arg6 = (bool)(SWIG_As_bool(obj5));
11088 if (SWIG_arg_fail(6)) SWIG_fail;
11089 }
11090 }
11091 {
11092 PyThreadState* __tstate = wxPyBeginAllowThreads();
11093 result = (bool)wxLocale_Init1(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
11094
11095 wxPyEndAllowThreads(__tstate);
11096 if (PyErr_Occurred()) SWIG_fail;
11097 }
11098 {
11099 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11100 }
11101 {
11102 if (temp2)
11103 delete arg2;
11104 }
11105 {
11106 if (temp3)
11107 delete arg3;
11108 }
11109 {
11110 if (temp4)
11111 delete arg4;
11112 }
11113 return resultobj;
11114 fail:
11115 {
11116 if (temp2)
11117 delete arg2;
11118 }
11119 {
11120 if (temp3)
11121 delete arg3;
11122 }
11123 {
11124 if (temp4)
11125 delete arg4;
11126 }
11127 return NULL;
11128 }
11129
11130
11131 static PyObject *_wrap_Locale_Init2(PyObject *, PyObject *args, PyObject *kwargs) {
11132 PyObject *resultobj;
11133 wxLocale *arg1 = (wxLocale *) 0 ;
11134 int arg2 = (int) wxLANGUAGE_DEFAULT ;
11135 int arg3 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
11136 bool result;
11137 PyObject * obj0 = 0 ;
11138 PyObject * obj1 = 0 ;
11139 PyObject * obj2 = 0 ;
11140 char *kwnames[] = {
11141 (char *) "self",(char *) "language",(char *) "flags", NULL
11142 };
11143
11144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Locale_Init2",kwnames,&obj0,&obj1,&obj2)) goto fail;
11145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11146 if (SWIG_arg_fail(1)) SWIG_fail;
11147 if (obj1) {
11148 {
11149 arg2 = (int)(SWIG_As_int(obj1));
11150 if (SWIG_arg_fail(2)) SWIG_fail;
11151 }
11152 }
11153 if (obj2) {
11154 {
11155 arg3 = (int)(SWIG_As_int(obj2));
11156 if (SWIG_arg_fail(3)) SWIG_fail;
11157 }
11158 }
11159 {
11160 PyThreadState* __tstate = wxPyBeginAllowThreads();
11161 result = (bool)wxLocale_Init2(arg1,arg2,arg3);
11162
11163 wxPyEndAllowThreads(__tstate);
11164 if (PyErr_Occurred()) SWIG_fail;
11165 }
11166 {
11167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11168 }
11169 return resultobj;
11170 fail:
11171 return NULL;
11172 }
11173
11174
11175 static PyObject *_wrap_Locale_GetSystemLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11176 PyObject *resultobj;
11177 int result;
11178 char *kwnames[] = {
11179 NULL
11180 };
11181
11182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemLanguage",kwnames)) goto fail;
11183 {
11184 PyThreadState* __tstate = wxPyBeginAllowThreads();
11185 result = (int)wxLocale::GetSystemLanguage();
11186
11187 wxPyEndAllowThreads(__tstate);
11188 if (PyErr_Occurred()) SWIG_fail;
11189 }
11190 {
11191 resultobj = SWIG_From_int((int)(result));
11192 }
11193 return resultobj;
11194 fail:
11195 return NULL;
11196 }
11197
11198
11199 static PyObject *_wrap_Locale_GetSystemEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
11200 PyObject *resultobj;
11201 wxFontEncoding result;
11202 char *kwnames[] = {
11203 NULL
11204 };
11205
11206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncoding",kwnames)) goto fail;
11207 {
11208 PyThreadState* __tstate = wxPyBeginAllowThreads();
11209 result = (wxFontEncoding)wxLocale::GetSystemEncoding();
11210
11211 wxPyEndAllowThreads(__tstate);
11212 if (PyErr_Occurred()) SWIG_fail;
11213 }
11214 resultobj = SWIG_From_int((result));
11215 return resultobj;
11216 fail:
11217 return NULL;
11218 }
11219
11220
11221 static PyObject *_wrap_Locale_GetSystemEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
11222 PyObject *resultobj;
11223 wxString result;
11224 char *kwnames[] = {
11225 NULL
11226 };
11227
11228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncodingName",kwnames)) goto fail;
11229 {
11230 PyThreadState* __tstate = wxPyBeginAllowThreads();
11231 result = wxLocale::GetSystemEncodingName();
11232
11233 wxPyEndAllowThreads(__tstate);
11234 if (PyErr_Occurred()) SWIG_fail;
11235 }
11236 {
11237 #if wxUSE_UNICODE
11238 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11239 #else
11240 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11241 #endif
11242 }
11243 return resultobj;
11244 fail:
11245 return NULL;
11246 }
11247
11248
11249 static PyObject *_wrap_Locale_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11250 PyObject *resultobj;
11251 wxLocale *arg1 = (wxLocale *) 0 ;
11252 bool result;
11253 PyObject * obj0 = 0 ;
11254 char *kwnames[] = {
11255 (char *) "self", NULL
11256 };
11257
11258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_IsOk",kwnames,&obj0)) goto fail;
11259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11260 if (SWIG_arg_fail(1)) SWIG_fail;
11261 {
11262 PyThreadState* __tstate = wxPyBeginAllowThreads();
11263 result = (bool)((wxLocale const *)arg1)->IsOk();
11264
11265 wxPyEndAllowThreads(__tstate);
11266 if (PyErr_Occurred()) SWIG_fail;
11267 }
11268 {
11269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11270 }
11271 return resultobj;
11272 fail:
11273 return NULL;
11274 }
11275
11276
11277 static PyObject *_wrap_Locale_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
11278 PyObject *resultobj;
11279 wxLocale *arg1 = (wxLocale *) 0 ;
11280 wxString result;
11281 PyObject * obj0 = 0 ;
11282 char *kwnames[] = {
11283 (char *) "self", NULL
11284 };
11285
11286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLocale",kwnames,&obj0)) goto fail;
11287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11288 if (SWIG_arg_fail(1)) SWIG_fail;
11289 {
11290 PyThreadState* __tstate = wxPyBeginAllowThreads();
11291 result = ((wxLocale const *)arg1)->GetLocale();
11292
11293 wxPyEndAllowThreads(__tstate);
11294 if (PyErr_Occurred()) SWIG_fail;
11295 }
11296 {
11297 #if wxUSE_UNICODE
11298 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11299 #else
11300 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11301 #endif
11302 }
11303 return resultobj;
11304 fail:
11305 return NULL;
11306 }
11307
11308
11309 static PyObject *_wrap_Locale_GetLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11310 PyObject *resultobj;
11311 wxLocale *arg1 = (wxLocale *) 0 ;
11312 int result;
11313 PyObject * obj0 = 0 ;
11314 char *kwnames[] = {
11315 (char *) "self", NULL
11316 };
11317
11318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguage",kwnames,&obj0)) goto fail;
11319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11320 if (SWIG_arg_fail(1)) SWIG_fail;
11321 {
11322 PyThreadState* __tstate = wxPyBeginAllowThreads();
11323 result = (int)((wxLocale const *)arg1)->GetLanguage();
11324
11325 wxPyEndAllowThreads(__tstate);
11326 if (PyErr_Occurred()) SWIG_fail;
11327 }
11328 {
11329 resultobj = SWIG_From_int((int)(result));
11330 }
11331 return resultobj;
11332 fail:
11333 return NULL;
11334 }
11335
11336
11337 static PyObject *_wrap_Locale_GetSysName(PyObject *, PyObject *args, PyObject *kwargs) {
11338 PyObject *resultobj;
11339 wxLocale *arg1 = (wxLocale *) 0 ;
11340 wxString result;
11341 PyObject * obj0 = 0 ;
11342 char *kwnames[] = {
11343 (char *) "self", NULL
11344 };
11345
11346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetSysName",kwnames,&obj0)) goto fail;
11347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11348 if (SWIG_arg_fail(1)) SWIG_fail;
11349 {
11350 PyThreadState* __tstate = wxPyBeginAllowThreads();
11351 result = ((wxLocale const *)arg1)->GetSysName();
11352
11353 wxPyEndAllowThreads(__tstate);
11354 if (PyErr_Occurred()) SWIG_fail;
11355 }
11356 {
11357 #if wxUSE_UNICODE
11358 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11359 #else
11360 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11361 #endif
11362 }
11363 return resultobj;
11364 fail:
11365 return NULL;
11366 }
11367
11368
11369 static PyObject *_wrap_Locale_GetCanonicalName(PyObject *, PyObject *args, PyObject *kwargs) {
11370 PyObject *resultobj;
11371 wxLocale *arg1 = (wxLocale *) 0 ;
11372 wxString result;
11373 PyObject * obj0 = 0 ;
11374 char *kwnames[] = {
11375 (char *) "self", NULL
11376 };
11377
11378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetCanonicalName",kwnames,&obj0)) goto fail;
11379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11380 if (SWIG_arg_fail(1)) SWIG_fail;
11381 {
11382 PyThreadState* __tstate = wxPyBeginAllowThreads();
11383 result = ((wxLocale const *)arg1)->GetCanonicalName();
11384
11385 wxPyEndAllowThreads(__tstate);
11386 if (PyErr_Occurred()) SWIG_fail;
11387 }
11388 {
11389 #if wxUSE_UNICODE
11390 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11391 #else
11392 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11393 #endif
11394 }
11395 return resultobj;
11396 fail:
11397 return NULL;
11398 }
11399
11400
11401 static PyObject *_wrap_Locale_AddCatalogLookupPathPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
11402 PyObject *resultobj;
11403 wxString *arg1 = 0 ;
11404 bool temp1 = false ;
11405 PyObject * obj0 = 0 ;
11406 char *kwnames[] = {
11407 (char *) "prefix", NULL
11408 };
11409
11410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddCatalogLookupPathPrefix",kwnames,&obj0)) goto fail;
11411 {
11412 arg1 = wxString_in_helper(obj0);
11413 if (arg1 == NULL) SWIG_fail;
11414 temp1 = true;
11415 }
11416 {
11417 PyThreadState* __tstate = wxPyBeginAllowThreads();
11418 wxLocale::AddCatalogLookupPathPrefix((wxString const &)*arg1);
11419
11420 wxPyEndAllowThreads(__tstate);
11421 if (PyErr_Occurred()) SWIG_fail;
11422 }
11423 Py_INCREF(Py_None); resultobj = Py_None;
11424 {
11425 if (temp1)
11426 delete arg1;
11427 }
11428 return resultobj;
11429 fail:
11430 {
11431 if (temp1)
11432 delete arg1;
11433 }
11434 return NULL;
11435 }
11436
11437
11438 static PyObject *_wrap_Locale_AddCatalog(PyObject *, PyObject *args, PyObject *kwargs) {
11439 PyObject *resultobj;
11440 wxLocale *arg1 = (wxLocale *) 0 ;
11441 wxString *arg2 = 0 ;
11442 bool result;
11443 bool temp2 = false ;
11444 PyObject * obj0 = 0 ;
11445 PyObject * obj1 = 0 ;
11446 char *kwnames[] = {
11447 (char *) "self",(char *) "szDomain", NULL
11448 };
11449
11450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_AddCatalog",kwnames,&obj0,&obj1)) goto fail;
11451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11452 if (SWIG_arg_fail(1)) SWIG_fail;
11453 {
11454 arg2 = wxString_in_helper(obj1);
11455 if (arg2 == NULL) SWIG_fail;
11456 temp2 = true;
11457 }
11458 {
11459 PyThreadState* __tstate = wxPyBeginAllowThreads();
11460 result = (bool)(arg1)->AddCatalog((wxString const &)*arg2);
11461
11462 wxPyEndAllowThreads(__tstate);
11463 if (PyErr_Occurred()) SWIG_fail;
11464 }
11465 {
11466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11467 }
11468 {
11469 if (temp2)
11470 delete arg2;
11471 }
11472 return resultobj;
11473 fail:
11474 {
11475 if (temp2)
11476 delete arg2;
11477 }
11478 return NULL;
11479 }
11480
11481
11482 static PyObject *_wrap_Locale_IsLoaded(PyObject *, PyObject *args, PyObject *kwargs) {
11483 PyObject *resultobj;
11484 wxLocale *arg1 = (wxLocale *) 0 ;
11485 wxString *arg2 = 0 ;
11486 bool result;
11487 bool temp2 = false ;
11488 PyObject * obj0 = 0 ;
11489 PyObject * obj1 = 0 ;
11490 char *kwnames[] = {
11491 (char *) "self",(char *) "szDomain", NULL
11492 };
11493
11494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_IsLoaded",kwnames,&obj0,&obj1)) goto fail;
11495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11496 if (SWIG_arg_fail(1)) SWIG_fail;
11497 {
11498 arg2 = wxString_in_helper(obj1);
11499 if (arg2 == NULL) SWIG_fail;
11500 temp2 = true;
11501 }
11502 {
11503 PyThreadState* __tstate = wxPyBeginAllowThreads();
11504 result = (bool)((wxLocale const *)arg1)->IsLoaded((wxString const &)*arg2);
11505
11506 wxPyEndAllowThreads(__tstate);
11507 if (PyErr_Occurred()) SWIG_fail;
11508 }
11509 {
11510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11511 }
11512 {
11513 if (temp2)
11514 delete arg2;
11515 }
11516 return resultobj;
11517 fail:
11518 {
11519 if (temp2)
11520 delete arg2;
11521 }
11522 return NULL;
11523 }
11524
11525
11526 static PyObject *_wrap_Locale_GetLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11527 PyObject *resultobj;
11528 int arg1 ;
11529 wxLanguageInfo *result;
11530 PyObject * obj0 = 0 ;
11531 char *kwnames[] = {
11532 (char *) "lang", NULL
11533 };
11534
11535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageInfo",kwnames,&obj0)) goto fail;
11536 {
11537 arg1 = (int)(SWIG_As_int(obj0));
11538 if (SWIG_arg_fail(1)) SWIG_fail;
11539 }
11540 {
11541 PyThreadState* __tstate = wxPyBeginAllowThreads();
11542 result = (wxLanguageInfo *)wxLocale::GetLanguageInfo(arg1);
11543
11544 wxPyEndAllowThreads(__tstate);
11545 if (PyErr_Occurred()) SWIG_fail;
11546 }
11547 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
11548 return resultobj;
11549 fail:
11550 return NULL;
11551 }
11552
11553
11554 static PyObject *_wrap_Locale_GetLanguageName(PyObject *, PyObject *args, PyObject *kwargs) {
11555 PyObject *resultobj;
11556 int arg1 ;
11557 wxString result;
11558 PyObject * obj0 = 0 ;
11559 char *kwnames[] = {
11560 (char *) "lang", NULL
11561 };
11562
11563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageName",kwnames,&obj0)) goto fail;
11564 {
11565 arg1 = (int)(SWIG_As_int(obj0));
11566 if (SWIG_arg_fail(1)) SWIG_fail;
11567 }
11568 {
11569 PyThreadState* __tstate = wxPyBeginAllowThreads();
11570 result = wxLocale::GetLanguageName(arg1);
11571
11572 wxPyEndAllowThreads(__tstate);
11573 if (PyErr_Occurred()) SWIG_fail;
11574 }
11575 {
11576 #if wxUSE_UNICODE
11577 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11578 #else
11579 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11580 #endif
11581 }
11582 return resultobj;
11583 fail:
11584 return NULL;
11585 }
11586
11587
11588 static PyObject *_wrap_Locale_FindLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11589 PyObject *resultobj;
11590 wxString *arg1 = 0 ;
11591 wxLanguageInfo *result;
11592 bool temp1 = false ;
11593 PyObject * obj0 = 0 ;
11594 char *kwnames[] = {
11595 (char *) "locale", NULL
11596 };
11597
11598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_FindLanguageInfo",kwnames,&obj0)) goto fail;
11599 {
11600 arg1 = wxString_in_helper(obj0);
11601 if (arg1 == NULL) SWIG_fail;
11602 temp1 = true;
11603 }
11604 {
11605 PyThreadState* __tstate = wxPyBeginAllowThreads();
11606 result = (wxLanguageInfo *)wxLocale::FindLanguageInfo((wxString const &)*arg1);
11607
11608 wxPyEndAllowThreads(__tstate);
11609 if (PyErr_Occurred()) SWIG_fail;
11610 }
11611 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
11612 {
11613 if (temp1)
11614 delete arg1;
11615 }
11616 return resultobj;
11617 fail:
11618 {
11619 if (temp1)
11620 delete arg1;
11621 }
11622 return NULL;
11623 }
11624
11625
11626 static PyObject *_wrap_Locale_AddLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11627 PyObject *resultobj;
11628 wxLanguageInfo *arg1 = 0 ;
11629 PyObject * obj0 = 0 ;
11630 char *kwnames[] = {
11631 (char *) "info", NULL
11632 };
11633
11634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddLanguage",kwnames,&obj0)) goto fail;
11635 {
11636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11637 if (SWIG_arg_fail(1)) SWIG_fail;
11638 if (arg1 == NULL) {
11639 SWIG_null_ref("wxLanguageInfo");
11640 }
11641 if (SWIG_arg_fail(1)) SWIG_fail;
11642 }
11643 {
11644 PyThreadState* __tstate = wxPyBeginAllowThreads();
11645 wxLocale::AddLanguage((wxLanguageInfo const &)*arg1);
11646
11647 wxPyEndAllowThreads(__tstate);
11648 if (PyErr_Occurred()) SWIG_fail;
11649 }
11650 Py_INCREF(Py_None); resultobj = Py_None;
11651 return resultobj;
11652 fail:
11653 return NULL;
11654 }
11655
11656
11657 static PyObject *_wrap_Locale_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
11658 PyObject *resultobj;
11659 wxLocale *arg1 = (wxLocale *) 0 ;
11660 wxString *arg2 = 0 ;
11661 wxString const &arg3_defvalue = wxPyEmptyString ;
11662 wxString *arg3 = (wxString *) &arg3_defvalue ;
11663 wxString result;
11664 bool temp2 = false ;
11665 bool temp3 = false ;
11666 PyObject * obj0 = 0 ;
11667 PyObject * obj1 = 0 ;
11668 PyObject * obj2 = 0 ;
11669 char *kwnames[] = {
11670 (char *) "self",(char *) "szOrigString",(char *) "szDomain", NULL
11671 };
11672
11673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Locale_GetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
11674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, 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 (obj2) {
11682 {
11683 arg3 = wxString_in_helper(obj2);
11684 if (arg3 == NULL) SWIG_fail;
11685 temp3 = true;
11686 }
11687 }
11688 {
11689 PyThreadState* __tstate = wxPyBeginAllowThreads();
11690 result = ((wxLocale const *)arg1)->GetString((wxString const &)*arg2,(wxString const &)*arg3);
11691
11692 wxPyEndAllowThreads(__tstate);
11693 if (PyErr_Occurred()) SWIG_fail;
11694 }
11695 {
11696 #if wxUSE_UNICODE
11697 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11698 #else
11699 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11700 #endif
11701 }
11702 {
11703 if (temp2)
11704 delete arg2;
11705 }
11706 {
11707 if (temp3)
11708 delete arg3;
11709 }
11710 return resultobj;
11711 fail:
11712 {
11713 if (temp2)
11714 delete arg2;
11715 }
11716 {
11717 if (temp3)
11718 delete arg3;
11719 }
11720 return NULL;
11721 }
11722
11723
11724 static PyObject *_wrap_Locale_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
11725 PyObject *resultobj;
11726 wxLocale *arg1 = (wxLocale *) 0 ;
11727 wxString *result;
11728 PyObject * obj0 = 0 ;
11729 char *kwnames[] = {
11730 (char *) "self", NULL
11731 };
11732
11733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetName",kwnames,&obj0)) goto fail;
11734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11735 if (SWIG_arg_fail(1)) SWIG_fail;
11736 {
11737 PyThreadState* __tstate = wxPyBeginAllowThreads();
11738 {
11739 wxString const &_result_ref = ((wxLocale const *)arg1)->GetName();
11740 result = (wxString *) &_result_ref;
11741 }
11742
11743 wxPyEndAllowThreads(__tstate);
11744 if (PyErr_Occurred()) SWIG_fail;
11745 }
11746 {
11747 #if wxUSE_UNICODE
11748 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
11749 #else
11750 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
11751 #endif
11752 }
11753 return resultobj;
11754 fail:
11755 return NULL;
11756 }
11757
11758
11759 static PyObject * Locale_swigregister(PyObject *, PyObject *args) {
11760 PyObject *obj;
11761 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11762 SWIG_TypeClientData(SWIGTYPE_p_wxLocale, obj);
11763 Py_INCREF(obj);
11764 return Py_BuildValue((char *)"");
11765 }
11766 static PyObject *_wrap_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
11767 PyObject *resultobj;
11768 wxLocale *result;
11769 char *kwnames[] = {
11770 NULL
11771 };
11772
11773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocale",kwnames)) goto fail;
11774 {
11775 PyThreadState* __tstate = wxPyBeginAllowThreads();
11776 result = (wxLocale *)wxGetLocale();
11777
11778 wxPyEndAllowThreads(__tstate);
11779 if (PyErr_Occurred()) SWIG_fail;
11780 }
11781 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 0);
11782 return resultobj;
11783 fail:
11784 return NULL;
11785 }
11786
11787
11788 static PyObject *_wrap_GetTranslation__SWIG_0(PyObject *, PyObject *args) {
11789 PyObject *resultobj;
11790 wxString *arg1 = 0 ;
11791 wxString result;
11792 bool temp1 = false ;
11793 PyObject * obj0 = 0 ;
11794
11795 if(!PyArg_ParseTuple(args,(char *)"O:GetTranslation",&obj0)) goto fail;
11796 {
11797 arg1 = wxString_in_helper(obj0);
11798 if (arg1 == NULL) SWIG_fail;
11799 temp1 = true;
11800 }
11801 {
11802 PyThreadState* __tstate = wxPyBeginAllowThreads();
11803 result = wxGetTranslation((wxString const &)*arg1);
11804
11805 wxPyEndAllowThreads(__tstate);
11806 if (PyErr_Occurred()) SWIG_fail;
11807 }
11808 {
11809 #if wxUSE_UNICODE
11810 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11811 #else
11812 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11813 #endif
11814 }
11815 {
11816 if (temp1)
11817 delete arg1;
11818 }
11819 return resultobj;
11820 fail:
11821 {
11822 if (temp1)
11823 delete arg1;
11824 }
11825 return NULL;
11826 }
11827
11828
11829 static PyObject *_wrap_GetTranslation__SWIG_1(PyObject *, PyObject *args) {
11830 PyObject *resultobj;
11831 wxString *arg1 = 0 ;
11832 wxString *arg2 = 0 ;
11833 size_t arg3 ;
11834 wxString result;
11835 bool temp1 = false ;
11836 bool temp2 = false ;
11837 PyObject * obj0 = 0 ;
11838 PyObject * obj1 = 0 ;
11839 PyObject * obj2 = 0 ;
11840
11841 if(!PyArg_ParseTuple(args,(char *)"OOO:GetTranslation",&obj0,&obj1,&obj2)) goto fail;
11842 {
11843 arg1 = wxString_in_helper(obj0);
11844 if (arg1 == NULL) SWIG_fail;
11845 temp1 = true;
11846 }
11847 {
11848 arg2 = wxString_in_helper(obj1);
11849 if (arg2 == NULL) SWIG_fail;
11850 temp2 = true;
11851 }
11852 {
11853 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
11854 if (SWIG_arg_fail(3)) SWIG_fail;
11855 }
11856 {
11857 PyThreadState* __tstate = wxPyBeginAllowThreads();
11858 result = wxGetTranslation((wxString const &)*arg1,(wxString const &)*arg2,arg3);
11859
11860 wxPyEndAllowThreads(__tstate);
11861 if (PyErr_Occurred()) SWIG_fail;
11862 }
11863 {
11864 #if wxUSE_UNICODE
11865 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11866 #else
11867 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11868 #endif
11869 }
11870 {
11871 if (temp1)
11872 delete arg1;
11873 }
11874 {
11875 if (temp2)
11876 delete arg2;
11877 }
11878 return resultobj;
11879 fail:
11880 {
11881 if (temp1)
11882 delete arg1;
11883 }
11884 {
11885 if (temp2)
11886 delete arg2;
11887 }
11888 return NULL;
11889 }
11890
11891
11892 static PyObject *_wrap_GetTranslation(PyObject *self, PyObject *args) {
11893 int argc;
11894 PyObject *argv[4];
11895 int ii;
11896
11897 argc = PyObject_Length(args);
11898 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
11899 argv[ii] = PyTuple_GetItem(args,ii);
11900 }
11901 if (argc == 1) {
11902 int _v;
11903 {
11904 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
11905 }
11906 if (_v) {
11907 return _wrap_GetTranslation__SWIG_0(self,args);
11908 }
11909 }
11910 if (argc == 3) {
11911 int _v;
11912 {
11913 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
11914 }
11915 if (_v) {
11916 {
11917 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
11918 }
11919 if (_v) {
11920 _v = SWIG_Check_unsigned_SS_long(argv[2]);
11921 if (_v) {
11922 return _wrap_GetTranslation__SWIG_1(self,args);
11923 }
11924 }
11925 }
11926 }
11927
11928 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GetTranslation'");
11929 return NULL;
11930 }
11931
11932
11933 static PyObject *_wrap_new_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
11934 PyObject *resultobj;
11935 wxEncodingConverter *result;
11936 char *kwnames[] = {
11937 NULL
11938 };
11939
11940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EncodingConverter",kwnames)) goto fail;
11941 {
11942 PyThreadState* __tstate = wxPyBeginAllowThreads();
11943 result = (wxEncodingConverter *)new wxEncodingConverter();
11944
11945 wxPyEndAllowThreads(__tstate);
11946 if (PyErr_Occurred()) SWIG_fail;
11947 }
11948 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEncodingConverter, 1);
11949 return resultobj;
11950 fail:
11951 return NULL;
11952 }
11953
11954
11955 static PyObject *_wrap_delete_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
11956 PyObject *resultobj;
11957 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
11958 PyObject * obj0 = 0 ;
11959 char *kwnames[] = {
11960 (char *) "self", NULL
11961 };
11962
11963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EncodingConverter",kwnames,&obj0)) goto fail;
11964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
11965 if (SWIG_arg_fail(1)) SWIG_fail;
11966 {
11967 PyThreadState* __tstate = wxPyBeginAllowThreads();
11968 delete arg1;
11969
11970 wxPyEndAllowThreads(__tstate);
11971 if (PyErr_Occurred()) SWIG_fail;
11972 }
11973 Py_INCREF(Py_None); resultobj = Py_None;
11974 return resultobj;
11975 fail:
11976 return NULL;
11977 }
11978
11979
11980 static PyObject *_wrap_EncodingConverter_Init(PyObject *, PyObject *args, PyObject *kwargs) {
11981 PyObject *resultobj;
11982 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
11983 wxFontEncoding arg2 ;
11984 wxFontEncoding arg3 ;
11985 int arg4 = (int) wxCONVERT_STRICT ;
11986 bool result;
11987 PyObject * obj0 = 0 ;
11988 PyObject * obj1 = 0 ;
11989 PyObject * obj2 = 0 ;
11990 PyObject * obj3 = 0 ;
11991 char *kwnames[] = {
11992 (char *) "self",(char *) "input_enc",(char *) "output_enc",(char *) "method", NULL
11993 };
11994
11995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:EncodingConverter_Init",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
11997 if (SWIG_arg_fail(1)) SWIG_fail;
11998 {
11999 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12000 if (SWIG_arg_fail(2)) SWIG_fail;
12001 }
12002 {
12003 arg3 = (wxFontEncoding)(SWIG_As_int(obj2));
12004 if (SWIG_arg_fail(3)) SWIG_fail;
12005 }
12006 if (obj3) {
12007 {
12008 arg4 = (int)(SWIG_As_int(obj3));
12009 if (SWIG_arg_fail(4)) SWIG_fail;
12010 }
12011 }
12012 {
12013 PyThreadState* __tstate = wxPyBeginAllowThreads();
12014 result = (bool)(arg1)->Init((wxFontEncoding )arg2,(wxFontEncoding )arg3,arg4);
12015
12016 wxPyEndAllowThreads(__tstate);
12017 if (PyErr_Occurred()) SWIG_fail;
12018 }
12019 {
12020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12021 }
12022 return resultobj;
12023 fail:
12024 return NULL;
12025 }
12026
12027
12028 static PyObject *_wrap_EncodingConverter_Convert(PyObject *, PyObject *args, PyObject *kwargs) {
12029 PyObject *resultobj;
12030 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12031 wxString *arg2 = 0 ;
12032 wxString result;
12033 bool temp2 = false ;
12034 PyObject * obj0 = 0 ;
12035 PyObject * obj1 = 0 ;
12036 char *kwnames[] = {
12037 (char *) "self",(char *) "input", NULL
12038 };
12039
12040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_Convert",kwnames,&obj0,&obj1)) goto fail;
12041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12042 if (SWIG_arg_fail(1)) SWIG_fail;
12043 {
12044 arg2 = wxString_in_helper(obj1);
12045 if (arg2 == NULL) SWIG_fail;
12046 temp2 = true;
12047 }
12048 {
12049 PyThreadState* __tstate = wxPyBeginAllowThreads();
12050 result = (arg1)->Convert((wxString const &)*arg2);
12051
12052 wxPyEndAllowThreads(__tstate);
12053 if (PyErr_Occurred()) SWIG_fail;
12054 }
12055 {
12056 #if wxUSE_UNICODE
12057 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12058 #else
12059 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12060 #endif
12061 }
12062 {
12063 if (temp2)
12064 delete arg2;
12065 }
12066 return resultobj;
12067 fail:
12068 {
12069 if (temp2)
12070 delete arg2;
12071 }
12072 return NULL;
12073 }
12074
12075
12076 static PyObject *_wrap_EncodingConverter_GetPlatformEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12077 PyObject *resultobj;
12078 wxFontEncoding arg1 ;
12079 int arg2 = (int) wxPLATFORM_CURRENT ;
12080 wxFontEncodingArray result;
12081 PyObject * obj0 = 0 ;
12082 PyObject * obj1 = 0 ;
12083 char *kwnames[] = {
12084 (char *) "enc",(char *) "platform", NULL
12085 };
12086
12087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EncodingConverter_GetPlatformEquivalents",kwnames,&obj0,&obj1)) goto fail;
12088 {
12089 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12090 if (SWIG_arg_fail(1)) SWIG_fail;
12091 }
12092 if (obj1) {
12093 {
12094 arg2 = (int)(SWIG_As_int(obj1));
12095 if (SWIG_arg_fail(2)) SWIG_fail;
12096 }
12097 }
12098 {
12099 PyThreadState* __tstate = wxPyBeginAllowThreads();
12100 result = wxEncodingConverter::GetPlatformEquivalents((wxFontEncoding )arg1,arg2);
12101
12102 wxPyEndAllowThreads(__tstate);
12103 if (PyErr_Occurred()) SWIG_fail;
12104 }
12105 {
12106 resultobj = PyList_New(0);
12107 for (size_t i=0; i < (&result)->GetCount(); i++) {
12108 PyObject* number = PyInt_FromLong((&result)->Item(i));
12109 PyList_Append(resultobj, number);
12110 Py_DECREF(number);
12111 }
12112 }
12113 return resultobj;
12114 fail:
12115 return NULL;
12116 }
12117
12118
12119 static PyObject *_wrap_EncodingConverter_GetAllEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12120 PyObject *resultobj;
12121 wxFontEncoding arg1 ;
12122 wxFontEncodingArray result;
12123 PyObject * obj0 = 0 ;
12124 char *kwnames[] = {
12125 (char *) "enc", NULL
12126 };
12127
12128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EncodingConverter_GetAllEquivalents",kwnames,&obj0)) goto fail;
12129 {
12130 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12131 if (SWIG_arg_fail(1)) SWIG_fail;
12132 }
12133 {
12134 PyThreadState* __tstate = wxPyBeginAllowThreads();
12135 result = wxEncodingConverter::GetAllEquivalents((wxFontEncoding )arg1);
12136
12137 wxPyEndAllowThreads(__tstate);
12138 if (PyErr_Occurred()) SWIG_fail;
12139 }
12140 {
12141 resultobj = PyList_New(0);
12142 for (size_t i=0; i < (&result)->GetCount(); i++) {
12143 PyObject* number = PyInt_FromLong((&result)->Item(i));
12144 PyList_Append(resultobj, number);
12145 Py_DECREF(number);
12146 }
12147 }
12148 return resultobj;
12149 fail:
12150 return NULL;
12151 }
12152
12153
12154 static PyObject *_wrap_EncodingConverter_CanConvert(PyObject *, PyObject *args, PyObject *kwargs) {
12155 PyObject *resultobj;
12156 wxFontEncoding arg1 ;
12157 wxFontEncoding arg2 ;
12158 bool result;
12159 PyObject * obj0 = 0 ;
12160 PyObject * obj1 = 0 ;
12161 char *kwnames[] = {
12162 (char *) "encIn",(char *) "encOut", NULL
12163 };
12164
12165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_CanConvert",kwnames,&obj0,&obj1)) goto fail;
12166 {
12167 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12168 if (SWIG_arg_fail(1)) SWIG_fail;
12169 }
12170 {
12171 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12172 if (SWIG_arg_fail(2)) SWIG_fail;
12173 }
12174 {
12175 PyThreadState* __tstate = wxPyBeginAllowThreads();
12176 result = (bool)wxEncodingConverter::CanConvert((wxFontEncoding )arg1,(wxFontEncoding )arg2);
12177
12178 wxPyEndAllowThreads(__tstate);
12179 if (PyErr_Occurred()) SWIG_fail;
12180 }
12181 {
12182 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12183 }
12184 return resultobj;
12185 fail:
12186 return NULL;
12187 }
12188
12189
12190 static PyObject * EncodingConverter_swigregister(PyObject *, PyObject *args) {
12191 PyObject *obj;
12192 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12193 SWIG_TypeClientData(SWIGTYPE_p_wxEncodingConverter, obj);
12194 Py_INCREF(obj);
12195 return Py_BuildValue((char *)"");
12196 }
12197 static PyObject *_wrap_delete_DC(PyObject *, PyObject *args, PyObject *kwargs) {
12198 PyObject *resultobj;
12199 wxDC *arg1 = (wxDC *) 0 ;
12200 PyObject * obj0 = 0 ;
12201 char *kwnames[] = {
12202 (char *) "self", NULL
12203 };
12204
12205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DC",kwnames,&obj0)) goto fail;
12206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12207 if (SWIG_arg_fail(1)) SWIG_fail;
12208 {
12209 PyThreadState* __tstate = wxPyBeginAllowThreads();
12210 delete arg1;
12211
12212 wxPyEndAllowThreads(__tstate);
12213 if (PyErr_Occurred()) SWIG_fail;
12214 }
12215 Py_INCREF(Py_None); resultobj = Py_None;
12216 return resultobj;
12217 fail:
12218 return NULL;
12219 }
12220
12221
12222 static PyObject *_wrap_DC_BeginDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12223 PyObject *resultobj;
12224 wxDC *arg1 = (wxDC *) 0 ;
12225 PyObject * obj0 = 0 ;
12226 char *kwnames[] = {
12227 (char *) "self", NULL
12228 };
12229
12230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_BeginDrawing",kwnames,&obj0)) goto fail;
12231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12232 if (SWIG_arg_fail(1)) SWIG_fail;
12233 {
12234 PyThreadState* __tstate = wxPyBeginAllowThreads();
12235 (arg1)->BeginDrawing();
12236
12237 wxPyEndAllowThreads(__tstate);
12238 if (PyErr_Occurred()) SWIG_fail;
12239 }
12240 Py_INCREF(Py_None); resultobj = Py_None;
12241 return resultobj;
12242 fail:
12243 return NULL;
12244 }
12245
12246
12247 static PyObject *_wrap_DC_EndDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12248 PyObject *resultobj;
12249 wxDC *arg1 = (wxDC *) 0 ;
12250 PyObject * obj0 = 0 ;
12251 char *kwnames[] = {
12252 (char *) "self", NULL
12253 };
12254
12255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDrawing",kwnames,&obj0)) goto fail;
12256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12257 if (SWIG_arg_fail(1)) SWIG_fail;
12258 {
12259 PyThreadState* __tstate = wxPyBeginAllowThreads();
12260 (arg1)->EndDrawing();
12261
12262 wxPyEndAllowThreads(__tstate);
12263 if (PyErr_Occurred()) SWIG_fail;
12264 }
12265 Py_INCREF(Py_None); resultobj = Py_None;
12266 return resultobj;
12267 fail:
12268 return NULL;
12269 }
12270
12271
12272 static PyObject *_wrap_DC_FloodFill(PyObject *, PyObject *args, PyObject *kwargs) {
12273 PyObject *resultobj;
12274 wxDC *arg1 = (wxDC *) 0 ;
12275 int arg2 ;
12276 int arg3 ;
12277 wxColour *arg4 = 0 ;
12278 int arg5 = (int) wxFLOOD_SURFACE ;
12279 bool result;
12280 wxColour temp4 ;
12281 PyObject * obj0 = 0 ;
12282 PyObject * obj1 = 0 ;
12283 PyObject * obj2 = 0 ;
12284 PyObject * obj3 = 0 ;
12285 PyObject * obj4 = 0 ;
12286 char *kwnames[] = {
12287 (char *) "self",(char *) "x",(char *) "y",(char *) "col",(char *) "style", NULL
12288 };
12289
12290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_FloodFill",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12292 if (SWIG_arg_fail(1)) SWIG_fail;
12293 {
12294 arg2 = (int)(SWIG_As_int(obj1));
12295 if (SWIG_arg_fail(2)) SWIG_fail;
12296 }
12297 {
12298 arg3 = (int)(SWIG_As_int(obj2));
12299 if (SWIG_arg_fail(3)) SWIG_fail;
12300 }
12301 {
12302 arg4 = &temp4;
12303 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
12304 }
12305 if (obj4) {
12306 {
12307 arg5 = (int)(SWIG_As_int(obj4));
12308 if (SWIG_arg_fail(5)) SWIG_fail;
12309 }
12310 }
12311 {
12312 PyThreadState* __tstate = wxPyBeginAllowThreads();
12313 result = (bool)(arg1)->FloodFill(arg2,arg3,(wxColour const &)*arg4,arg5);
12314
12315 wxPyEndAllowThreads(__tstate);
12316 if (PyErr_Occurred()) SWIG_fail;
12317 }
12318 {
12319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12320 }
12321 return resultobj;
12322 fail:
12323 return NULL;
12324 }
12325
12326
12327 static PyObject *_wrap_DC_FloodFillPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12328 PyObject *resultobj;
12329 wxDC *arg1 = (wxDC *) 0 ;
12330 wxPoint *arg2 = 0 ;
12331 wxColour *arg3 = 0 ;
12332 int arg4 = (int) wxFLOOD_SURFACE ;
12333 bool result;
12334 wxPoint temp2 ;
12335 wxColour temp3 ;
12336 PyObject * obj0 = 0 ;
12337 PyObject * obj1 = 0 ;
12338 PyObject * obj2 = 0 ;
12339 PyObject * obj3 = 0 ;
12340 char *kwnames[] = {
12341 (char *) "self",(char *) "pt",(char *) "col",(char *) "style", NULL
12342 };
12343
12344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_FloodFillPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12346 if (SWIG_arg_fail(1)) SWIG_fail;
12347 {
12348 arg2 = &temp2;
12349 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12350 }
12351 {
12352 arg3 = &temp3;
12353 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
12354 }
12355 if (obj3) {
12356 {
12357 arg4 = (int)(SWIG_As_int(obj3));
12358 if (SWIG_arg_fail(4)) SWIG_fail;
12359 }
12360 }
12361 {
12362 PyThreadState* __tstate = wxPyBeginAllowThreads();
12363 result = (bool)(arg1)->FloodFill((wxPoint const &)*arg2,(wxColour const &)*arg3,arg4);
12364
12365 wxPyEndAllowThreads(__tstate);
12366 if (PyErr_Occurred()) SWIG_fail;
12367 }
12368 {
12369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12370 }
12371 return resultobj;
12372 fail:
12373 return NULL;
12374 }
12375
12376
12377 static PyObject *_wrap_DC_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
12378 PyObject *resultobj;
12379 wxDC *arg1 = (wxDC *) 0 ;
12380 int arg2 ;
12381 int arg3 ;
12382 wxColour result;
12383 PyObject * obj0 = 0 ;
12384 PyObject * obj1 = 0 ;
12385 PyObject * obj2 = 0 ;
12386 char *kwnames[] = {
12387 (char *) "self",(char *) "x",(char *) "y", NULL
12388 };
12389
12390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_GetPixel",kwnames,&obj0,&obj1,&obj2)) goto fail;
12391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12392 if (SWIG_arg_fail(1)) SWIG_fail;
12393 {
12394 arg2 = (int)(SWIG_As_int(obj1));
12395 if (SWIG_arg_fail(2)) SWIG_fail;
12396 }
12397 {
12398 arg3 = (int)(SWIG_As_int(obj2));
12399 if (SWIG_arg_fail(3)) SWIG_fail;
12400 }
12401 {
12402 PyThreadState* __tstate = wxPyBeginAllowThreads();
12403 result = wxDC_GetPixel(arg1,arg2,arg3);
12404
12405 wxPyEndAllowThreads(__tstate);
12406 if (PyErr_Occurred()) SWIG_fail;
12407 }
12408 {
12409 wxColour * resultptr;
12410 resultptr = new wxColour((wxColour &)(result));
12411 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12412 }
12413 return resultobj;
12414 fail:
12415 return NULL;
12416 }
12417
12418
12419 static PyObject *_wrap_DC_GetPixelPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12420 PyObject *resultobj;
12421 wxDC *arg1 = (wxDC *) 0 ;
12422 wxPoint *arg2 = 0 ;
12423 wxColour result;
12424 wxPoint temp2 ;
12425 PyObject * obj0 = 0 ;
12426 PyObject * obj1 = 0 ;
12427 char *kwnames[] = {
12428 (char *) "self",(char *) "pt", NULL
12429 };
12430
12431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPixelPoint",kwnames,&obj0,&obj1)) goto fail;
12432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12433 if (SWIG_arg_fail(1)) SWIG_fail;
12434 {
12435 arg2 = &temp2;
12436 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12437 }
12438 {
12439 PyThreadState* __tstate = wxPyBeginAllowThreads();
12440 result = wxDC_GetPixelPoint(arg1,(wxPoint const &)*arg2);
12441
12442 wxPyEndAllowThreads(__tstate);
12443 if (PyErr_Occurred()) SWIG_fail;
12444 }
12445 {
12446 wxColour * resultptr;
12447 resultptr = new wxColour((wxColour &)(result));
12448 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12449 }
12450 return resultobj;
12451 fail:
12452 return NULL;
12453 }
12454
12455
12456 static PyObject *_wrap_DC_DrawLine(PyObject *, PyObject *args, PyObject *kwargs) {
12457 PyObject *resultobj;
12458 wxDC *arg1 = (wxDC *) 0 ;
12459 int arg2 ;
12460 int arg3 ;
12461 int arg4 ;
12462 int arg5 ;
12463 PyObject * obj0 = 0 ;
12464 PyObject * obj1 = 0 ;
12465 PyObject * obj2 = 0 ;
12466 PyObject * obj3 = 0 ;
12467 PyObject * obj4 = 0 ;
12468 char *kwnames[] = {
12469 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2", NULL
12470 };
12471
12472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawLine",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12474 if (SWIG_arg_fail(1)) SWIG_fail;
12475 {
12476 arg2 = (int)(SWIG_As_int(obj1));
12477 if (SWIG_arg_fail(2)) SWIG_fail;
12478 }
12479 {
12480 arg3 = (int)(SWIG_As_int(obj2));
12481 if (SWIG_arg_fail(3)) SWIG_fail;
12482 }
12483 {
12484 arg4 = (int)(SWIG_As_int(obj3));
12485 if (SWIG_arg_fail(4)) SWIG_fail;
12486 }
12487 {
12488 arg5 = (int)(SWIG_As_int(obj4));
12489 if (SWIG_arg_fail(5)) SWIG_fail;
12490 }
12491 {
12492 PyThreadState* __tstate = wxPyBeginAllowThreads();
12493 (arg1)->DrawLine(arg2,arg3,arg4,arg5);
12494
12495 wxPyEndAllowThreads(__tstate);
12496 if (PyErr_Occurred()) SWIG_fail;
12497 }
12498 Py_INCREF(Py_None); resultobj = Py_None;
12499 return resultobj;
12500 fail:
12501 return NULL;
12502 }
12503
12504
12505 static PyObject *_wrap_DC_DrawLinePoint(PyObject *, PyObject *args, PyObject *kwargs) {
12506 PyObject *resultobj;
12507 wxDC *arg1 = (wxDC *) 0 ;
12508 wxPoint *arg2 = 0 ;
12509 wxPoint *arg3 = 0 ;
12510 wxPoint temp2 ;
12511 wxPoint temp3 ;
12512 PyObject * obj0 = 0 ;
12513 PyObject * obj1 = 0 ;
12514 PyObject * obj2 = 0 ;
12515 char *kwnames[] = {
12516 (char *) "self",(char *) "pt1",(char *) "pt2", NULL
12517 };
12518
12519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawLinePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
12520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12521 if (SWIG_arg_fail(1)) SWIG_fail;
12522 {
12523 arg2 = &temp2;
12524 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12525 }
12526 {
12527 arg3 = &temp3;
12528 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12529 }
12530 {
12531 PyThreadState* __tstate = wxPyBeginAllowThreads();
12532 (arg1)->DrawLine((wxPoint const &)*arg2,(wxPoint const &)*arg3);
12533
12534 wxPyEndAllowThreads(__tstate);
12535 if (PyErr_Occurred()) SWIG_fail;
12536 }
12537 Py_INCREF(Py_None); resultobj = Py_None;
12538 return resultobj;
12539 fail:
12540 return NULL;
12541 }
12542
12543
12544 static PyObject *_wrap_DC_CrossHair(PyObject *, PyObject *args, PyObject *kwargs) {
12545 PyObject *resultobj;
12546 wxDC *arg1 = (wxDC *) 0 ;
12547 int arg2 ;
12548 int arg3 ;
12549 PyObject * obj0 = 0 ;
12550 PyObject * obj1 = 0 ;
12551 PyObject * obj2 = 0 ;
12552 char *kwnames[] = {
12553 (char *) "self",(char *) "x",(char *) "y", NULL
12554 };
12555
12556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CrossHair",kwnames,&obj0,&obj1,&obj2)) goto fail;
12557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12558 if (SWIG_arg_fail(1)) SWIG_fail;
12559 {
12560 arg2 = (int)(SWIG_As_int(obj1));
12561 if (SWIG_arg_fail(2)) SWIG_fail;
12562 }
12563 {
12564 arg3 = (int)(SWIG_As_int(obj2));
12565 if (SWIG_arg_fail(3)) SWIG_fail;
12566 }
12567 {
12568 PyThreadState* __tstate = wxPyBeginAllowThreads();
12569 (arg1)->CrossHair(arg2,arg3);
12570
12571 wxPyEndAllowThreads(__tstate);
12572 if (PyErr_Occurred()) SWIG_fail;
12573 }
12574 Py_INCREF(Py_None); resultobj = Py_None;
12575 return resultobj;
12576 fail:
12577 return NULL;
12578 }
12579
12580
12581 static PyObject *_wrap_DC_CrossHairPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12582 PyObject *resultobj;
12583 wxDC *arg1 = (wxDC *) 0 ;
12584 wxPoint *arg2 = 0 ;
12585 wxPoint temp2 ;
12586 PyObject * obj0 = 0 ;
12587 PyObject * obj1 = 0 ;
12588 char *kwnames[] = {
12589 (char *) "self",(char *) "pt", NULL
12590 };
12591
12592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CrossHairPoint",kwnames,&obj0,&obj1)) goto fail;
12593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12594 if (SWIG_arg_fail(1)) SWIG_fail;
12595 {
12596 arg2 = &temp2;
12597 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12598 }
12599 {
12600 PyThreadState* __tstate = wxPyBeginAllowThreads();
12601 (arg1)->CrossHair((wxPoint const &)*arg2);
12602
12603 wxPyEndAllowThreads(__tstate);
12604 if (PyErr_Occurred()) SWIG_fail;
12605 }
12606 Py_INCREF(Py_None); resultobj = Py_None;
12607 return resultobj;
12608 fail:
12609 return NULL;
12610 }
12611
12612
12613 static PyObject *_wrap_DC_DrawArc(PyObject *, PyObject *args, PyObject *kwargs) {
12614 PyObject *resultobj;
12615 wxDC *arg1 = (wxDC *) 0 ;
12616 int arg2 ;
12617 int arg3 ;
12618 int arg4 ;
12619 int arg5 ;
12620 int arg6 ;
12621 int arg7 ;
12622 PyObject * obj0 = 0 ;
12623 PyObject * obj1 = 0 ;
12624 PyObject * obj2 = 0 ;
12625 PyObject * obj3 = 0 ;
12626 PyObject * obj4 = 0 ;
12627 PyObject * obj5 = 0 ;
12628 PyObject * obj6 = 0 ;
12629 char *kwnames[] = {
12630 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2",(char *) "xc",(char *) "yc", NULL
12631 };
12632
12633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12635 if (SWIG_arg_fail(1)) SWIG_fail;
12636 {
12637 arg2 = (int)(SWIG_As_int(obj1));
12638 if (SWIG_arg_fail(2)) SWIG_fail;
12639 }
12640 {
12641 arg3 = (int)(SWIG_As_int(obj2));
12642 if (SWIG_arg_fail(3)) SWIG_fail;
12643 }
12644 {
12645 arg4 = (int)(SWIG_As_int(obj3));
12646 if (SWIG_arg_fail(4)) SWIG_fail;
12647 }
12648 {
12649 arg5 = (int)(SWIG_As_int(obj4));
12650 if (SWIG_arg_fail(5)) SWIG_fail;
12651 }
12652 {
12653 arg6 = (int)(SWIG_As_int(obj5));
12654 if (SWIG_arg_fail(6)) SWIG_fail;
12655 }
12656 {
12657 arg7 = (int)(SWIG_As_int(obj6));
12658 if (SWIG_arg_fail(7)) SWIG_fail;
12659 }
12660 {
12661 PyThreadState* __tstate = wxPyBeginAllowThreads();
12662 (arg1)->DrawArc(arg2,arg3,arg4,arg5,arg6,arg7);
12663
12664 wxPyEndAllowThreads(__tstate);
12665 if (PyErr_Occurred()) SWIG_fail;
12666 }
12667 Py_INCREF(Py_None); resultobj = Py_None;
12668 return resultobj;
12669 fail:
12670 return NULL;
12671 }
12672
12673
12674 static PyObject *_wrap_DC_DrawArcPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12675 PyObject *resultobj;
12676 wxDC *arg1 = (wxDC *) 0 ;
12677 wxPoint *arg2 = 0 ;
12678 wxPoint *arg3 = 0 ;
12679 wxPoint *arg4 = 0 ;
12680 wxPoint temp2 ;
12681 wxPoint temp3 ;
12682 wxPoint temp4 ;
12683 PyObject * obj0 = 0 ;
12684 PyObject * obj1 = 0 ;
12685 PyObject * obj2 = 0 ;
12686 PyObject * obj3 = 0 ;
12687 char *kwnames[] = {
12688 (char *) "self",(char *) "pt1",(char *) "pt2",(char *) "center", NULL
12689 };
12690
12691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawArcPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12693 if (SWIG_arg_fail(1)) SWIG_fail;
12694 {
12695 arg2 = &temp2;
12696 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12697 }
12698 {
12699 arg3 = &temp3;
12700 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12701 }
12702 {
12703 arg4 = &temp4;
12704 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
12705 }
12706 {
12707 PyThreadState* __tstate = wxPyBeginAllowThreads();
12708 (arg1)->DrawArc((wxPoint const &)*arg2,(wxPoint const &)*arg3,(wxPoint const &)*arg4);
12709
12710 wxPyEndAllowThreads(__tstate);
12711 if (PyErr_Occurred()) SWIG_fail;
12712 }
12713 Py_INCREF(Py_None); resultobj = Py_None;
12714 return resultobj;
12715 fail:
12716 return NULL;
12717 }
12718
12719
12720 static PyObject *_wrap_DC_DrawCheckMark(PyObject *, PyObject *args, PyObject *kwargs) {
12721 PyObject *resultobj;
12722 wxDC *arg1 = (wxDC *) 0 ;
12723 int arg2 ;
12724 int arg3 ;
12725 int arg4 ;
12726 int arg5 ;
12727 PyObject * obj0 = 0 ;
12728 PyObject * obj1 = 0 ;
12729 PyObject * obj2 = 0 ;
12730 PyObject * obj3 = 0 ;
12731 PyObject * obj4 = 0 ;
12732 char *kwnames[] = {
12733 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
12734 };
12735
12736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawCheckMark",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12738 if (SWIG_arg_fail(1)) SWIG_fail;
12739 {
12740 arg2 = (int)(SWIG_As_int(obj1));
12741 if (SWIG_arg_fail(2)) SWIG_fail;
12742 }
12743 {
12744 arg3 = (int)(SWIG_As_int(obj2));
12745 if (SWIG_arg_fail(3)) SWIG_fail;
12746 }
12747 {
12748 arg4 = (int)(SWIG_As_int(obj3));
12749 if (SWIG_arg_fail(4)) SWIG_fail;
12750 }
12751 {
12752 arg5 = (int)(SWIG_As_int(obj4));
12753 if (SWIG_arg_fail(5)) SWIG_fail;
12754 }
12755 {
12756 PyThreadState* __tstate = wxPyBeginAllowThreads();
12757 (arg1)->DrawCheckMark(arg2,arg3,arg4,arg5);
12758
12759 wxPyEndAllowThreads(__tstate);
12760 if (PyErr_Occurred()) SWIG_fail;
12761 }
12762 Py_INCREF(Py_None); resultobj = Py_None;
12763 return resultobj;
12764 fail:
12765 return NULL;
12766 }
12767
12768
12769 static PyObject *_wrap_DC_DrawCheckMarkRect(PyObject *, PyObject *args, PyObject *kwargs) {
12770 PyObject *resultobj;
12771 wxDC *arg1 = (wxDC *) 0 ;
12772 wxRect *arg2 = 0 ;
12773 wxRect temp2 ;
12774 PyObject * obj0 = 0 ;
12775 PyObject * obj1 = 0 ;
12776 char *kwnames[] = {
12777 (char *) "self",(char *) "rect", NULL
12778 };
12779
12780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawCheckMarkRect",kwnames,&obj0,&obj1)) goto fail;
12781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12782 if (SWIG_arg_fail(1)) SWIG_fail;
12783 {
12784 arg2 = &temp2;
12785 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12786 }
12787 {
12788 PyThreadState* __tstate = wxPyBeginAllowThreads();
12789 (arg1)->DrawCheckMark((wxRect const &)*arg2);
12790
12791 wxPyEndAllowThreads(__tstate);
12792 if (PyErr_Occurred()) SWIG_fail;
12793 }
12794 Py_INCREF(Py_None); resultobj = Py_None;
12795 return resultobj;
12796 fail:
12797 return NULL;
12798 }
12799
12800
12801 static PyObject *_wrap_DC_DrawEllipticArc(PyObject *, PyObject *args, PyObject *kwargs) {
12802 PyObject *resultobj;
12803 wxDC *arg1 = (wxDC *) 0 ;
12804 int arg2 ;
12805 int arg3 ;
12806 int arg4 ;
12807 int arg5 ;
12808 double arg6 ;
12809 double arg7 ;
12810 PyObject * obj0 = 0 ;
12811 PyObject * obj1 = 0 ;
12812 PyObject * obj2 = 0 ;
12813 PyObject * obj3 = 0 ;
12814 PyObject * obj4 = 0 ;
12815 PyObject * obj5 = 0 ;
12816 PyObject * obj6 = 0 ;
12817 char *kwnames[] = {
12818 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h",(char *) "start",(char *) "end", NULL
12819 };
12820
12821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawEllipticArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12823 if (SWIG_arg_fail(1)) SWIG_fail;
12824 {
12825 arg2 = (int)(SWIG_As_int(obj1));
12826 if (SWIG_arg_fail(2)) SWIG_fail;
12827 }
12828 {
12829 arg3 = (int)(SWIG_As_int(obj2));
12830 if (SWIG_arg_fail(3)) SWIG_fail;
12831 }
12832 {
12833 arg4 = (int)(SWIG_As_int(obj3));
12834 if (SWIG_arg_fail(4)) SWIG_fail;
12835 }
12836 {
12837 arg5 = (int)(SWIG_As_int(obj4));
12838 if (SWIG_arg_fail(5)) SWIG_fail;
12839 }
12840 {
12841 arg6 = (double)(SWIG_As_double(obj5));
12842 if (SWIG_arg_fail(6)) SWIG_fail;
12843 }
12844 {
12845 arg7 = (double)(SWIG_As_double(obj6));
12846 if (SWIG_arg_fail(7)) SWIG_fail;
12847 }
12848 {
12849 PyThreadState* __tstate = wxPyBeginAllowThreads();
12850 (arg1)->DrawEllipticArc(arg2,arg3,arg4,arg5,arg6,arg7);
12851
12852 wxPyEndAllowThreads(__tstate);
12853 if (PyErr_Occurred()) SWIG_fail;
12854 }
12855 Py_INCREF(Py_None); resultobj = Py_None;
12856 return resultobj;
12857 fail:
12858 return NULL;
12859 }
12860
12861
12862 static PyObject *_wrap_DC_DrawEllipticArcPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
12863 PyObject *resultobj;
12864 wxDC *arg1 = (wxDC *) 0 ;
12865 wxPoint *arg2 = 0 ;
12866 wxSize *arg3 = 0 ;
12867 double arg4 ;
12868 double arg5 ;
12869 wxPoint temp2 ;
12870 wxSize temp3 ;
12871 PyObject * obj0 = 0 ;
12872 PyObject * obj1 = 0 ;
12873 PyObject * obj2 = 0 ;
12874 PyObject * obj3 = 0 ;
12875 PyObject * obj4 = 0 ;
12876 char *kwnames[] = {
12877 (char *) "self",(char *) "pt",(char *) "sz",(char *) "start",(char *) "end", NULL
12878 };
12879
12880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipticArcPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12882 if (SWIG_arg_fail(1)) SWIG_fail;
12883 {
12884 arg2 = &temp2;
12885 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12886 }
12887 {
12888 arg3 = &temp3;
12889 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
12890 }
12891 {
12892 arg4 = (double)(SWIG_As_double(obj3));
12893 if (SWIG_arg_fail(4)) SWIG_fail;
12894 }
12895 {
12896 arg5 = (double)(SWIG_As_double(obj4));
12897 if (SWIG_arg_fail(5)) SWIG_fail;
12898 }
12899 {
12900 PyThreadState* __tstate = wxPyBeginAllowThreads();
12901 (arg1)->DrawEllipticArc((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,arg5);
12902
12903 wxPyEndAllowThreads(__tstate);
12904 if (PyErr_Occurred()) SWIG_fail;
12905 }
12906 Py_INCREF(Py_None); resultobj = Py_None;
12907 return resultobj;
12908 fail:
12909 return NULL;
12910 }
12911
12912
12913 static PyObject *_wrap_DC_DrawPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12914 PyObject *resultobj;
12915 wxDC *arg1 = (wxDC *) 0 ;
12916 int arg2 ;
12917 int arg3 ;
12918 PyObject * obj0 = 0 ;
12919 PyObject * obj1 = 0 ;
12920 PyObject * obj2 = 0 ;
12921 char *kwnames[] = {
12922 (char *) "self",(char *) "x",(char *) "y", NULL
12923 };
12924
12925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
12926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12927 if (SWIG_arg_fail(1)) SWIG_fail;
12928 {
12929 arg2 = (int)(SWIG_As_int(obj1));
12930 if (SWIG_arg_fail(2)) SWIG_fail;
12931 }
12932 {
12933 arg3 = (int)(SWIG_As_int(obj2));
12934 if (SWIG_arg_fail(3)) SWIG_fail;
12935 }
12936 {
12937 PyThreadState* __tstate = wxPyBeginAllowThreads();
12938 (arg1)->DrawPoint(arg2,arg3);
12939
12940 wxPyEndAllowThreads(__tstate);
12941 if (PyErr_Occurred()) SWIG_fail;
12942 }
12943 Py_INCREF(Py_None); resultobj = Py_None;
12944 return resultobj;
12945 fail:
12946 return NULL;
12947 }
12948
12949
12950 static PyObject *_wrap_DC_DrawPointPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12951 PyObject *resultobj;
12952 wxDC *arg1 = (wxDC *) 0 ;
12953 wxPoint *arg2 = 0 ;
12954 wxPoint temp2 ;
12955 PyObject * obj0 = 0 ;
12956 PyObject * obj1 = 0 ;
12957 char *kwnames[] = {
12958 (char *) "self",(char *) "pt", NULL
12959 };
12960
12961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawPointPoint",kwnames,&obj0,&obj1)) goto fail;
12962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12963 if (SWIG_arg_fail(1)) SWIG_fail;
12964 {
12965 arg2 = &temp2;
12966 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12967 }
12968 {
12969 PyThreadState* __tstate = wxPyBeginAllowThreads();
12970 (arg1)->DrawPoint((wxPoint const &)*arg2);
12971
12972 wxPyEndAllowThreads(__tstate);
12973 if (PyErr_Occurred()) SWIG_fail;
12974 }
12975 Py_INCREF(Py_None); resultobj = Py_None;
12976 return resultobj;
12977 fail:
12978 return NULL;
12979 }
12980
12981
12982 static PyObject *_wrap_DC_DrawRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
12983 PyObject *resultobj;
12984 wxDC *arg1 = (wxDC *) 0 ;
12985 int arg2 ;
12986 int arg3 ;
12987 int arg4 ;
12988 int arg5 ;
12989 PyObject * obj0 = 0 ;
12990 PyObject * obj1 = 0 ;
12991 PyObject * obj2 = 0 ;
12992 PyObject * obj3 = 0 ;
12993 PyObject * obj4 = 0 ;
12994 char *kwnames[] = {
12995 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
12996 };
12997
12998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13000 if (SWIG_arg_fail(1)) SWIG_fail;
13001 {
13002 arg2 = (int)(SWIG_As_int(obj1));
13003 if (SWIG_arg_fail(2)) SWIG_fail;
13004 }
13005 {
13006 arg3 = (int)(SWIG_As_int(obj2));
13007 if (SWIG_arg_fail(3)) SWIG_fail;
13008 }
13009 {
13010 arg4 = (int)(SWIG_As_int(obj3));
13011 if (SWIG_arg_fail(4)) SWIG_fail;
13012 }
13013 {
13014 arg5 = (int)(SWIG_As_int(obj4));
13015 if (SWIG_arg_fail(5)) SWIG_fail;
13016 }
13017 {
13018 PyThreadState* __tstate = wxPyBeginAllowThreads();
13019 (arg1)->DrawRectangle(arg2,arg3,arg4,arg5);
13020
13021 wxPyEndAllowThreads(__tstate);
13022 if (PyErr_Occurred()) SWIG_fail;
13023 }
13024 Py_INCREF(Py_None); resultobj = Py_None;
13025 return resultobj;
13026 fail:
13027 return NULL;
13028 }
13029
13030
13031 static PyObject *_wrap_DC_DrawRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13032 PyObject *resultobj;
13033 wxDC *arg1 = (wxDC *) 0 ;
13034 wxRect *arg2 = 0 ;
13035 wxRect temp2 ;
13036 PyObject * obj0 = 0 ;
13037 PyObject * obj1 = 0 ;
13038 char *kwnames[] = {
13039 (char *) "self",(char *) "rect", NULL
13040 };
13041
13042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawRectangleRect",kwnames,&obj0,&obj1)) goto fail;
13043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13044 if (SWIG_arg_fail(1)) SWIG_fail;
13045 {
13046 arg2 = &temp2;
13047 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13048 }
13049 {
13050 PyThreadState* __tstate = wxPyBeginAllowThreads();
13051 (arg1)->DrawRectangle((wxRect const &)*arg2);
13052
13053 wxPyEndAllowThreads(__tstate);
13054 if (PyErr_Occurred()) SWIG_fail;
13055 }
13056 Py_INCREF(Py_None); resultobj = Py_None;
13057 return resultobj;
13058 fail:
13059 return NULL;
13060 }
13061
13062
13063 static PyObject *_wrap_DC_DrawRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13064 PyObject *resultobj;
13065 wxDC *arg1 = (wxDC *) 0 ;
13066 wxPoint *arg2 = 0 ;
13067 wxSize *arg3 = 0 ;
13068 wxPoint temp2 ;
13069 wxSize temp3 ;
13070 PyObject * obj0 = 0 ;
13071 PyObject * obj1 = 0 ;
13072 PyObject * obj2 = 0 ;
13073 char *kwnames[] = {
13074 (char *) "self",(char *) "pt",(char *) "sz", NULL
13075 };
13076
13077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRectanglePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13079 if (SWIG_arg_fail(1)) SWIG_fail;
13080 {
13081 arg2 = &temp2;
13082 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13083 }
13084 {
13085 arg3 = &temp3;
13086 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13087 }
13088 {
13089 PyThreadState* __tstate = wxPyBeginAllowThreads();
13090 (arg1)->DrawRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3);
13091
13092 wxPyEndAllowThreads(__tstate);
13093 if (PyErr_Occurred()) SWIG_fail;
13094 }
13095 Py_INCREF(Py_None); resultobj = Py_None;
13096 return resultobj;
13097 fail:
13098 return NULL;
13099 }
13100
13101
13102 static PyObject *_wrap_DC_DrawRoundedRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
13103 PyObject *resultobj;
13104 wxDC *arg1 = (wxDC *) 0 ;
13105 int arg2 ;
13106 int arg3 ;
13107 int arg4 ;
13108 int arg5 ;
13109 double arg6 ;
13110 PyObject * obj0 = 0 ;
13111 PyObject * obj1 = 0 ;
13112 PyObject * obj2 = 0 ;
13113 PyObject * obj3 = 0 ;
13114 PyObject * obj4 = 0 ;
13115 PyObject * obj5 = 0 ;
13116 char *kwnames[] = {
13117 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "radius", NULL
13118 };
13119
13120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:DC_DrawRoundedRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
13121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13122 if (SWIG_arg_fail(1)) SWIG_fail;
13123 {
13124 arg2 = (int)(SWIG_As_int(obj1));
13125 if (SWIG_arg_fail(2)) SWIG_fail;
13126 }
13127 {
13128 arg3 = (int)(SWIG_As_int(obj2));
13129 if (SWIG_arg_fail(3)) SWIG_fail;
13130 }
13131 {
13132 arg4 = (int)(SWIG_As_int(obj3));
13133 if (SWIG_arg_fail(4)) SWIG_fail;
13134 }
13135 {
13136 arg5 = (int)(SWIG_As_int(obj4));
13137 if (SWIG_arg_fail(5)) SWIG_fail;
13138 }
13139 {
13140 arg6 = (double)(SWIG_As_double(obj5));
13141 if (SWIG_arg_fail(6)) SWIG_fail;
13142 }
13143 {
13144 PyThreadState* __tstate = wxPyBeginAllowThreads();
13145 (arg1)->DrawRoundedRectangle(arg2,arg3,arg4,arg5,arg6);
13146
13147 wxPyEndAllowThreads(__tstate);
13148 if (PyErr_Occurred()) SWIG_fail;
13149 }
13150 Py_INCREF(Py_None); resultobj = Py_None;
13151 return resultobj;
13152 fail:
13153 return NULL;
13154 }
13155
13156
13157 static PyObject *_wrap_DC_DrawRoundedRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13158 PyObject *resultobj;
13159 wxDC *arg1 = (wxDC *) 0 ;
13160 wxRect *arg2 = 0 ;
13161 double arg3 ;
13162 wxRect temp2 ;
13163 PyObject * obj0 = 0 ;
13164 PyObject * obj1 = 0 ;
13165 PyObject * obj2 = 0 ;
13166 char *kwnames[] = {
13167 (char *) "self",(char *) "r",(char *) "radius", NULL
13168 };
13169
13170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRoundedRectangleRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
13171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13172 if (SWIG_arg_fail(1)) SWIG_fail;
13173 {
13174 arg2 = &temp2;
13175 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13176 }
13177 {
13178 arg3 = (double)(SWIG_As_double(obj2));
13179 if (SWIG_arg_fail(3)) SWIG_fail;
13180 }
13181 {
13182 PyThreadState* __tstate = wxPyBeginAllowThreads();
13183 (arg1)->DrawRoundedRectangle((wxRect const &)*arg2,arg3);
13184
13185 wxPyEndAllowThreads(__tstate);
13186 if (PyErr_Occurred()) SWIG_fail;
13187 }
13188 Py_INCREF(Py_None); resultobj = Py_None;
13189 return resultobj;
13190 fail:
13191 return NULL;
13192 }
13193
13194
13195 static PyObject *_wrap_DC_DrawRoundedRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13196 PyObject *resultobj;
13197 wxDC *arg1 = (wxDC *) 0 ;
13198 wxPoint *arg2 = 0 ;
13199 wxSize *arg3 = 0 ;
13200 double arg4 ;
13201 wxPoint temp2 ;
13202 wxSize temp3 ;
13203 PyObject * obj0 = 0 ;
13204 PyObject * obj1 = 0 ;
13205 PyObject * obj2 = 0 ;
13206 PyObject * obj3 = 0 ;
13207 char *kwnames[] = {
13208 (char *) "self",(char *) "pt",(char *) "sz",(char *) "radius", NULL
13209 };
13210
13211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRoundedRectanglePointSize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13213 if (SWIG_arg_fail(1)) SWIG_fail;
13214 {
13215 arg2 = &temp2;
13216 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13217 }
13218 {
13219 arg3 = &temp3;
13220 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13221 }
13222 {
13223 arg4 = (double)(SWIG_As_double(obj3));
13224 if (SWIG_arg_fail(4)) SWIG_fail;
13225 }
13226 {
13227 PyThreadState* __tstate = wxPyBeginAllowThreads();
13228 (arg1)->DrawRoundedRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4);
13229
13230 wxPyEndAllowThreads(__tstate);
13231 if (PyErr_Occurred()) SWIG_fail;
13232 }
13233 Py_INCREF(Py_None); resultobj = Py_None;
13234 return resultobj;
13235 fail:
13236 return NULL;
13237 }
13238
13239
13240 static PyObject *_wrap_DC_DrawCircle(PyObject *, PyObject *args, PyObject *kwargs) {
13241 PyObject *resultobj;
13242 wxDC *arg1 = (wxDC *) 0 ;
13243 int arg2 ;
13244 int arg3 ;
13245 int arg4 ;
13246 PyObject * obj0 = 0 ;
13247 PyObject * obj1 = 0 ;
13248 PyObject * obj2 = 0 ;
13249 PyObject * obj3 = 0 ;
13250 char *kwnames[] = {
13251 (char *) "self",(char *) "x",(char *) "y",(char *) "radius", NULL
13252 };
13253
13254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawCircle",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13256 if (SWIG_arg_fail(1)) SWIG_fail;
13257 {
13258 arg2 = (int)(SWIG_As_int(obj1));
13259 if (SWIG_arg_fail(2)) SWIG_fail;
13260 }
13261 {
13262 arg3 = (int)(SWIG_As_int(obj2));
13263 if (SWIG_arg_fail(3)) SWIG_fail;
13264 }
13265 {
13266 arg4 = (int)(SWIG_As_int(obj3));
13267 if (SWIG_arg_fail(4)) SWIG_fail;
13268 }
13269 {
13270 PyThreadState* __tstate = wxPyBeginAllowThreads();
13271 (arg1)->DrawCircle(arg2,arg3,arg4);
13272
13273 wxPyEndAllowThreads(__tstate);
13274 if (PyErr_Occurred()) SWIG_fail;
13275 }
13276 Py_INCREF(Py_None); resultobj = Py_None;
13277 return resultobj;
13278 fail:
13279 return NULL;
13280 }
13281
13282
13283 static PyObject *_wrap_DC_DrawCirclePoint(PyObject *, PyObject *args, PyObject *kwargs) {
13284 PyObject *resultobj;
13285 wxDC *arg1 = (wxDC *) 0 ;
13286 wxPoint *arg2 = 0 ;
13287 int arg3 ;
13288 wxPoint temp2 ;
13289 PyObject * obj0 = 0 ;
13290 PyObject * obj1 = 0 ;
13291 PyObject * obj2 = 0 ;
13292 char *kwnames[] = {
13293 (char *) "self",(char *) "pt",(char *) "radius", NULL
13294 };
13295
13296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawCirclePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13298 if (SWIG_arg_fail(1)) SWIG_fail;
13299 {
13300 arg2 = &temp2;
13301 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13302 }
13303 {
13304 arg3 = (int)(SWIG_As_int(obj2));
13305 if (SWIG_arg_fail(3)) SWIG_fail;
13306 }
13307 {
13308 PyThreadState* __tstate = wxPyBeginAllowThreads();
13309 (arg1)->DrawCircle((wxPoint const &)*arg2,arg3);
13310
13311 wxPyEndAllowThreads(__tstate);
13312 if (PyErr_Occurred()) SWIG_fail;
13313 }
13314 Py_INCREF(Py_None); resultobj = Py_None;
13315 return resultobj;
13316 fail:
13317 return NULL;
13318 }
13319
13320
13321 static PyObject *_wrap_DC_DrawEllipse(PyObject *, PyObject *args, PyObject *kwargs) {
13322 PyObject *resultobj;
13323 wxDC *arg1 = (wxDC *) 0 ;
13324 int arg2 ;
13325 int arg3 ;
13326 int arg4 ;
13327 int arg5 ;
13328 PyObject * obj0 = 0 ;
13329 PyObject * obj1 = 0 ;
13330 PyObject * obj2 = 0 ;
13331 PyObject * obj3 = 0 ;
13332 PyObject * obj4 = 0 ;
13333 char *kwnames[] = {
13334 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13335 };
13336
13337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipse",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13339 if (SWIG_arg_fail(1)) SWIG_fail;
13340 {
13341 arg2 = (int)(SWIG_As_int(obj1));
13342 if (SWIG_arg_fail(2)) SWIG_fail;
13343 }
13344 {
13345 arg3 = (int)(SWIG_As_int(obj2));
13346 if (SWIG_arg_fail(3)) SWIG_fail;
13347 }
13348 {
13349 arg4 = (int)(SWIG_As_int(obj3));
13350 if (SWIG_arg_fail(4)) SWIG_fail;
13351 }
13352 {
13353 arg5 = (int)(SWIG_As_int(obj4));
13354 if (SWIG_arg_fail(5)) SWIG_fail;
13355 }
13356 {
13357 PyThreadState* __tstate = wxPyBeginAllowThreads();
13358 (arg1)->DrawEllipse(arg2,arg3,arg4,arg5);
13359
13360 wxPyEndAllowThreads(__tstate);
13361 if (PyErr_Occurred()) SWIG_fail;
13362 }
13363 Py_INCREF(Py_None); resultobj = Py_None;
13364 return resultobj;
13365 fail:
13366 return NULL;
13367 }
13368
13369
13370 static PyObject *_wrap_DC_DrawEllipseRect(PyObject *, PyObject *args, PyObject *kwargs) {
13371 PyObject *resultobj;
13372 wxDC *arg1 = (wxDC *) 0 ;
13373 wxRect *arg2 = 0 ;
13374 wxRect temp2 ;
13375 PyObject * obj0 = 0 ;
13376 PyObject * obj1 = 0 ;
13377 char *kwnames[] = {
13378 (char *) "self",(char *) "rect", NULL
13379 };
13380
13381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawEllipseRect",kwnames,&obj0,&obj1)) goto fail;
13382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13383 if (SWIG_arg_fail(1)) SWIG_fail;
13384 {
13385 arg2 = &temp2;
13386 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13387 }
13388 {
13389 PyThreadState* __tstate = wxPyBeginAllowThreads();
13390 (arg1)->DrawEllipse((wxRect const &)*arg2);
13391
13392 wxPyEndAllowThreads(__tstate);
13393 if (PyErr_Occurred()) SWIG_fail;
13394 }
13395 Py_INCREF(Py_None); resultobj = Py_None;
13396 return resultobj;
13397 fail:
13398 return NULL;
13399 }
13400
13401
13402 static PyObject *_wrap_DC_DrawEllipsePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13403 PyObject *resultobj;
13404 wxDC *arg1 = (wxDC *) 0 ;
13405 wxPoint *arg2 = 0 ;
13406 wxSize *arg3 = 0 ;
13407 wxPoint temp2 ;
13408 wxSize temp3 ;
13409 PyObject * obj0 = 0 ;
13410 PyObject * obj1 = 0 ;
13411 PyObject * obj2 = 0 ;
13412 char *kwnames[] = {
13413 (char *) "self",(char *) "pt",(char *) "sz", NULL
13414 };
13415
13416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawEllipsePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13418 if (SWIG_arg_fail(1)) SWIG_fail;
13419 {
13420 arg2 = &temp2;
13421 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13422 }
13423 {
13424 arg3 = &temp3;
13425 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13426 }
13427 {
13428 PyThreadState* __tstate = wxPyBeginAllowThreads();
13429 (arg1)->DrawEllipse((wxPoint const &)*arg2,(wxSize const &)*arg3);
13430
13431 wxPyEndAllowThreads(__tstate);
13432 if (PyErr_Occurred()) SWIG_fail;
13433 }
13434 Py_INCREF(Py_None); resultobj = Py_None;
13435 return resultobj;
13436 fail:
13437 return NULL;
13438 }
13439
13440
13441 static PyObject *_wrap_DC_DrawIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13442 PyObject *resultobj;
13443 wxDC *arg1 = (wxDC *) 0 ;
13444 wxIcon *arg2 = 0 ;
13445 int arg3 ;
13446 int arg4 ;
13447 PyObject * obj0 = 0 ;
13448 PyObject * obj1 = 0 ;
13449 PyObject * obj2 = 0 ;
13450 PyObject * obj3 = 0 ;
13451 char *kwnames[] = {
13452 (char *) "self",(char *) "icon",(char *) "x",(char *) "y", NULL
13453 };
13454
13455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawIcon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13457 if (SWIG_arg_fail(1)) SWIG_fail;
13458 {
13459 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
13460 if (SWIG_arg_fail(2)) SWIG_fail;
13461 if (arg2 == NULL) {
13462 SWIG_null_ref("wxIcon");
13463 }
13464 if (SWIG_arg_fail(2)) SWIG_fail;
13465 }
13466 {
13467 arg3 = (int)(SWIG_As_int(obj2));
13468 if (SWIG_arg_fail(3)) SWIG_fail;
13469 }
13470 {
13471 arg4 = (int)(SWIG_As_int(obj3));
13472 if (SWIG_arg_fail(4)) SWIG_fail;
13473 }
13474 {
13475 PyThreadState* __tstate = wxPyBeginAllowThreads();
13476 (arg1)->DrawIcon((wxIcon const &)*arg2,arg3,arg4);
13477
13478 wxPyEndAllowThreads(__tstate);
13479 if (PyErr_Occurred()) SWIG_fail;
13480 }
13481 Py_INCREF(Py_None); resultobj = Py_None;
13482 return resultobj;
13483 fail:
13484 return NULL;
13485 }
13486
13487
13488 static PyObject *_wrap_DC_DrawIconPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13489 PyObject *resultobj;
13490 wxDC *arg1 = (wxDC *) 0 ;
13491 wxIcon *arg2 = 0 ;
13492 wxPoint *arg3 = 0 ;
13493 wxPoint temp3 ;
13494 PyObject * obj0 = 0 ;
13495 PyObject * obj1 = 0 ;
13496 PyObject * obj2 = 0 ;
13497 char *kwnames[] = {
13498 (char *) "self",(char *) "icon",(char *) "pt", NULL
13499 };
13500
13501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawIconPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13503 if (SWIG_arg_fail(1)) SWIG_fail;
13504 {
13505 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
13506 if (SWIG_arg_fail(2)) SWIG_fail;
13507 if (arg2 == NULL) {
13508 SWIG_null_ref("wxIcon");
13509 }
13510 if (SWIG_arg_fail(2)) SWIG_fail;
13511 }
13512 {
13513 arg3 = &temp3;
13514 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13515 }
13516 {
13517 PyThreadState* __tstate = wxPyBeginAllowThreads();
13518 (arg1)->DrawIcon((wxIcon const &)*arg2,(wxPoint const &)*arg3);
13519
13520 wxPyEndAllowThreads(__tstate);
13521 if (PyErr_Occurred()) SWIG_fail;
13522 }
13523 Py_INCREF(Py_None); resultobj = Py_None;
13524 return resultobj;
13525 fail:
13526 return NULL;
13527 }
13528
13529
13530 static PyObject *_wrap_DC_DrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13531 PyObject *resultobj;
13532 wxDC *arg1 = (wxDC *) 0 ;
13533 wxBitmap *arg2 = 0 ;
13534 int arg3 ;
13535 int arg4 ;
13536 bool arg5 = (bool) false ;
13537 PyObject * obj0 = 0 ;
13538 PyObject * obj1 = 0 ;
13539 PyObject * obj2 = 0 ;
13540 PyObject * obj3 = 0 ;
13541 PyObject * obj4 = 0 ;
13542 char *kwnames[] = {
13543 (char *) "self",(char *) "bmp",(char *) "x",(char *) "y",(char *) "useMask", NULL
13544 };
13545
13546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_DrawBitmap",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13548 if (SWIG_arg_fail(1)) SWIG_fail;
13549 {
13550 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
13551 if (SWIG_arg_fail(2)) SWIG_fail;
13552 if (arg2 == NULL) {
13553 SWIG_null_ref("wxBitmap");
13554 }
13555 if (SWIG_arg_fail(2)) SWIG_fail;
13556 }
13557 {
13558 arg3 = (int)(SWIG_As_int(obj2));
13559 if (SWIG_arg_fail(3)) SWIG_fail;
13560 }
13561 {
13562 arg4 = (int)(SWIG_As_int(obj3));
13563 if (SWIG_arg_fail(4)) SWIG_fail;
13564 }
13565 if (obj4) {
13566 {
13567 arg5 = (bool)(SWIG_As_bool(obj4));
13568 if (SWIG_arg_fail(5)) SWIG_fail;
13569 }
13570 }
13571 {
13572 PyThreadState* __tstate = wxPyBeginAllowThreads();
13573 (arg1)->DrawBitmap((wxBitmap const &)*arg2,arg3,arg4,arg5);
13574
13575 wxPyEndAllowThreads(__tstate);
13576 if (PyErr_Occurred()) SWIG_fail;
13577 }
13578 Py_INCREF(Py_None); resultobj = Py_None;
13579 return resultobj;
13580 fail:
13581 return NULL;
13582 }
13583
13584
13585 static PyObject *_wrap_DC_DrawBitmapPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13586 PyObject *resultobj;
13587 wxDC *arg1 = (wxDC *) 0 ;
13588 wxBitmap *arg2 = 0 ;
13589 wxPoint *arg3 = 0 ;
13590 bool arg4 = (bool) false ;
13591 wxPoint temp3 ;
13592 PyObject * obj0 = 0 ;
13593 PyObject * obj1 = 0 ;
13594 PyObject * obj2 = 0 ;
13595 PyObject * obj3 = 0 ;
13596 char *kwnames[] = {
13597 (char *) "self",(char *) "bmp",(char *) "pt",(char *) "useMask", NULL
13598 };
13599
13600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_DrawBitmapPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13602 if (SWIG_arg_fail(1)) SWIG_fail;
13603 {
13604 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
13605 if (SWIG_arg_fail(2)) SWIG_fail;
13606 if (arg2 == NULL) {
13607 SWIG_null_ref("wxBitmap");
13608 }
13609 if (SWIG_arg_fail(2)) SWIG_fail;
13610 }
13611 {
13612 arg3 = &temp3;
13613 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13614 }
13615 if (obj3) {
13616 {
13617 arg4 = (bool)(SWIG_As_bool(obj3));
13618 if (SWIG_arg_fail(4)) SWIG_fail;
13619 }
13620 }
13621 {
13622 PyThreadState* __tstate = wxPyBeginAllowThreads();
13623 (arg1)->DrawBitmap((wxBitmap const &)*arg2,(wxPoint const &)*arg3,arg4);
13624
13625 wxPyEndAllowThreads(__tstate);
13626 if (PyErr_Occurred()) SWIG_fail;
13627 }
13628 Py_INCREF(Py_None); resultobj = Py_None;
13629 return resultobj;
13630 fail:
13631 return NULL;
13632 }
13633
13634
13635 static PyObject *_wrap_DC_DrawText(PyObject *, PyObject *args, PyObject *kwargs) {
13636 PyObject *resultobj;
13637 wxDC *arg1 = (wxDC *) 0 ;
13638 wxString *arg2 = 0 ;
13639 int arg3 ;
13640 int arg4 ;
13641 bool temp2 = false ;
13642 PyObject * obj0 = 0 ;
13643 PyObject * obj1 = 0 ;
13644 PyObject * obj2 = 0 ;
13645 PyObject * obj3 = 0 ;
13646 char *kwnames[] = {
13647 (char *) "self",(char *) "text",(char *) "x",(char *) "y", NULL
13648 };
13649
13650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawText",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13652 if (SWIG_arg_fail(1)) SWIG_fail;
13653 {
13654 arg2 = wxString_in_helper(obj1);
13655 if (arg2 == NULL) SWIG_fail;
13656 temp2 = true;
13657 }
13658 {
13659 arg3 = (int)(SWIG_As_int(obj2));
13660 if (SWIG_arg_fail(3)) SWIG_fail;
13661 }
13662 {
13663 arg4 = (int)(SWIG_As_int(obj3));
13664 if (SWIG_arg_fail(4)) SWIG_fail;
13665 }
13666 {
13667 PyThreadState* __tstate = wxPyBeginAllowThreads();
13668 (arg1)->DrawText((wxString const &)*arg2,arg3,arg4);
13669
13670 wxPyEndAllowThreads(__tstate);
13671 if (PyErr_Occurred()) SWIG_fail;
13672 }
13673 Py_INCREF(Py_None); resultobj = Py_None;
13674 {
13675 if (temp2)
13676 delete arg2;
13677 }
13678 return resultobj;
13679 fail:
13680 {
13681 if (temp2)
13682 delete arg2;
13683 }
13684 return NULL;
13685 }
13686
13687
13688 static PyObject *_wrap_DC_DrawTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13689 PyObject *resultobj;
13690 wxDC *arg1 = (wxDC *) 0 ;
13691 wxString *arg2 = 0 ;
13692 wxPoint *arg3 = 0 ;
13693 bool temp2 = false ;
13694 wxPoint temp3 ;
13695 PyObject * obj0 = 0 ;
13696 PyObject * obj1 = 0 ;
13697 PyObject * obj2 = 0 ;
13698 char *kwnames[] = {
13699 (char *) "self",(char *) "text",(char *) "pt", NULL
13700 };
13701
13702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawTextPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13704 if (SWIG_arg_fail(1)) SWIG_fail;
13705 {
13706 arg2 = wxString_in_helper(obj1);
13707 if (arg2 == NULL) SWIG_fail;
13708 temp2 = true;
13709 }
13710 {
13711 arg3 = &temp3;
13712 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13713 }
13714 {
13715 PyThreadState* __tstate = wxPyBeginAllowThreads();
13716 (arg1)->DrawText((wxString const &)*arg2,(wxPoint const &)*arg3);
13717
13718 wxPyEndAllowThreads(__tstate);
13719 if (PyErr_Occurred()) SWIG_fail;
13720 }
13721 Py_INCREF(Py_None); resultobj = Py_None;
13722 {
13723 if (temp2)
13724 delete arg2;
13725 }
13726 return resultobj;
13727 fail:
13728 {
13729 if (temp2)
13730 delete arg2;
13731 }
13732 return NULL;
13733 }
13734
13735
13736 static PyObject *_wrap_DC_DrawRotatedText(PyObject *, PyObject *args, PyObject *kwargs) {
13737 PyObject *resultobj;
13738 wxDC *arg1 = (wxDC *) 0 ;
13739 wxString *arg2 = 0 ;
13740 int arg3 ;
13741 int arg4 ;
13742 double arg5 ;
13743 bool temp2 = false ;
13744 PyObject * obj0 = 0 ;
13745 PyObject * obj1 = 0 ;
13746 PyObject * obj2 = 0 ;
13747 PyObject * obj3 = 0 ;
13748 PyObject * obj4 = 0 ;
13749 char *kwnames[] = {
13750 (char *) "self",(char *) "text",(char *) "x",(char *) "y",(char *) "angle", NULL
13751 };
13752
13753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRotatedText",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13755 if (SWIG_arg_fail(1)) SWIG_fail;
13756 {
13757 arg2 = wxString_in_helper(obj1);
13758 if (arg2 == NULL) SWIG_fail;
13759 temp2 = true;
13760 }
13761 {
13762 arg3 = (int)(SWIG_As_int(obj2));
13763 if (SWIG_arg_fail(3)) SWIG_fail;
13764 }
13765 {
13766 arg4 = (int)(SWIG_As_int(obj3));
13767 if (SWIG_arg_fail(4)) SWIG_fail;
13768 }
13769 {
13770 arg5 = (double)(SWIG_As_double(obj4));
13771 if (SWIG_arg_fail(5)) SWIG_fail;
13772 }
13773 {
13774 PyThreadState* __tstate = wxPyBeginAllowThreads();
13775 (arg1)->DrawRotatedText((wxString const &)*arg2,arg3,arg4,arg5);
13776
13777 wxPyEndAllowThreads(__tstate);
13778 if (PyErr_Occurred()) SWIG_fail;
13779 }
13780 Py_INCREF(Py_None); resultobj = Py_None;
13781 {
13782 if (temp2)
13783 delete arg2;
13784 }
13785 return resultobj;
13786 fail:
13787 {
13788 if (temp2)
13789 delete arg2;
13790 }
13791 return NULL;
13792 }
13793
13794
13795 static PyObject *_wrap_DC_DrawRotatedTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13796 PyObject *resultobj;
13797 wxDC *arg1 = (wxDC *) 0 ;
13798 wxString *arg2 = 0 ;
13799 wxPoint *arg3 = 0 ;
13800 double arg4 ;
13801 bool temp2 = false ;
13802 wxPoint temp3 ;
13803 PyObject * obj0 = 0 ;
13804 PyObject * obj1 = 0 ;
13805 PyObject * obj2 = 0 ;
13806 PyObject * obj3 = 0 ;
13807 char *kwnames[] = {
13808 (char *) "self",(char *) "text",(char *) "pt",(char *) "angle", NULL
13809 };
13810
13811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRotatedTextPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13813 if (SWIG_arg_fail(1)) SWIG_fail;
13814 {
13815 arg2 = wxString_in_helper(obj1);
13816 if (arg2 == NULL) SWIG_fail;
13817 temp2 = true;
13818 }
13819 {
13820 arg3 = &temp3;
13821 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13822 }
13823 {
13824 arg4 = (double)(SWIG_As_double(obj3));
13825 if (SWIG_arg_fail(4)) SWIG_fail;
13826 }
13827 {
13828 PyThreadState* __tstate = wxPyBeginAllowThreads();
13829 (arg1)->DrawRotatedText((wxString const &)*arg2,(wxPoint const &)*arg3,arg4);
13830
13831 wxPyEndAllowThreads(__tstate);
13832 if (PyErr_Occurred()) SWIG_fail;
13833 }
13834 Py_INCREF(Py_None); resultobj = Py_None;
13835 {
13836 if (temp2)
13837 delete arg2;
13838 }
13839 return resultobj;
13840 fail:
13841 {
13842 if (temp2)
13843 delete arg2;
13844 }
13845 return NULL;
13846 }
13847
13848
13849 static PyObject *_wrap_DC_Blit(PyObject *, PyObject *args, PyObject *kwargs) {
13850 PyObject *resultobj;
13851 wxDC *arg1 = (wxDC *) 0 ;
13852 int arg2 ;
13853 int arg3 ;
13854 int arg4 ;
13855 int arg5 ;
13856 wxDC *arg6 = (wxDC *) 0 ;
13857 int arg7 ;
13858 int arg8 ;
13859 int arg9 = (int) wxCOPY ;
13860 bool arg10 = (bool) false ;
13861 int arg11 = (int) -1 ;
13862 int arg12 = (int) -1 ;
13863 bool result;
13864 PyObject * obj0 = 0 ;
13865 PyObject * obj1 = 0 ;
13866 PyObject * obj2 = 0 ;
13867 PyObject * obj3 = 0 ;
13868 PyObject * obj4 = 0 ;
13869 PyObject * obj5 = 0 ;
13870 PyObject * obj6 = 0 ;
13871 PyObject * obj7 = 0 ;
13872 PyObject * obj8 = 0 ;
13873 PyObject * obj9 = 0 ;
13874 PyObject * obj10 = 0 ;
13875 PyObject * obj11 = 0 ;
13876 char *kwnames[] = {
13877 (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
13878 };
13879
13880 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;
13881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13882 if (SWIG_arg_fail(1)) SWIG_fail;
13883 {
13884 arg2 = (int)(SWIG_As_int(obj1));
13885 if (SWIG_arg_fail(2)) SWIG_fail;
13886 }
13887 {
13888 arg3 = (int)(SWIG_As_int(obj2));
13889 if (SWIG_arg_fail(3)) SWIG_fail;
13890 }
13891 {
13892 arg4 = (int)(SWIG_As_int(obj3));
13893 if (SWIG_arg_fail(4)) SWIG_fail;
13894 }
13895 {
13896 arg5 = (int)(SWIG_As_int(obj4));
13897 if (SWIG_arg_fail(5)) SWIG_fail;
13898 }
13899 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13900 if (SWIG_arg_fail(6)) SWIG_fail;
13901 {
13902 arg7 = (int)(SWIG_As_int(obj6));
13903 if (SWIG_arg_fail(7)) SWIG_fail;
13904 }
13905 {
13906 arg8 = (int)(SWIG_As_int(obj7));
13907 if (SWIG_arg_fail(8)) SWIG_fail;
13908 }
13909 if (obj8) {
13910 {
13911 arg9 = (int)(SWIG_As_int(obj8));
13912 if (SWIG_arg_fail(9)) SWIG_fail;
13913 }
13914 }
13915 if (obj9) {
13916 {
13917 arg10 = (bool)(SWIG_As_bool(obj9));
13918 if (SWIG_arg_fail(10)) SWIG_fail;
13919 }
13920 }
13921 if (obj10) {
13922 {
13923 arg11 = (int)(SWIG_As_int(obj10));
13924 if (SWIG_arg_fail(11)) SWIG_fail;
13925 }
13926 }
13927 if (obj11) {
13928 {
13929 arg12 = (int)(SWIG_As_int(obj11));
13930 if (SWIG_arg_fail(12)) SWIG_fail;
13931 }
13932 }
13933 {
13934 PyThreadState* __tstate = wxPyBeginAllowThreads();
13935 result = (bool)(arg1)->Blit(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
13936
13937 wxPyEndAllowThreads(__tstate);
13938 if (PyErr_Occurred()) SWIG_fail;
13939 }
13940 {
13941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13942 }
13943 return resultobj;
13944 fail:
13945 return NULL;
13946 }
13947
13948
13949 static PyObject *_wrap_DC_BlitPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13950 PyObject *resultobj;
13951 wxDC *arg1 = (wxDC *) 0 ;
13952 wxPoint *arg2 = 0 ;
13953 wxSize *arg3 = 0 ;
13954 wxDC *arg4 = (wxDC *) 0 ;
13955 wxPoint *arg5 = 0 ;
13956 int arg6 = (int) wxCOPY ;
13957 bool arg7 = (bool) false ;
13958 wxPoint const &arg8_defvalue = wxDefaultPosition ;
13959 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
13960 bool result;
13961 wxPoint temp2 ;
13962 wxSize temp3 ;
13963 wxPoint temp5 ;
13964 wxPoint temp8 ;
13965 PyObject * obj0 = 0 ;
13966 PyObject * obj1 = 0 ;
13967 PyObject * obj2 = 0 ;
13968 PyObject * obj3 = 0 ;
13969 PyObject * obj4 = 0 ;
13970 PyObject * obj5 = 0 ;
13971 PyObject * obj6 = 0 ;
13972 PyObject * obj7 = 0 ;
13973 char *kwnames[] = {
13974 (char *) "self",(char *) "destPt",(char *) "sz",(char *) "source",(char *) "srcPt",(char *) "rop",(char *) "useMask",(char *) "srcPtMask", NULL
13975 };
13976
13977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:DC_BlitPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
13978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13979 if (SWIG_arg_fail(1)) SWIG_fail;
13980 {
13981 arg2 = &temp2;
13982 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13983 }
13984 {
13985 arg3 = &temp3;
13986 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13987 }
13988 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13989 if (SWIG_arg_fail(4)) SWIG_fail;
13990 {
13991 arg5 = &temp5;
13992 if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
13993 }
13994 if (obj5) {
13995 {
13996 arg6 = (int)(SWIG_As_int(obj5));
13997 if (SWIG_arg_fail(6)) SWIG_fail;
13998 }
13999 }
14000 if (obj6) {
14001 {
14002 arg7 = (bool)(SWIG_As_bool(obj6));
14003 if (SWIG_arg_fail(7)) SWIG_fail;
14004 }
14005 }
14006 if (obj7) {
14007 {
14008 arg8 = &temp8;
14009 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
14010 }
14011 }
14012 {
14013 PyThreadState* __tstate = wxPyBeginAllowThreads();
14014 result = (bool)(arg1)->Blit((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,(wxPoint const &)*arg5,arg6,arg7,(wxPoint const &)*arg8);
14015
14016 wxPyEndAllowThreads(__tstate);
14017 if (PyErr_Occurred()) SWIG_fail;
14018 }
14019 {
14020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14021 }
14022 return resultobj;
14023 fail:
14024 return NULL;
14025 }
14026
14027
14028 static PyObject *_wrap_DC_SetClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14029 PyObject *resultobj;
14030 wxDC *arg1 = (wxDC *) 0 ;
14031 int arg2 ;
14032 int arg3 ;
14033 int arg4 ;
14034 int arg5 ;
14035 PyObject * obj0 = 0 ;
14036 PyObject * obj1 = 0 ;
14037 PyObject * obj2 = 0 ;
14038 PyObject * obj3 = 0 ;
14039 PyObject * obj4 = 0 ;
14040 char *kwnames[] = {
14041 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
14042 };
14043
14044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_SetClippingRegion",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14046 if (SWIG_arg_fail(1)) SWIG_fail;
14047 {
14048 arg2 = (int)(SWIG_As_int(obj1));
14049 if (SWIG_arg_fail(2)) SWIG_fail;
14050 }
14051 {
14052 arg3 = (int)(SWIG_As_int(obj2));
14053 if (SWIG_arg_fail(3)) SWIG_fail;
14054 }
14055 {
14056 arg4 = (int)(SWIG_As_int(obj3));
14057 if (SWIG_arg_fail(4)) SWIG_fail;
14058 }
14059 {
14060 arg5 = (int)(SWIG_As_int(obj4));
14061 if (SWIG_arg_fail(5)) SWIG_fail;
14062 }
14063 {
14064 PyThreadState* __tstate = wxPyBeginAllowThreads();
14065 (arg1)->SetClippingRegion(arg2,arg3,arg4,arg5);
14066
14067 wxPyEndAllowThreads(__tstate);
14068 if (PyErr_Occurred()) SWIG_fail;
14069 }
14070 Py_INCREF(Py_None); resultobj = Py_None;
14071 return resultobj;
14072 fail:
14073 return NULL;
14074 }
14075
14076
14077 static PyObject *_wrap_DC_SetClippingRegionPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14078 PyObject *resultobj;
14079 wxDC *arg1 = (wxDC *) 0 ;
14080 wxPoint *arg2 = 0 ;
14081 wxSize *arg3 = 0 ;
14082 wxPoint temp2 ;
14083 wxSize temp3 ;
14084 PyObject * obj0 = 0 ;
14085 PyObject * obj1 = 0 ;
14086 PyObject * obj2 = 0 ;
14087 char *kwnames[] = {
14088 (char *) "self",(char *) "pt",(char *) "sz", NULL
14089 };
14090
14091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetClippingRegionPointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14093 if (SWIG_arg_fail(1)) SWIG_fail;
14094 {
14095 arg2 = &temp2;
14096 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14097 }
14098 {
14099 arg3 = &temp3;
14100 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14101 }
14102 {
14103 PyThreadState* __tstate = wxPyBeginAllowThreads();
14104 (arg1)->SetClippingRegion((wxPoint const &)*arg2,(wxSize const &)*arg3);
14105
14106 wxPyEndAllowThreads(__tstate);
14107 if (PyErr_Occurred()) SWIG_fail;
14108 }
14109 Py_INCREF(Py_None); resultobj = Py_None;
14110 return resultobj;
14111 fail:
14112 return NULL;
14113 }
14114
14115
14116 static PyObject *_wrap_DC_SetClippingRegionAsRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14117 PyObject *resultobj;
14118 wxDC *arg1 = (wxDC *) 0 ;
14119 wxRegion *arg2 = 0 ;
14120 PyObject * obj0 = 0 ;
14121 PyObject * obj1 = 0 ;
14122 char *kwnames[] = {
14123 (char *) "self",(char *) "region", NULL
14124 };
14125
14126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRegionAsRegion",kwnames,&obj0,&obj1)) goto fail;
14127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14128 if (SWIG_arg_fail(1)) SWIG_fail;
14129 {
14130 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
14131 if (SWIG_arg_fail(2)) SWIG_fail;
14132 if (arg2 == NULL) {
14133 SWIG_null_ref("wxRegion");
14134 }
14135 if (SWIG_arg_fail(2)) SWIG_fail;
14136 }
14137 {
14138 PyThreadState* __tstate = wxPyBeginAllowThreads();
14139 (arg1)->SetClippingRegion((wxRegion const &)*arg2);
14140
14141 wxPyEndAllowThreads(__tstate);
14142 if (PyErr_Occurred()) SWIG_fail;
14143 }
14144 Py_INCREF(Py_None); resultobj = Py_None;
14145 return resultobj;
14146 fail:
14147 return NULL;
14148 }
14149
14150
14151 static PyObject *_wrap_DC_SetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
14152 PyObject *resultobj;
14153 wxDC *arg1 = (wxDC *) 0 ;
14154 wxRect *arg2 = 0 ;
14155 wxRect temp2 ;
14156 PyObject * obj0 = 0 ;
14157 PyObject * obj1 = 0 ;
14158 char *kwnames[] = {
14159 (char *) "self",(char *) "rect", NULL
14160 };
14161
14162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRect",kwnames,&obj0,&obj1)) goto fail;
14163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14164 if (SWIG_arg_fail(1)) SWIG_fail;
14165 {
14166 arg2 = &temp2;
14167 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14168 }
14169 {
14170 PyThreadState* __tstate = wxPyBeginAllowThreads();
14171 (arg1)->SetClippingRegion((wxRect const &)*arg2);
14172
14173 wxPyEndAllowThreads(__tstate);
14174 if (PyErr_Occurred()) SWIG_fail;
14175 }
14176 Py_INCREF(Py_None); resultobj = Py_None;
14177 return resultobj;
14178 fail:
14179 return NULL;
14180 }
14181
14182
14183 static PyObject *_wrap_DC_DrawLines(PyObject *, PyObject *args, PyObject *kwargs) {
14184 PyObject *resultobj;
14185 wxDC *arg1 = (wxDC *) 0 ;
14186 int arg2 ;
14187 wxPoint *arg3 = (wxPoint *) 0 ;
14188 int arg4 = (int) 0 ;
14189 int arg5 = (int) 0 ;
14190 PyObject * obj0 = 0 ;
14191 PyObject * obj1 = 0 ;
14192 PyObject * obj2 = 0 ;
14193 PyObject * obj3 = 0 ;
14194 char *kwnames[] = {
14195 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset", NULL
14196 };
14197
14198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DC_DrawLines",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14200 if (SWIG_arg_fail(1)) SWIG_fail;
14201 {
14202 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14203 if (arg3 == NULL) SWIG_fail;
14204 }
14205 if (obj2) {
14206 {
14207 arg4 = (int)(SWIG_As_int(obj2));
14208 if (SWIG_arg_fail(4)) SWIG_fail;
14209 }
14210 }
14211 if (obj3) {
14212 {
14213 arg5 = (int)(SWIG_As_int(obj3));
14214 if (SWIG_arg_fail(5)) SWIG_fail;
14215 }
14216 }
14217 {
14218 PyThreadState* __tstate = wxPyBeginAllowThreads();
14219 (arg1)->DrawLines(arg2,arg3,arg4,arg5);
14220
14221 wxPyEndAllowThreads(__tstate);
14222 if (PyErr_Occurred()) SWIG_fail;
14223 }
14224 Py_INCREF(Py_None); resultobj = Py_None;
14225 {
14226 if (arg3) delete [] arg3;
14227 }
14228 return resultobj;
14229 fail:
14230 {
14231 if (arg3) delete [] arg3;
14232 }
14233 return NULL;
14234 }
14235
14236
14237 static PyObject *_wrap_DC_DrawPolygon(PyObject *, PyObject *args, PyObject *kwargs) {
14238 PyObject *resultobj;
14239 wxDC *arg1 = (wxDC *) 0 ;
14240 int arg2 ;
14241 wxPoint *arg3 = (wxPoint *) 0 ;
14242 int arg4 = (int) 0 ;
14243 int arg5 = (int) 0 ;
14244 int arg6 = (int) wxODDEVEN_RULE ;
14245 PyObject * obj0 = 0 ;
14246 PyObject * obj1 = 0 ;
14247 PyObject * obj2 = 0 ;
14248 PyObject * obj3 = 0 ;
14249 PyObject * obj4 = 0 ;
14250 char *kwnames[] = {
14251 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset",(char *) "fillStyle", NULL
14252 };
14253
14254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DC_DrawPolygon",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14256 if (SWIG_arg_fail(1)) SWIG_fail;
14257 {
14258 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14259 if (arg3 == NULL) SWIG_fail;
14260 }
14261 if (obj2) {
14262 {
14263 arg4 = (int)(SWIG_As_int(obj2));
14264 if (SWIG_arg_fail(4)) SWIG_fail;
14265 }
14266 }
14267 if (obj3) {
14268 {
14269 arg5 = (int)(SWIG_As_int(obj3));
14270 if (SWIG_arg_fail(5)) SWIG_fail;
14271 }
14272 }
14273 if (obj4) {
14274 {
14275 arg6 = (int)(SWIG_As_int(obj4));
14276 if (SWIG_arg_fail(6)) SWIG_fail;
14277 }
14278 }
14279 {
14280 PyThreadState* __tstate = wxPyBeginAllowThreads();
14281 (arg1)->DrawPolygon(arg2,arg3,arg4,arg5,arg6);
14282
14283 wxPyEndAllowThreads(__tstate);
14284 if (PyErr_Occurred()) SWIG_fail;
14285 }
14286 Py_INCREF(Py_None); resultobj = Py_None;
14287 {
14288 if (arg3) delete [] arg3;
14289 }
14290 return resultobj;
14291 fail:
14292 {
14293 if (arg3) delete [] arg3;
14294 }
14295 return NULL;
14296 }
14297
14298
14299 static PyObject *_wrap_DC_DrawLabel(PyObject *, PyObject *args, PyObject *kwargs) {
14300 PyObject *resultobj;
14301 wxDC *arg1 = (wxDC *) 0 ;
14302 wxString *arg2 = 0 ;
14303 wxRect *arg3 = 0 ;
14304 int arg4 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
14305 int arg5 = (int) -1 ;
14306 bool temp2 = false ;
14307 wxRect temp3 ;
14308 PyObject * obj0 = 0 ;
14309 PyObject * obj1 = 0 ;
14310 PyObject * obj2 = 0 ;
14311 PyObject * obj3 = 0 ;
14312 PyObject * obj4 = 0 ;
14313 char *kwnames[] = {
14314 (char *) "self",(char *) "text",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
14315 };
14316
14317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:DC_DrawLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14319 if (SWIG_arg_fail(1)) SWIG_fail;
14320 {
14321 arg2 = wxString_in_helper(obj1);
14322 if (arg2 == NULL) SWIG_fail;
14323 temp2 = true;
14324 }
14325 {
14326 arg3 = &temp3;
14327 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
14328 }
14329 if (obj3) {
14330 {
14331 arg4 = (int)(SWIG_As_int(obj3));
14332 if (SWIG_arg_fail(4)) SWIG_fail;
14333 }
14334 }
14335 if (obj4) {
14336 {
14337 arg5 = (int)(SWIG_As_int(obj4));
14338 if (SWIG_arg_fail(5)) SWIG_fail;
14339 }
14340 }
14341 {
14342 PyThreadState* __tstate = wxPyBeginAllowThreads();
14343 (arg1)->DrawLabel((wxString const &)*arg2,(wxRect const &)*arg3,arg4,arg5);
14344
14345 wxPyEndAllowThreads(__tstate);
14346 if (PyErr_Occurred()) SWIG_fail;
14347 }
14348 Py_INCREF(Py_None); resultobj = Py_None;
14349 {
14350 if (temp2)
14351 delete arg2;
14352 }
14353 return resultobj;
14354 fail:
14355 {
14356 if (temp2)
14357 delete arg2;
14358 }
14359 return NULL;
14360 }
14361
14362
14363 static PyObject *_wrap_DC_DrawImageLabel(PyObject *, PyObject *args, PyObject *kwargs) {
14364 PyObject *resultobj;
14365 wxDC *arg1 = (wxDC *) 0 ;
14366 wxString *arg2 = 0 ;
14367 wxBitmap *arg3 = 0 ;
14368 wxRect *arg4 = 0 ;
14369 int arg5 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
14370 int arg6 = (int) -1 ;
14371 wxRect result;
14372 bool temp2 = false ;
14373 wxRect temp4 ;
14374 PyObject * obj0 = 0 ;
14375 PyObject * obj1 = 0 ;
14376 PyObject * obj2 = 0 ;
14377 PyObject * obj3 = 0 ;
14378 PyObject * obj4 = 0 ;
14379 PyObject * obj5 = 0 ;
14380 char *kwnames[] = {
14381 (char *) "self",(char *) "text",(char *) "image",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
14382 };
14383
14384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:DC_DrawImageLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
14385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14386 if (SWIG_arg_fail(1)) SWIG_fail;
14387 {
14388 arg2 = wxString_in_helper(obj1);
14389 if (arg2 == NULL) SWIG_fail;
14390 temp2 = true;
14391 }
14392 {
14393 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
14394 if (SWIG_arg_fail(3)) SWIG_fail;
14395 if (arg3 == NULL) {
14396 SWIG_null_ref("wxBitmap");
14397 }
14398 if (SWIG_arg_fail(3)) SWIG_fail;
14399 }
14400 {
14401 arg4 = &temp4;
14402 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
14403 }
14404 if (obj4) {
14405 {
14406 arg5 = (int)(SWIG_As_int(obj4));
14407 if (SWIG_arg_fail(5)) SWIG_fail;
14408 }
14409 }
14410 if (obj5) {
14411 {
14412 arg6 = (int)(SWIG_As_int(obj5));
14413 if (SWIG_arg_fail(6)) SWIG_fail;
14414 }
14415 }
14416 {
14417 PyThreadState* __tstate = wxPyBeginAllowThreads();
14418 result = wxDC_DrawImageLabel(arg1,(wxString const &)*arg2,(wxBitmap const &)*arg3,(wxRect const &)*arg4,arg5,arg6);
14419
14420 wxPyEndAllowThreads(__tstate);
14421 if (PyErr_Occurred()) SWIG_fail;
14422 }
14423 {
14424 wxRect * resultptr;
14425 resultptr = new wxRect((wxRect &)(result));
14426 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
14427 }
14428 {
14429 if (temp2)
14430 delete arg2;
14431 }
14432 return resultobj;
14433 fail:
14434 {
14435 if (temp2)
14436 delete arg2;
14437 }
14438 return NULL;
14439 }
14440
14441
14442 static PyObject *_wrap_DC_DrawSpline(PyObject *, PyObject *args, PyObject *kwargs) {
14443 PyObject *resultobj;
14444 wxDC *arg1 = (wxDC *) 0 ;
14445 int arg2 ;
14446 wxPoint *arg3 = (wxPoint *) 0 ;
14447 PyObject * obj0 = 0 ;
14448 PyObject * obj1 = 0 ;
14449 char *kwnames[] = {
14450 (char *) "self",(char *) "points", NULL
14451 };
14452
14453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawSpline",kwnames,&obj0,&obj1)) goto fail;
14454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14455 if (SWIG_arg_fail(1)) SWIG_fail;
14456 {
14457 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14458 if (arg3 == NULL) SWIG_fail;
14459 }
14460 {
14461 PyThreadState* __tstate = wxPyBeginAllowThreads();
14462 (arg1)->DrawSpline(arg2,arg3);
14463
14464 wxPyEndAllowThreads(__tstate);
14465 if (PyErr_Occurred()) SWIG_fail;
14466 }
14467 Py_INCREF(Py_None); resultobj = Py_None;
14468 {
14469 if (arg3) delete [] arg3;
14470 }
14471 return resultobj;
14472 fail:
14473 {
14474 if (arg3) delete [] arg3;
14475 }
14476 return NULL;
14477 }
14478
14479
14480 static PyObject *_wrap_DC_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
14481 PyObject *resultobj;
14482 wxDC *arg1 = (wxDC *) 0 ;
14483 PyObject * obj0 = 0 ;
14484 char *kwnames[] = {
14485 (char *) "self", NULL
14486 };
14487
14488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Clear",kwnames,&obj0)) goto fail;
14489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14490 if (SWIG_arg_fail(1)) SWIG_fail;
14491 {
14492 PyThreadState* __tstate = wxPyBeginAllowThreads();
14493 (arg1)->Clear();
14494
14495 wxPyEndAllowThreads(__tstate);
14496 if (PyErr_Occurred()) SWIG_fail;
14497 }
14498 Py_INCREF(Py_None); resultobj = Py_None;
14499 return resultobj;
14500 fail:
14501 return NULL;
14502 }
14503
14504
14505 static PyObject *_wrap_DC_StartDoc(PyObject *, PyObject *args, PyObject *kwargs) {
14506 PyObject *resultobj;
14507 wxDC *arg1 = (wxDC *) 0 ;
14508 wxString *arg2 = 0 ;
14509 bool result;
14510 bool temp2 = false ;
14511 PyObject * obj0 = 0 ;
14512 PyObject * obj1 = 0 ;
14513 char *kwnames[] = {
14514 (char *) "self",(char *) "message", NULL
14515 };
14516
14517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_StartDoc",kwnames,&obj0,&obj1)) goto fail;
14518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14519 if (SWIG_arg_fail(1)) SWIG_fail;
14520 {
14521 arg2 = wxString_in_helper(obj1);
14522 if (arg2 == NULL) SWIG_fail;
14523 temp2 = true;
14524 }
14525 {
14526 PyThreadState* __tstate = wxPyBeginAllowThreads();
14527 result = (bool)(arg1)->StartDoc((wxString const &)*arg2);
14528
14529 wxPyEndAllowThreads(__tstate);
14530 if (PyErr_Occurred()) SWIG_fail;
14531 }
14532 {
14533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14534 }
14535 {
14536 if (temp2)
14537 delete arg2;
14538 }
14539 return resultobj;
14540 fail:
14541 {
14542 if (temp2)
14543 delete arg2;
14544 }
14545 return NULL;
14546 }
14547
14548
14549 static PyObject *_wrap_DC_EndDoc(PyObject *, PyObject *args, PyObject *kwargs) {
14550 PyObject *resultobj;
14551 wxDC *arg1 = (wxDC *) 0 ;
14552 PyObject * obj0 = 0 ;
14553 char *kwnames[] = {
14554 (char *) "self", NULL
14555 };
14556
14557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDoc",kwnames,&obj0)) goto fail;
14558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14559 if (SWIG_arg_fail(1)) SWIG_fail;
14560 {
14561 PyThreadState* __tstate = wxPyBeginAllowThreads();
14562 (arg1)->EndDoc();
14563
14564 wxPyEndAllowThreads(__tstate);
14565 if (PyErr_Occurred()) SWIG_fail;
14566 }
14567 Py_INCREF(Py_None); resultobj = Py_None;
14568 return resultobj;
14569 fail:
14570 return NULL;
14571 }
14572
14573
14574 static PyObject *_wrap_DC_StartPage(PyObject *, PyObject *args, PyObject *kwargs) {
14575 PyObject *resultobj;
14576 wxDC *arg1 = (wxDC *) 0 ;
14577 PyObject * obj0 = 0 ;
14578 char *kwnames[] = {
14579 (char *) "self", NULL
14580 };
14581
14582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_StartPage",kwnames,&obj0)) goto fail;
14583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14584 if (SWIG_arg_fail(1)) SWIG_fail;
14585 {
14586 PyThreadState* __tstate = wxPyBeginAllowThreads();
14587 (arg1)->StartPage();
14588
14589 wxPyEndAllowThreads(__tstate);
14590 if (PyErr_Occurred()) SWIG_fail;
14591 }
14592 Py_INCREF(Py_None); resultobj = Py_None;
14593 return resultobj;
14594 fail:
14595 return NULL;
14596 }
14597
14598
14599 static PyObject *_wrap_DC_EndPage(PyObject *, PyObject *args, PyObject *kwargs) {
14600 PyObject *resultobj;
14601 wxDC *arg1 = (wxDC *) 0 ;
14602 PyObject * obj0 = 0 ;
14603 char *kwnames[] = {
14604 (char *) "self", NULL
14605 };
14606
14607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndPage",kwnames,&obj0)) goto fail;
14608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14609 if (SWIG_arg_fail(1)) SWIG_fail;
14610 {
14611 PyThreadState* __tstate = wxPyBeginAllowThreads();
14612 (arg1)->EndPage();
14613
14614 wxPyEndAllowThreads(__tstate);
14615 if (PyErr_Occurred()) SWIG_fail;
14616 }
14617 Py_INCREF(Py_None); resultobj = Py_None;
14618 return resultobj;
14619 fail:
14620 return NULL;
14621 }
14622
14623
14624 static PyObject *_wrap_DC_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
14625 PyObject *resultobj;
14626 wxDC *arg1 = (wxDC *) 0 ;
14627 wxFont *arg2 = 0 ;
14628 PyObject * obj0 = 0 ;
14629 PyObject * obj1 = 0 ;
14630 char *kwnames[] = {
14631 (char *) "self",(char *) "font", NULL
14632 };
14633
14634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetFont",kwnames,&obj0,&obj1)) goto fail;
14635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14636 if (SWIG_arg_fail(1)) SWIG_fail;
14637 {
14638 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
14639 if (SWIG_arg_fail(2)) SWIG_fail;
14640 if (arg2 == NULL) {
14641 SWIG_null_ref("wxFont");
14642 }
14643 if (SWIG_arg_fail(2)) SWIG_fail;
14644 }
14645 {
14646 PyThreadState* __tstate = wxPyBeginAllowThreads();
14647 (arg1)->SetFont((wxFont const &)*arg2);
14648
14649 wxPyEndAllowThreads(__tstate);
14650 if (PyErr_Occurred()) SWIG_fail;
14651 }
14652 Py_INCREF(Py_None); resultobj = Py_None;
14653 return resultobj;
14654 fail:
14655 return NULL;
14656 }
14657
14658
14659 static PyObject *_wrap_DC_SetPen(PyObject *, PyObject *args, PyObject *kwargs) {
14660 PyObject *resultobj;
14661 wxDC *arg1 = (wxDC *) 0 ;
14662 wxPen *arg2 = 0 ;
14663 PyObject * obj0 = 0 ;
14664 PyObject * obj1 = 0 ;
14665 char *kwnames[] = {
14666 (char *) "self",(char *) "pen", NULL
14667 };
14668
14669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPen",kwnames,&obj0,&obj1)) goto fail;
14670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14671 if (SWIG_arg_fail(1)) SWIG_fail;
14672 {
14673 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
14674 if (SWIG_arg_fail(2)) SWIG_fail;
14675 if (arg2 == NULL) {
14676 SWIG_null_ref("wxPen");
14677 }
14678 if (SWIG_arg_fail(2)) SWIG_fail;
14679 }
14680 {
14681 PyThreadState* __tstate = wxPyBeginAllowThreads();
14682 (arg1)->SetPen((wxPen const &)*arg2);
14683
14684 wxPyEndAllowThreads(__tstate);
14685 if (PyErr_Occurred()) SWIG_fail;
14686 }
14687 Py_INCREF(Py_None); resultobj = Py_None;
14688 return resultobj;
14689 fail:
14690 return NULL;
14691 }
14692
14693
14694 static PyObject *_wrap_DC_SetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
14695 PyObject *resultobj;
14696 wxDC *arg1 = (wxDC *) 0 ;
14697 wxBrush *arg2 = 0 ;
14698 PyObject * obj0 = 0 ;
14699 PyObject * obj1 = 0 ;
14700 char *kwnames[] = {
14701 (char *) "self",(char *) "brush", NULL
14702 };
14703
14704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBrush",kwnames,&obj0,&obj1)) goto fail;
14705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14706 if (SWIG_arg_fail(1)) SWIG_fail;
14707 {
14708 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
14709 if (SWIG_arg_fail(2)) SWIG_fail;
14710 if (arg2 == NULL) {
14711 SWIG_null_ref("wxBrush");
14712 }
14713 if (SWIG_arg_fail(2)) SWIG_fail;
14714 }
14715 {
14716 PyThreadState* __tstate = wxPyBeginAllowThreads();
14717 (arg1)->SetBrush((wxBrush const &)*arg2);
14718
14719 wxPyEndAllowThreads(__tstate);
14720 if (PyErr_Occurred()) SWIG_fail;
14721 }
14722 Py_INCREF(Py_None); resultobj = Py_None;
14723 return resultobj;
14724 fail:
14725 return NULL;
14726 }
14727
14728
14729 static PyObject *_wrap_DC_SetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
14730 PyObject *resultobj;
14731 wxDC *arg1 = (wxDC *) 0 ;
14732 wxBrush *arg2 = 0 ;
14733 PyObject * obj0 = 0 ;
14734 PyObject * obj1 = 0 ;
14735 char *kwnames[] = {
14736 (char *) "self",(char *) "brush", NULL
14737 };
14738
14739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackground",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
14744 if (SWIG_arg_fail(2)) SWIG_fail;
14745 if (arg2 == NULL) {
14746 SWIG_null_ref("wxBrush");
14747 }
14748 if (SWIG_arg_fail(2)) SWIG_fail;
14749 }
14750 {
14751 PyThreadState* __tstate = wxPyBeginAllowThreads();
14752 (arg1)->SetBackground((wxBrush const &)*arg2);
14753
14754 wxPyEndAllowThreads(__tstate);
14755 if (PyErr_Occurred()) SWIG_fail;
14756 }
14757 Py_INCREF(Py_None); resultobj = Py_None;
14758 return resultobj;
14759 fail:
14760 return NULL;
14761 }
14762
14763
14764 static PyObject *_wrap_DC_SetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
14765 PyObject *resultobj;
14766 wxDC *arg1 = (wxDC *) 0 ;
14767 int arg2 ;
14768 PyObject * obj0 = 0 ;
14769 PyObject * obj1 = 0 ;
14770 char *kwnames[] = {
14771 (char *) "self",(char *) "mode", NULL
14772 };
14773
14774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackgroundMode",kwnames,&obj0,&obj1)) goto fail;
14775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14776 if (SWIG_arg_fail(1)) SWIG_fail;
14777 {
14778 arg2 = (int)(SWIG_As_int(obj1));
14779 if (SWIG_arg_fail(2)) SWIG_fail;
14780 }
14781 {
14782 PyThreadState* __tstate = wxPyBeginAllowThreads();
14783 (arg1)->SetBackgroundMode(arg2);
14784
14785 wxPyEndAllowThreads(__tstate);
14786 if (PyErr_Occurred()) SWIG_fail;
14787 }
14788 Py_INCREF(Py_None); resultobj = Py_None;
14789 return resultobj;
14790 fail:
14791 return NULL;
14792 }
14793
14794
14795 static PyObject *_wrap_DC_SetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
14796 PyObject *resultobj;
14797 wxDC *arg1 = (wxDC *) 0 ;
14798 wxPalette *arg2 = 0 ;
14799 PyObject * obj0 = 0 ;
14800 PyObject * obj1 = 0 ;
14801 char *kwnames[] = {
14802 (char *) "self",(char *) "palette", NULL
14803 };
14804
14805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPalette",kwnames,&obj0,&obj1)) goto fail;
14806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14807 if (SWIG_arg_fail(1)) SWIG_fail;
14808 {
14809 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
14810 if (SWIG_arg_fail(2)) SWIG_fail;
14811 if (arg2 == NULL) {
14812 SWIG_null_ref("wxPalette");
14813 }
14814 if (SWIG_arg_fail(2)) SWIG_fail;
14815 }
14816 {
14817 PyThreadState* __tstate = wxPyBeginAllowThreads();
14818 (arg1)->SetPalette((wxPalette const &)*arg2);
14819
14820 wxPyEndAllowThreads(__tstate);
14821 if (PyErr_Occurred()) SWIG_fail;
14822 }
14823 Py_INCREF(Py_None); resultobj = Py_None;
14824 return resultobj;
14825 fail:
14826 return NULL;
14827 }
14828
14829
14830 static PyObject *_wrap_DC_DestroyClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14831 PyObject *resultobj;
14832 wxDC *arg1 = (wxDC *) 0 ;
14833 PyObject * obj0 = 0 ;
14834 char *kwnames[] = {
14835 (char *) "self", NULL
14836 };
14837
14838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_DestroyClippingRegion",kwnames,&obj0)) goto fail;
14839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14840 if (SWIG_arg_fail(1)) SWIG_fail;
14841 {
14842 PyThreadState* __tstate = wxPyBeginAllowThreads();
14843 (arg1)->DestroyClippingRegion();
14844
14845 wxPyEndAllowThreads(__tstate);
14846 if (PyErr_Occurred()) SWIG_fail;
14847 }
14848 Py_INCREF(Py_None); resultobj = Py_None;
14849 return resultobj;
14850 fail:
14851 return NULL;
14852 }
14853
14854
14855 static PyObject *_wrap_DC_GetClippingBox(PyObject *, PyObject *args, PyObject *kwargs) {
14856 PyObject *resultobj;
14857 wxDC *arg1 = (wxDC *) 0 ;
14858 int *arg2 = (int *) 0 ;
14859 int *arg3 = (int *) 0 ;
14860 int *arg4 = (int *) 0 ;
14861 int *arg5 = (int *) 0 ;
14862 int temp2 ;
14863 int res2 = 0 ;
14864 int temp3 ;
14865 int res3 = 0 ;
14866 int temp4 ;
14867 int res4 = 0 ;
14868 int temp5 ;
14869 int res5 = 0 ;
14870 PyObject * obj0 = 0 ;
14871 char *kwnames[] = {
14872 (char *) "self", NULL
14873 };
14874
14875 arg2 = &temp2; res2 = SWIG_NEWOBJ;
14876 arg3 = &temp3; res3 = SWIG_NEWOBJ;
14877 arg4 = &temp4; res4 = SWIG_NEWOBJ;
14878 arg5 = &temp5; res5 = SWIG_NEWOBJ;
14879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingBox",kwnames,&obj0)) goto fail;
14880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14881 if (SWIG_arg_fail(1)) SWIG_fail;
14882 {
14883 PyThreadState* __tstate = wxPyBeginAllowThreads();
14884 ((wxDC const *)arg1)->GetClippingBox(arg2,arg3,arg4,arg5);
14885
14886 wxPyEndAllowThreads(__tstate);
14887 if (PyErr_Occurred()) SWIG_fail;
14888 }
14889 Py_INCREF(Py_None); resultobj = Py_None;
14890 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
14891 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
14892 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
14893 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
14894 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
14895 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
14896 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
14897 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
14898 return resultobj;
14899 fail:
14900 return NULL;
14901 }
14902
14903
14904 static PyObject *_wrap_DC_GetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
14905 PyObject *resultobj;
14906 wxDC *arg1 = (wxDC *) 0 ;
14907 wxRect result;
14908 PyObject * obj0 = 0 ;
14909 char *kwnames[] = {
14910 (char *) "self", NULL
14911 };
14912
14913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingRect",kwnames,&obj0)) goto fail;
14914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14915 if (SWIG_arg_fail(1)) SWIG_fail;
14916 {
14917 PyThreadState* __tstate = wxPyBeginAllowThreads();
14918 result = wxDC_GetClippingRect(arg1);
14919
14920 wxPyEndAllowThreads(__tstate);
14921 if (PyErr_Occurred()) SWIG_fail;
14922 }
14923 {
14924 wxRect * resultptr;
14925 resultptr = new wxRect((wxRect &)(result));
14926 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
14927 }
14928 return resultobj;
14929 fail:
14930 return NULL;
14931 }
14932
14933
14934 static PyObject *_wrap_DC_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
14935 PyObject *resultobj;
14936 wxDC *arg1 = (wxDC *) 0 ;
14937 int result;
14938 PyObject * obj0 = 0 ;
14939 char *kwnames[] = {
14940 (char *) "self", NULL
14941 };
14942
14943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharHeight",kwnames,&obj0)) goto fail;
14944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14945 if (SWIG_arg_fail(1)) SWIG_fail;
14946 {
14947 PyThreadState* __tstate = wxPyBeginAllowThreads();
14948 result = (int)((wxDC const *)arg1)->GetCharHeight();
14949
14950 wxPyEndAllowThreads(__tstate);
14951 if (PyErr_Occurred()) SWIG_fail;
14952 }
14953 {
14954 resultobj = SWIG_From_int((int)(result));
14955 }
14956 return resultobj;
14957 fail:
14958 return NULL;
14959 }
14960
14961
14962 static PyObject *_wrap_DC_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
14963 PyObject *resultobj;
14964 wxDC *arg1 = (wxDC *) 0 ;
14965 int result;
14966 PyObject * obj0 = 0 ;
14967 char *kwnames[] = {
14968 (char *) "self", NULL
14969 };
14970
14971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharWidth",kwnames,&obj0)) goto fail;
14972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14973 if (SWIG_arg_fail(1)) SWIG_fail;
14974 {
14975 PyThreadState* __tstate = wxPyBeginAllowThreads();
14976 result = (int)((wxDC const *)arg1)->GetCharWidth();
14977
14978 wxPyEndAllowThreads(__tstate);
14979 if (PyErr_Occurred()) SWIG_fail;
14980 }
14981 {
14982 resultobj = SWIG_From_int((int)(result));
14983 }
14984 return resultobj;
14985 fail:
14986 return NULL;
14987 }
14988
14989
14990 static PyObject *_wrap_DC_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
14991 PyObject *resultobj;
14992 wxDC *arg1 = (wxDC *) 0 ;
14993 wxString *arg2 = 0 ;
14994 int *arg3 = (int *) 0 ;
14995 int *arg4 = (int *) 0 ;
14996 bool temp2 = false ;
14997 int temp3 ;
14998 int res3 = 0 ;
14999 int temp4 ;
15000 int res4 = 0 ;
15001 PyObject * obj0 = 0 ;
15002 PyObject * obj1 = 0 ;
15003 char *kwnames[] = {
15004 (char *) "self",(char *) "string", NULL
15005 };
15006
15007 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15008 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
15010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15011 if (SWIG_arg_fail(1)) SWIG_fail;
15012 {
15013 arg2 = wxString_in_helper(obj1);
15014 if (arg2 == NULL) SWIG_fail;
15015 temp2 = true;
15016 }
15017 {
15018 PyThreadState* __tstate = wxPyBeginAllowThreads();
15019 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
15020
15021 wxPyEndAllowThreads(__tstate);
15022 if (PyErr_Occurred()) SWIG_fail;
15023 }
15024 Py_INCREF(Py_None); resultobj = Py_None;
15025 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15026 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15027 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15028 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15029 {
15030 if (temp2)
15031 delete arg2;
15032 }
15033 return resultobj;
15034 fail:
15035 {
15036 if (temp2)
15037 delete arg2;
15038 }
15039 return NULL;
15040 }
15041
15042
15043 static PyObject *_wrap_DC_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15044 PyObject *resultobj;
15045 wxDC *arg1 = (wxDC *) 0 ;
15046 wxString *arg2 = 0 ;
15047 int *arg3 = (int *) 0 ;
15048 int *arg4 = (int *) 0 ;
15049 int *arg5 = (int *) 0 ;
15050 int *arg6 = (int *) 0 ;
15051 wxFont *arg7 = (wxFont *) NULL ;
15052 bool temp2 = false ;
15053 int temp3 ;
15054 int res3 = 0 ;
15055 int temp4 ;
15056 int res4 = 0 ;
15057 int temp5 ;
15058 int res5 = 0 ;
15059 int temp6 ;
15060 int res6 = 0 ;
15061 PyObject * obj0 = 0 ;
15062 PyObject * obj1 = 0 ;
15063 PyObject * obj2 = 0 ;
15064 char *kwnames[] = {
15065 (char *) "self",(char *) "string",(char *) "font", NULL
15066 };
15067
15068 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15069 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15070 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15071 arg6 = &temp6; res6 = SWIG_NEWOBJ;
15072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15074 if (SWIG_arg_fail(1)) SWIG_fail;
15075 {
15076 arg2 = wxString_in_helper(obj1);
15077 if (arg2 == NULL) SWIG_fail;
15078 temp2 = true;
15079 }
15080 if (obj2) {
15081 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15082 if (SWIG_arg_fail(7)) SWIG_fail;
15083 }
15084 {
15085 PyThreadState* __tstate = wxPyBeginAllowThreads();
15086 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7);
15087
15088 wxPyEndAllowThreads(__tstate);
15089 if (PyErr_Occurred()) SWIG_fail;
15090 }
15091 Py_INCREF(Py_None); resultobj = Py_None;
15092 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15093 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15094 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15095 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15096 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15097 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15098 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
15099 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
15100 {
15101 if (temp2)
15102 delete arg2;
15103 }
15104 return resultobj;
15105 fail:
15106 {
15107 if (temp2)
15108 delete arg2;
15109 }
15110 return NULL;
15111 }
15112
15113
15114 static PyObject *_wrap_DC_GetMultiLineTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15115 PyObject *resultobj;
15116 wxDC *arg1 = (wxDC *) 0 ;
15117 wxString *arg2 = 0 ;
15118 int *arg3 = (int *) 0 ;
15119 int *arg4 = (int *) 0 ;
15120 int *arg5 = (int *) 0 ;
15121 wxFont *arg6 = (wxFont *) NULL ;
15122 bool temp2 = false ;
15123 int temp3 ;
15124 int res3 = 0 ;
15125 int temp4 ;
15126 int res4 = 0 ;
15127 int temp5 ;
15128 int res5 = 0 ;
15129 PyObject * obj0 = 0 ;
15130 PyObject * obj1 = 0 ;
15131 PyObject * obj2 = 0 ;
15132 char *kwnames[] = {
15133 (char *) "self",(char *) "text",(char *) "font", NULL
15134 };
15135
15136 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15137 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15138 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetMultiLineTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15141 if (SWIG_arg_fail(1)) SWIG_fail;
15142 {
15143 arg2 = wxString_in_helper(obj1);
15144 if (arg2 == NULL) SWIG_fail;
15145 temp2 = true;
15146 }
15147 if (obj2) {
15148 SWIG_Python_ConvertPtr(obj2, (void **)&arg6, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15149 if (SWIG_arg_fail(6)) SWIG_fail;
15150 }
15151 {
15152 PyThreadState* __tstate = wxPyBeginAllowThreads();
15153 (arg1)->GetMultiLineTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6);
15154
15155 wxPyEndAllowThreads(__tstate);
15156 if (PyErr_Occurred()) SWIG_fail;
15157 }
15158 Py_INCREF(Py_None); resultobj = Py_None;
15159 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15160 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15161 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15162 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15163 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15164 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15165 {
15166 if (temp2)
15167 delete arg2;
15168 }
15169 return resultobj;
15170 fail:
15171 {
15172 if (temp2)
15173 delete arg2;
15174 }
15175 return NULL;
15176 }
15177
15178
15179 static PyObject *_wrap_DC_GetPartialTextExtents(PyObject *, PyObject *args, PyObject *kwargs) {
15180 PyObject *resultobj;
15181 wxDC *arg1 = (wxDC *) 0 ;
15182 wxString *arg2 = 0 ;
15183 wxArrayInt result;
15184 bool temp2 = false ;
15185 PyObject * obj0 = 0 ;
15186 PyObject * obj1 = 0 ;
15187 char *kwnames[] = {
15188 (char *) "self",(char *) "text", NULL
15189 };
15190
15191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPartialTextExtents",kwnames,&obj0,&obj1)) goto fail;
15192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15193 if (SWIG_arg_fail(1)) SWIG_fail;
15194 {
15195 arg2 = wxString_in_helper(obj1);
15196 if (arg2 == NULL) SWIG_fail;
15197 temp2 = true;
15198 }
15199 {
15200 PyThreadState* __tstate = wxPyBeginAllowThreads();
15201 result = wxDC_GetPartialTextExtents(arg1,(wxString const &)*arg2);
15202
15203 wxPyEndAllowThreads(__tstate);
15204 if (PyErr_Occurred()) SWIG_fail;
15205 }
15206 {
15207 resultobj = PyList_New(0);
15208 size_t idx;
15209 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
15210 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
15211 PyList_Append(resultobj, val);
15212 Py_DECREF(val);
15213 }
15214 }
15215 {
15216 if (temp2)
15217 delete arg2;
15218 }
15219 return resultobj;
15220 fail:
15221 {
15222 if (temp2)
15223 delete arg2;
15224 }
15225 return NULL;
15226 }
15227
15228
15229 static PyObject *_wrap_DC_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
15230 PyObject *resultobj;
15231 wxDC *arg1 = (wxDC *) 0 ;
15232 wxSize result;
15233 PyObject * obj0 = 0 ;
15234 char *kwnames[] = {
15235 (char *) "self", NULL
15236 };
15237
15238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSize",kwnames,&obj0)) goto fail;
15239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15240 if (SWIG_arg_fail(1)) SWIG_fail;
15241 {
15242 PyThreadState* __tstate = wxPyBeginAllowThreads();
15243 result = (arg1)->GetSize();
15244
15245 wxPyEndAllowThreads(__tstate);
15246 if (PyErr_Occurred()) SWIG_fail;
15247 }
15248 {
15249 wxSize * resultptr;
15250 resultptr = new wxSize((wxSize &)(result));
15251 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15252 }
15253 return resultobj;
15254 fail:
15255 return NULL;
15256 }
15257
15258
15259 static PyObject *_wrap_DC_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
15260 PyObject *resultobj;
15261 wxDC *arg1 = (wxDC *) 0 ;
15262 int *arg2 = (int *) 0 ;
15263 int *arg3 = (int *) 0 ;
15264 int temp2 ;
15265 int res2 = 0 ;
15266 int temp3 ;
15267 int res3 = 0 ;
15268 PyObject * obj0 = 0 ;
15269 char *kwnames[] = {
15270 (char *) "self", NULL
15271 };
15272
15273 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15274 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeTuple",kwnames,&obj0)) goto fail;
15276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15277 if (SWIG_arg_fail(1)) SWIG_fail;
15278 {
15279 PyThreadState* __tstate = wxPyBeginAllowThreads();
15280 (arg1)->GetSize(arg2,arg3);
15281
15282 wxPyEndAllowThreads(__tstate);
15283 if (PyErr_Occurred()) SWIG_fail;
15284 }
15285 Py_INCREF(Py_None); resultobj = Py_None;
15286 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15287 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15288 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15289 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15290 return resultobj;
15291 fail:
15292 return NULL;
15293 }
15294
15295
15296 static PyObject *_wrap_DC_GetSizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
15297 PyObject *resultobj;
15298 wxDC *arg1 = (wxDC *) 0 ;
15299 wxSize result;
15300 PyObject * obj0 = 0 ;
15301 char *kwnames[] = {
15302 (char *) "self", NULL
15303 };
15304
15305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMM",kwnames,&obj0)) goto fail;
15306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15307 if (SWIG_arg_fail(1)) SWIG_fail;
15308 {
15309 PyThreadState* __tstate = wxPyBeginAllowThreads();
15310 result = ((wxDC const *)arg1)->GetSizeMM();
15311
15312 wxPyEndAllowThreads(__tstate);
15313 if (PyErr_Occurred()) SWIG_fail;
15314 }
15315 {
15316 wxSize * resultptr;
15317 resultptr = new wxSize((wxSize &)(result));
15318 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15319 }
15320 return resultobj;
15321 fail:
15322 return NULL;
15323 }
15324
15325
15326 static PyObject *_wrap_DC_GetSizeMMTuple(PyObject *, PyObject *args, PyObject *kwargs) {
15327 PyObject *resultobj;
15328 wxDC *arg1 = (wxDC *) 0 ;
15329 int *arg2 = (int *) 0 ;
15330 int *arg3 = (int *) 0 ;
15331 int temp2 ;
15332 int res2 = 0 ;
15333 int temp3 ;
15334 int res3 = 0 ;
15335 PyObject * obj0 = 0 ;
15336 char *kwnames[] = {
15337 (char *) "self", NULL
15338 };
15339
15340 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15341 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMMTuple",kwnames,&obj0)) goto fail;
15343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15344 if (SWIG_arg_fail(1)) SWIG_fail;
15345 {
15346 PyThreadState* __tstate = wxPyBeginAllowThreads();
15347 ((wxDC const *)arg1)->GetSizeMM(arg2,arg3);
15348
15349 wxPyEndAllowThreads(__tstate);
15350 if (PyErr_Occurred()) SWIG_fail;
15351 }
15352 Py_INCREF(Py_None); resultobj = Py_None;
15353 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15354 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15355 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15356 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15357 return resultobj;
15358 fail:
15359 return NULL;
15360 }
15361
15362
15363 static PyObject *_wrap_DC_DeviceToLogicalX(PyObject *, PyObject *args, PyObject *kwargs) {
15364 PyObject *resultobj;
15365 wxDC *arg1 = (wxDC *) 0 ;
15366 int arg2 ;
15367 int result;
15368 PyObject * obj0 = 0 ;
15369 PyObject * obj1 = 0 ;
15370 char *kwnames[] = {
15371 (char *) "self",(char *) "x", NULL
15372 };
15373
15374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalX",kwnames,&obj0,&obj1)) goto fail;
15375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15376 if (SWIG_arg_fail(1)) SWIG_fail;
15377 {
15378 arg2 = (int)(SWIG_As_int(obj1));
15379 if (SWIG_arg_fail(2)) SWIG_fail;
15380 }
15381 {
15382 PyThreadState* __tstate = wxPyBeginAllowThreads();
15383 result = (int)((wxDC const *)arg1)->DeviceToLogicalX(arg2);
15384
15385 wxPyEndAllowThreads(__tstate);
15386 if (PyErr_Occurred()) SWIG_fail;
15387 }
15388 {
15389 resultobj = SWIG_From_int((int)(result));
15390 }
15391 return resultobj;
15392 fail:
15393 return NULL;
15394 }
15395
15396
15397 static PyObject *_wrap_DC_DeviceToLogicalY(PyObject *, PyObject *args, PyObject *kwargs) {
15398 PyObject *resultobj;
15399 wxDC *arg1 = (wxDC *) 0 ;
15400 int arg2 ;
15401 int result;
15402 PyObject * obj0 = 0 ;
15403 PyObject * obj1 = 0 ;
15404 char *kwnames[] = {
15405 (char *) "self",(char *) "y", NULL
15406 };
15407
15408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalY",kwnames,&obj0,&obj1)) goto fail;
15409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15410 if (SWIG_arg_fail(1)) SWIG_fail;
15411 {
15412 arg2 = (int)(SWIG_As_int(obj1));
15413 if (SWIG_arg_fail(2)) SWIG_fail;
15414 }
15415 {
15416 PyThreadState* __tstate = wxPyBeginAllowThreads();
15417 result = (int)((wxDC const *)arg1)->DeviceToLogicalY(arg2);
15418
15419 wxPyEndAllowThreads(__tstate);
15420 if (PyErr_Occurred()) SWIG_fail;
15421 }
15422 {
15423 resultobj = SWIG_From_int((int)(result));
15424 }
15425 return resultobj;
15426 fail:
15427 return NULL;
15428 }
15429
15430
15431 static PyObject *_wrap_DC_DeviceToLogicalXRel(PyObject *, PyObject *args, PyObject *kwargs) {
15432 PyObject *resultobj;
15433 wxDC *arg1 = (wxDC *) 0 ;
15434 int arg2 ;
15435 int result;
15436 PyObject * obj0 = 0 ;
15437 PyObject * obj1 = 0 ;
15438 char *kwnames[] = {
15439 (char *) "self",(char *) "x", NULL
15440 };
15441
15442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalXRel",kwnames,&obj0,&obj1)) goto fail;
15443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15444 if (SWIG_arg_fail(1)) SWIG_fail;
15445 {
15446 arg2 = (int)(SWIG_As_int(obj1));
15447 if (SWIG_arg_fail(2)) SWIG_fail;
15448 }
15449 {
15450 PyThreadState* __tstate = wxPyBeginAllowThreads();
15451 result = (int)((wxDC const *)arg1)->DeviceToLogicalXRel(arg2);
15452
15453 wxPyEndAllowThreads(__tstate);
15454 if (PyErr_Occurred()) SWIG_fail;
15455 }
15456 {
15457 resultobj = SWIG_From_int((int)(result));
15458 }
15459 return resultobj;
15460 fail:
15461 return NULL;
15462 }
15463
15464
15465 static PyObject *_wrap_DC_DeviceToLogicalYRel(PyObject *, PyObject *args, PyObject *kwargs) {
15466 PyObject *resultobj;
15467 wxDC *arg1 = (wxDC *) 0 ;
15468 int arg2 ;
15469 int result;
15470 PyObject * obj0 = 0 ;
15471 PyObject * obj1 = 0 ;
15472 char *kwnames[] = {
15473 (char *) "self",(char *) "y", NULL
15474 };
15475
15476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalYRel",kwnames,&obj0,&obj1)) goto fail;
15477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15478 if (SWIG_arg_fail(1)) SWIG_fail;
15479 {
15480 arg2 = (int)(SWIG_As_int(obj1));
15481 if (SWIG_arg_fail(2)) SWIG_fail;
15482 }
15483 {
15484 PyThreadState* __tstate = wxPyBeginAllowThreads();
15485 result = (int)((wxDC const *)arg1)->DeviceToLogicalYRel(arg2);
15486
15487 wxPyEndAllowThreads(__tstate);
15488 if (PyErr_Occurred()) SWIG_fail;
15489 }
15490 {
15491 resultobj = SWIG_From_int((int)(result));
15492 }
15493 return resultobj;
15494 fail:
15495 return NULL;
15496 }
15497
15498
15499 static PyObject *_wrap_DC_LogicalToDeviceX(PyObject *, PyObject *args, PyObject *kwargs) {
15500 PyObject *resultobj;
15501 wxDC *arg1 = (wxDC *) 0 ;
15502 int arg2 ;
15503 int result;
15504 PyObject * obj0 = 0 ;
15505 PyObject * obj1 = 0 ;
15506 char *kwnames[] = {
15507 (char *) "self",(char *) "x", NULL
15508 };
15509
15510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceX",kwnames,&obj0,&obj1)) goto fail;
15511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15512 if (SWIG_arg_fail(1)) SWIG_fail;
15513 {
15514 arg2 = (int)(SWIG_As_int(obj1));
15515 if (SWIG_arg_fail(2)) SWIG_fail;
15516 }
15517 {
15518 PyThreadState* __tstate = wxPyBeginAllowThreads();
15519 result = (int)((wxDC const *)arg1)->LogicalToDeviceX(arg2);
15520
15521 wxPyEndAllowThreads(__tstate);
15522 if (PyErr_Occurred()) SWIG_fail;
15523 }
15524 {
15525 resultobj = SWIG_From_int((int)(result));
15526 }
15527 return resultobj;
15528 fail:
15529 return NULL;
15530 }
15531
15532
15533 static PyObject *_wrap_DC_LogicalToDeviceY(PyObject *, PyObject *args, PyObject *kwargs) {
15534 PyObject *resultobj;
15535 wxDC *arg1 = (wxDC *) 0 ;
15536 int arg2 ;
15537 int result;
15538 PyObject * obj0 = 0 ;
15539 PyObject * obj1 = 0 ;
15540 char *kwnames[] = {
15541 (char *) "self",(char *) "y", NULL
15542 };
15543
15544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceY",kwnames,&obj0,&obj1)) goto fail;
15545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15546 if (SWIG_arg_fail(1)) SWIG_fail;
15547 {
15548 arg2 = (int)(SWIG_As_int(obj1));
15549 if (SWIG_arg_fail(2)) SWIG_fail;
15550 }
15551 {
15552 PyThreadState* __tstate = wxPyBeginAllowThreads();
15553 result = (int)((wxDC const *)arg1)->LogicalToDeviceY(arg2);
15554
15555 wxPyEndAllowThreads(__tstate);
15556 if (PyErr_Occurred()) SWIG_fail;
15557 }
15558 {
15559 resultobj = SWIG_From_int((int)(result));
15560 }
15561 return resultobj;
15562 fail:
15563 return NULL;
15564 }
15565
15566
15567 static PyObject *_wrap_DC_LogicalToDeviceXRel(PyObject *, PyObject *args, PyObject *kwargs) {
15568 PyObject *resultobj;
15569 wxDC *arg1 = (wxDC *) 0 ;
15570 int arg2 ;
15571 int result;
15572 PyObject * obj0 = 0 ;
15573 PyObject * obj1 = 0 ;
15574 char *kwnames[] = {
15575 (char *) "self",(char *) "x", NULL
15576 };
15577
15578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceXRel",kwnames,&obj0,&obj1)) goto fail;
15579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15580 if (SWIG_arg_fail(1)) SWIG_fail;
15581 {
15582 arg2 = (int)(SWIG_As_int(obj1));
15583 if (SWIG_arg_fail(2)) SWIG_fail;
15584 }
15585 {
15586 PyThreadState* __tstate = wxPyBeginAllowThreads();
15587 result = (int)((wxDC const *)arg1)->LogicalToDeviceXRel(arg2);
15588
15589 wxPyEndAllowThreads(__tstate);
15590 if (PyErr_Occurred()) SWIG_fail;
15591 }
15592 {
15593 resultobj = SWIG_From_int((int)(result));
15594 }
15595 return resultobj;
15596 fail:
15597 return NULL;
15598 }
15599
15600
15601 static PyObject *_wrap_DC_LogicalToDeviceYRel(PyObject *, PyObject *args, PyObject *kwargs) {
15602 PyObject *resultobj;
15603 wxDC *arg1 = (wxDC *) 0 ;
15604 int arg2 ;
15605 int result;
15606 PyObject * obj0 = 0 ;
15607 PyObject * obj1 = 0 ;
15608 char *kwnames[] = {
15609 (char *) "self",(char *) "y", NULL
15610 };
15611
15612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceYRel",kwnames,&obj0,&obj1)) goto fail;
15613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15614 if (SWIG_arg_fail(1)) SWIG_fail;
15615 {
15616 arg2 = (int)(SWIG_As_int(obj1));
15617 if (SWIG_arg_fail(2)) SWIG_fail;
15618 }
15619 {
15620 PyThreadState* __tstate = wxPyBeginAllowThreads();
15621 result = (int)((wxDC const *)arg1)->LogicalToDeviceYRel(arg2);
15622
15623 wxPyEndAllowThreads(__tstate);
15624 if (PyErr_Occurred()) SWIG_fail;
15625 }
15626 {
15627 resultobj = SWIG_From_int((int)(result));
15628 }
15629 return resultobj;
15630 fail:
15631 return NULL;
15632 }
15633
15634
15635 static PyObject *_wrap_DC_CanDrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
15636 PyObject *resultobj;
15637 wxDC *arg1 = (wxDC *) 0 ;
15638 bool result;
15639 PyObject * obj0 = 0 ;
15640 char *kwnames[] = {
15641 (char *) "self", NULL
15642 };
15643
15644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanDrawBitmap",kwnames,&obj0)) goto fail;
15645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15646 if (SWIG_arg_fail(1)) SWIG_fail;
15647 {
15648 PyThreadState* __tstate = wxPyBeginAllowThreads();
15649 result = (bool)((wxDC const *)arg1)->CanDrawBitmap();
15650
15651 wxPyEndAllowThreads(__tstate);
15652 if (PyErr_Occurred()) SWIG_fail;
15653 }
15654 {
15655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15656 }
15657 return resultobj;
15658 fail:
15659 return NULL;
15660 }
15661
15662
15663 static PyObject *_wrap_DC_CanGetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15664 PyObject *resultobj;
15665 wxDC *arg1 = (wxDC *) 0 ;
15666 bool result;
15667 PyObject * obj0 = 0 ;
15668 char *kwnames[] = {
15669 (char *) "self", NULL
15670 };
15671
15672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanGetTextExtent",kwnames,&obj0)) goto fail;
15673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15674 if (SWIG_arg_fail(1)) SWIG_fail;
15675 {
15676 PyThreadState* __tstate = wxPyBeginAllowThreads();
15677 result = (bool)((wxDC const *)arg1)->CanGetTextExtent();
15678
15679 wxPyEndAllowThreads(__tstate);
15680 if (PyErr_Occurred()) SWIG_fail;
15681 }
15682 {
15683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15684 }
15685 return resultobj;
15686 fail:
15687 return NULL;
15688 }
15689
15690
15691 static PyObject *_wrap_DC_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
15692 PyObject *resultobj;
15693 wxDC *arg1 = (wxDC *) 0 ;
15694 int result;
15695 PyObject * obj0 = 0 ;
15696 char *kwnames[] = {
15697 (char *) "self", NULL
15698 };
15699
15700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDepth",kwnames,&obj0)) goto fail;
15701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15702 if (SWIG_arg_fail(1)) SWIG_fail;
15703 {
15704 PyThreadState* __tstate = wxPyBeginAllowThreads();
15705 result = (int)((wxDC const *)arg1)->GetDepth();
15706
15707 wxPyEndAllowThreads(__tstate);
15708 if (PyErr_Occurred()) SWIG_fail;
15709 }
15710 {
15711 resultobj = SWIG_From_int((int)(result));
15712 }
15713 return resultobj;
15714 fail:
15715 return NULL;
15716 }
15717
15718
15719 static PyObject *_wrap_DC_GetPPI(PyObject *, PyObject *args, PyObject *kwargs) {
15720 PyObject *resultobj;
15721 wxDC *arg1 = (wxDC *) 0 ;
15722 wxSize result;
15723 PyObject * obj0 = 0 ;
15724 char *kwnames[] = {
15725 (char *) "self", NULL
15726 };
15727
15728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPPI",kwnames,&obj0)) goto fail;
15729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15730 if (SWIG_arg_fail(1)) SWIG_fail;
15731 {
15732 PyThreadState* __tstate = wxPyBeginAllowThreads();
15733 result = ((wxDC const *)arg1)->GetPPI();
15734
15735 wxPyEndAllowThreads(__tstate);
15736 if (PyErr_Occurred()) SWIG_fail;
15737 }
15738 {
15739 wxSize * resultptr;
15740 resultptr = new wxSize((wxSize &)(result));
15741 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15742 }
15743 return resultobj;
15744 fail:
15745 return NULL;
15746 }
15747
15748
15749 static PyObject *_wrap_DC_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
15750 PyObject *resultobj;
15751 wxDC *arg1 = (wxDC *) 0 ;
15752 bool result;
15753 PyObject * obj0 = 0 ;
15754 char *kwnames[] = {
15755 (char *) "self", NULL
15756 };
15757
15758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Ok",kwnames,&obj0)) goto fail;
15759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15760 if (SWIG_arg_fail(1)) SWIG_fail;
15761 {
15762 PyThreadState* __tstate = wxPyBeginAllowThreads();
15763 result = (bool)((wxDC const *)arg1)->Ok();
15764
15765 wxPyEndAllowThreads(__tstate);
15766 if (PyErr_Occurred()) SWIG_fail;
15767 }
15768 {
15769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15770 }
15771 return resultobj;
15772 fail:
15773 return NULL;
15774 }
15775
15776
15777 static PyObject *_wrap_DC_GetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
15778 PyObject *resultobj;
15779 wxDC *arg1 = (wxDC *) 0 ;
15780 int result;
15781 PyObject * obj0 = 0 ;
15782 char *kwnames[] = {
15783 (char *) "self", NULL
15784 };
15785
15786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackgroundMode",kwnames,&obj0)) goto fail;
15787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15788 if (SWIG_arg_fail(1)) SWIG_fail;
15789 {
15790 PyThreadState* __tstate = wxPyBeginAllowThreads();
15791 result = (int)((wxDC const *)arg1)->GetBackgroundMode();
15792
15793 wxPyEndAllowThreads(__tstate);
15794 if (PyErr_Occurred()) SWIG_fail;
15795 }
15796 {
15797 resultobj = SWIG_From_int((int)(result));
15798 }
15799 return resultobj;
15800 fail:
15801 return NULL;
15802 }
15803
15804
15805 static PyObject *_wrap_DC_GetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
15806 PyObject *resultobj;
15807 wxDC *arg1 = (wxDC *) 0 ;
15808 wxBrush *result;
15809 PyObject * obj0 = 0 ;
15810 char *kwnames[] = {
15811 (char *) "self", NULL
15812 };
15813
15814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackground",kwnames,&obj0)) goto fail;
15815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15816 if (SWIG_arg_fail(1)) SWIG_fail;
15817 {
15818 PyThreadState* __tstate = wxPyBeginAllowThreads();
15819 {
15820 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBackground();
15821 result = (wxBrush *) &_result_ref;
15822 }
15823
15824 wxPyEndAllowThreads(__tstate);
15825 if (PyErr_Occurred()) SWIG_fail;
15826 }
15827 {
15828 wxBrush* resultptr = new wxBrush(*result);
15829 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
15830 }
15831 return resultobj;
15832 fail:
15833 return NULL;
15834 }
15835
15836
15837 static PyObject *_wrap_DC_GetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
15838 PyObject *resultobj;
15839 wxDC *arg1 = (wxDC *) 0 ;
15840 wxBrush *result;
15841 PyObject * obj0 = 0 ;
15842 char *kwnames[] = {
15843 (char *) "self", NULL
15844 };
15845
15846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBrush",kwnames,&obj0)) goto fail;
15847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15848 if (SWIG_arg_fail(1)) SWIG_fail;
15849 {
15850 PyThreadState* __tstate = wxPyBeginAllowThreads();
15851 {
15852 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBrush();
15853 result = (wxBrush *) &_result_ref;
15854 }
15855
15856 wxPyEndAllowThreads(__tstate);
15857 if (PyErr_Occurred()) SWIG_fail;
15858 }
15859 {
15860 wxBrush* resultptr = new wxBrush(*result);
15861 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
15862 }
15863 return resultobj;
15864 fail:
15865 return NULL;
15866 }
15867
15868
15869 static PyObject *_wrap_DC_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
15870 PyObject *resultobj;
15871 wxDC *arg1 = (wxDC *) 0 ;
15872 wxFont *result;
15873 PyObject * obj0 = 0 ;
15874 char *kwnames[] = {
15875 (char *) "self", NULL
15876 };
15877
15878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetFont",kwnames,&obj0)) goto fail;
15879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15880 if (SWIG_arg_fail(1)) SWIG_fail;
15881 {
15882 PyThreadState* __tstate = wxPyBeginAllowThreads();
15883 {
15884 wxFont const &_result_ref = ((wxDC const *)arg1)->GetFont();
15885 result = (wxFont *) &_result_ref;
15886 }
15887
15888 wxPyEndAllowThreads(__tstate);
15889 if (PyErr_Occurred()) SWIG_fail;
15890 }
15891 {
15892 wxFont* resultptr = new wxFont(*result);
15893 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxFont, 1);
15894 }
15895 return resultobj;
15896 fail:
15897 return NULL;
15898 }
15899
15900
15901 static PyObject *_wrap_DC_GetPen(PyObject *, PyObject *args, PyObject *kwargs) {
15902 PyObject *resultobj;
15903 wxDC *arg1 = (wxDC *) 0 ;
15904 wxPen *result;
15905 PyObject * obj0 = 0 ;
15906 char *kwnames[] = {
15907 (char *) "self", NULL
15908 };
15909
15910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPen",kwnames,&obj0)) goto fail;
15911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15912 if (SWIG_arg_fail(1)) SWIG_fail;
15913 {
15914 PyThreadState* __tstate = wxPyBeginAllowThreads();
15915 {
15916 wxPen const &_result_ref = ((wxDC const *)arg1)->GetPen();
15917 result = (wxPen *) &_result_ref;
15918 }
15919
15920 wxPyEndAllowThreads(__tstate);
15921 if (PyErr_Occurred()) SWIG_fail;
15922 }
15923 {
15924 wxPen* resultptr = new wxPen(*result);
15925 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxPen, 1);
15926 }
15927 return resultobj;
15928 fail:
15929 return NULL;
15930 }
15931
15932
15933 static PyObject *_wrap_DC_GetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
15934 PyObject *resultobj;
15935 wxDC *arg1 = (wxDC *) 0 ;
15936 wxColour *result;
15937 PyObject * obj0 = 0 ;
15938 char *kwnames[] = {
15939 (char *) "self", NULL
15940 };
15941
15942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextBackground",kwnames,&obj0)) goto fail;
15943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15944 if (SWIG_arg_fail(1)) SWIG_fail;
15945 {
15946 PyThreadState* __tstate = wxPyBeginAllowThreads();
15947 {
15948 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextBackground();
15949 result = (wxColour *) &_result_ref;
15950 }
15951
15952 wxPyEndAllowThreads(__tstate);
15953 if (PyErr_Occurred()) SWIG_fail;
15954 }
15955 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
15956 return resultobj;
15957 fail:
15958 return NULL;
15959 }
15960
15961
15962 static PyObject *_wrap_DC_GetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
15963 PyObject *resultobj;
15964 wxDC *arg1 = (wxDC *) 0 ;
15965 wxColour *result;
15966 PyObject * obj0 = 0 ;
15967 char *kwnames[] = {
15968 (char *) "self", NULL
15969 };
15970
15971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextForeground",kwnames,&obj0)) goto fail;
15972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15973 if (SWIG_arg_fail(1)) SWIG_fail;
15974 {
15975 PyThreadState* __tstate = wxPyBeginAllowThreads();
15976 {
15977 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextForeground();
15978 result = (wxColour *) &_result_ref;
15979 }
15980
15981 wxPyEndAllowThreads(__tstate);
15982 if (PyErr_Occurred()) SWIG_fail;
15983 }
15984 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
15985 return resultobj;
15986 fail:
15987 return NULL;
15988 }
15989
15990
15991 static PyObject *_wrap_DC_SetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
15992 PyObject *resultobj;
15993 wxDC *arg1 = (wxDC *) 0 ;
15994 wxColour *arg2 = 0 ;
15995 wxColour temp2 ;
15996 PyObject * obj0 = 0 ;
15997 PyObject * obj1 = 0 ;
15998 char *kwnames[] = {
15999 (char *) "self",(char *) "colour", NULL
16000 };
16001
16002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextForeground",kwnames,&obj0,&obj1)) goto fail;
16003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16004 if (SWIG_arg_fail(1)) SWIG_fail;
16005 {
16006 arg2 = &temp2;
16007 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16008 }
16009 {
16010 PyThreadState* __tstate = wxPyBeginAllowThreads();
16011 (arg1)->SetTextForeground((wxColour const &)*arg2);
16012
16013 wxPyEndAllowThreads(__tstate);
16014 if (PyErr_Occurred()) SWIG_fail;
16015 }
16016 Py_INCREF(Py_None); resultobj = Py_None;
16017 return resultobj;
16018 fail:
16019 return NULL;
16020 }
16021
16022
16023 static PyObject *_wrap_DC_SetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16024 PyObject *resultobj;
16025 wxDC *arg1 = (wxDC *) 0 ;
16026 wxColour *arg2 = 0 ;
16027 wxColour temp2 ;
16028 PyObject * obj0 = 0 ;
16029 PyObject * obj1 = 0 ;
16030 char *kwnames[] = {
16031 (char *) "self",(char *) "colour", NULL
16032 };
16033
16034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextBackground",kwnames,&obj0,&obj1)) goto fail;
16035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16036 if (SWIG_arg_fail(1)) SWIG_fail;
16037 {
16038 arg2 = &temp2;
16039 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16040 }
16041 {
16042 PyThreadState* __tstate = wxPyBeginAllowThreads();
16043 (arg1)->SetTextBackground((wxColour const &)*arg2);
16044
16045 wxPyEndAllowThreads(__tstate);
16046 if (PyErr_Occurred()) SWIG_fail;
16047 }
16048 Py_INCREF(Py_None); resultobj = Py_None;
16049 return resultobj;
16050 fail:
16051 return NULL;
16052 }
16053
16054
16055 static PyObject *_wrap_DC_GetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16056 PyObject *resultobj;
16057 wxDC *arg1 = (wxDC *) 0 ;
16058 int result;
16059 PyObject * obj0 = 0 ;
16060 char *kwnames[] = {
16061 (char *) "self", NULL
16062 };
16063
16064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetMapMode",kwnames,&obj0)) goto fail;
16065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16066 if (SWIG_arg_fail(1)) SWIG_fail;
16067 {
16068 PyThreadState* __tstate = wxPyBeginAllowThreads();
16069 result = (int)((wxDC const *)arg1)->GetMapMode();
16070
16071 wxPyEndAllowThreads(__tstate);
16072 if (PyErr_Occurred()) SWIG_fail;
16073 }
16074 {
16075 resultobj = SWIG_From_int((int)(result));
16076 }
16077 return resultobj;
16078 fail:
16079 return NULL;
16080 }
16081
16082
16083 static PyObject *_wrap_DC_SetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16084 PyObject *resultobj;
16085 wxDC *arg1 = (wxDC *) 0 ;
16086 int arg2 ;
16087 PyObject * obj0 = 0 ;
16088 PyObject * obj1 = 0 ;
16089 char *kwnames[] = {
16090 (char *) "self",(char *) "mode", NULL
16091 };
16092
16093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetMapMode",kwnames,&obj0,&obj1)) goto fail;
16094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16095 if (SWIG_arg_fail(1)) SWIG_fail;
16096 {
16097 arg2 = (int)(SWIG_As_int(obj1));
16098 if (SWIG_arg_fail(2)) SWIG_fail;
16099 }
16100 {
16101 PyThreadState* __tstate = wxPyBeginAllowThreads();
16102 (arg1)->SetMapMode(arg2);
16103
16104 wxPyEndAllowThreads(__tstate);
16105 if (PyErr_Occurred()) SWIG_fail;
16106 }
16107 Py_INCREF(Py_None); resultobj = Py_None;
16108 return resultobj;
16109 fail:
16110 return NULL;
16111 }
16112
16113
16114 static PyObject *_wrap_DC_GetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16115 PyObject *resultobj;
16116 wxDC *arg1 = (wxDC *) 0 ;
16117 double *arg2 = (double *) 0 ;
16118 double *arg3 = (double *) 0 ;
16119 double temp2 ;
16120 int res2 = 0 ;
16121 double temp3 ;
16122 int res3 = 0 ;
16123 PyObject * obj0 = 0 ;
16124 char *kwnames[] = {
16125 (char *) "self", NULL
16126 };
16127
16128 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16129 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetUserScale",kwnames,&obj0)) goto fail;
16131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16132 if (SWIG_arg_fail(1)) SWIG_fail;
16133 {
16134 PyThreadState* __tstate = wxPyBeginAllowThreads();
16135 ((wxDC const *)arg1)->GetUserScale(arg2,arg3);
16136
16137 wxPyEndAllowThreads(__tstate);
16138 if (PyErr_Occurred()) SWIG_fail;
16139 }
16140 Py_INCREF(Py_None); resultobj = Py_None;
16141 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16142 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16143 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16144 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16145 return resultobj;
16146 fail:
16147 return NULL;
16148 }
16149
16150
16151 static PyObject *_wrap_DC_SetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16152 PyObject *resultobj;
16153 wxDC *arg1 = (wxDC *) 0 ;
16154 double arg2 ;
16155 double arg3 ;
16156 PyObject * obj0 = 0 ;
16157 PyObject * obj1 = 0 ;
16158 PyObject * obj2 = 0 ;
16159 char *kwnames[] = {
16160 (char *) "self",(char *) "x",(char *) "y", NULL
16161 };
16162
16163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetUserScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16165 if (SWIG_arg_fail(1)) SWIG_fail;
16166 {
16167 arg2 = (double)(SWIG_As_double(obj1));
16168 if (SWIG_arg_fail(2)) SWIG_fail;
16169 }
16170 {
16171 arg3 = (double)(SWIG_As_double(obj2));
16172 if (SWIG_arg_fail(3)) SWIG_fail;
16173 }
16174 {
16175 PyThreadState* __tstate = wxPyBeginAllowThreads();
16176 (arg1)->SetUserScale(arg2,arg3);
16177
16178 wxPyEndAllowThreads(__tstate);
16179 if (PyErr_Occurred()) SWIG_fail;
16180 }
16181 Py_INCREF(Py_None); resultobj = Py_None;
16182 return resultobj;
16183 fail:
16184 return NULL;
16185 }
16186
16187
16188 static PyObject *_wrap_DC_GetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16189 PyObject *resultobj;
16190 wxDC *arg1 = (wxDC *) 0 ;
16191 double *arg2 = (double *) 0 ;
16192 double *arg3 = (double *) 0 ;
16193 double temp2 ;
16194 int res2 = 0 ;
16195 double temp3 ;
16196 int res3 = 0 ;
16197 PyObject * obj0 = 0 ;
16198 char *kwnames[] = {
16199 (char *) "self", NULL
16200 };
16201
16202 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16203 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalScale",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
16209 (arg1)->GetLogicalScale(arg2,arg3);
16210
16211 wxPyEndAllowThreads(__tstate);
16212 if (PyErr_Occurred()) SWIG_fail;
16213 }
16214 Py_INCREF(Py_None); resultobj = Py_None;
16215 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16216 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16217 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16218 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16219 return resultobj;
16220 fail:
16221 return NULL;
16222 }
16223
16224
16225 static PyObject *_wrap_DC_SetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16226 PyObject *resultobj;
16227 wxDC *arg1 = (wxDC *) 0 ;
16228 double arg2 ;
16229 double arg3 ;
16230 PyObject * obj0 = 0 ;
16231 PyObject * obj1 = 0 ;
16232 PyObject * obj2 = 0 ;
16233 char *kwnames[] = {
16234 (char *) "self",(char *) "x",(char *) "y", NULL
16235 };
16236
16237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16239 if (SWIG_arg_fail(1)) SWIG_fail;
16240 {
16241 arg2 = (double)(SWIG_As_double(obj1));
16242 if (SWIG_arg_fail(2)) SWIG_fail;
16243 }
16244 {
16245 arg3 = (double)(SWIG_As_double(obj2));
16246 if (SWIG_arg_fail(3)) SWIG_fail;
16247 }
16248 {
16249 PyThreadState* __tstate = wxPyBeginAllowThreads();
16250 (arg1)->SetLogicalScale(arg2,arg3);
16251
16252 wxPyEndAllowThreads(__tstate);
16253 if (PyErr_Occurred()) SWIG_fail;
16254 }
16255 Py_INCREF(Py_None); resultobj = Py_None;
16256 return resultobj;
16257 fail:
16258 return NULL;
16259 }
16260
16261
16262 static PyObject *_wrap_DC_GetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16263 PyObject *resultobj;
16264 wxDC *arg1 = (wxDC *) 0 ;
16265 wxPoint result;
16266 PyObject * obj0 = 0 ;
16267 char *kwnames[] = {
16268 (char *) "self", NULL
16269 };
16270
16271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOrigin",kwnames,&obj0)) goto fail;
16272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16273 if (SWIG_arg_fail(1)) SWIG_fail;
16274 {
16275 PyThreadState* __tstate = wxPyBeginAllowThreads();
16276 result = ((wxDC const *)arg1)->GetLogicalOrigin();
16277
16278 wxPyEndAllowThreads(__tstate);
16279 if (PyErr_Occurred()) SWIG_fail;
16280 }
16281 {
16282 wxPoint * resultptr;
16283 resultptr = new wxPoint((wxPoint &)(result));
16284 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16285 }
16286 return resultobj;
16287 fail:
16288 return NULL;
16289 }
16290
16291
16292 static PyObject *_wrap_DC_GetLogicalOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16293 PyObject *resultobj;
16294 wxDC *arg1 = (wxDC *) 0 ;
16295 int *arg2 = (int *) 0 ;
16296 int *arg3 = (int *) 0 ;
16297 int temp2 ;
16298 int res2 = 0 ;
16299 int temp3 ;
16300 int res3 = 0 ;
16301 PyObject * obj0 = 0 ;
16302 char *kwnames[] = {
16303 (char *) "self", NULL
16304 };
16305
16306 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16307 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOriginTuple",kwnames,&obj0)) goto fail;
16309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16310 if (SWIG_arg_fail(1)) SWIG_fail;
16311 {
16312 PyThreadState* __tstate = wxPyBeginAllowThreads();
16313 ((wxDC const *)arg1)->GetLogicalOrigin(arg2,arg3);
16314
16315 wxPyEndAllowThreads(__tstate);
16316 if (PyErr_Occurred()) SWIG_fail;
16317 }
16318 Py_INCREF(Py_None); resultobj = Py_None;
16319 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16320 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16321 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16322 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16323 return resultobj;
16324 fail:
16325 return NULL;
16326 }
16327
16328
16329 static PyObject *_wrap_DC_SetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16330 PyObject *resultobj;
16331 wxDC *arg1 = (wxDC *) 0 ;
16332 int arg2 ;
16333 int arg3 ;
16334 PyObject * obj0 = 0 ;
16335 PyObject * obj1 = 0 ;
16336 PyObject * obj2 = 0 ;
16337 char *kwnames[] = {
16338 (char *) "self",(char *) "x",(char *) "y", NULL
16339 };
16340
16341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
16342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16343 if (SWIG_arg_fail(1)) SWIG_fail;
16344 {
16345 arg2 = (int)(SWIG_As_int(obj1));
16346 if (SWIG_arg_fail(2)) SWIG_fail;
16347 }
16348 {
16349 arg3 = (int)(SWIG_As_int(obj2));
16350 if (SWIG_arg_fail(3)) SWIG_fail;
16351 }
16352 {
16353 PyThreadState* __tstate = wxPyBeginAllowThreads();
16354 (arg1)->SetLogicalOrigin(arg2,arg3);
16355
16356 wxPyEndAllowThreads(__tstate);
16357 if (PyErr_Occurred()) SWIG_fail;
16358 }
16359 Py_INCREF(Py_None); resultobj = Py_None;
16360 return resultobj;
16361 fail:
16362 return NULL;
16363 }
16364
16365
16366 static PyObject *_wrap_DC_SetLogicalOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16367 PyObject *resultobj;
16368 wxDC *arg1 = (wxDC *) 0 ;
16369 wxPoint *arg2 = 0 ;
16370 wxPoint temp2 ;
16371 PyObject * obj0 = 0 ;
16372 PyObject * obj1 = 0 ;
16373 char *kwnames[] = {
16374 (char *) "self",(char *) "point", NULL
16375 };
16376
16377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalOriginPoint",kwnames,&obj0,&obj1)) goto fail;
16378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16379 if (SWIG_arg_fail(1)) SWIG_fail;
16380 {
16381 arg2 = &temp2;
16382 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16383 }
16384 {
16385 PyThreadState* __tstate = wxPyBeginAllowThreads();
16386 wxDC_SetLogicalOriginPoint(arg1,(wxPoint const &)*arg2);
16387
16388 wxPyEndAllowThreads(__tstate);
16389 if (PyErr_Occurred()) SWIG_fail;
16390 }
16391 Py_INCREF(Py_None); resultobj = Py_None;
16392 return resultobj;
16393 fail:
16394 return NULL;
16395 }
16396
16397
16398 static PyObject *_wrap_DC_GetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16399 PyObject *resultobj;
16400 wxDC *arg1 = (wxDC *) 0 ;
16401 wxPoint result;
16402 PyObject * obj0 = 0 ;
16403 char *kwnames[] = {
16404 (char *) "self", NULL
16405 };
16406
16407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOrigin",kwnames,&obj0)) goto fail;
16408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16409 if (SWIG_arg_fail(1)) SWIG_fail;
16410 {
16411 PyThreadState* __tstate = wxPyBeginAllowThreads();
16412 result = ((wxDC const *)arg1)->GetDeviceOrigin();
16413
16414 wxPyEndAllowThreads(__tstate);
16415 if (PyErr_Occurred()) SWIG_fail;
16416 }
16417 {
16418 wxPoint * resultptr;
16419 resultptr = new wxPoint((wxPoint &)(result));
16420 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16421 }
16422 return resultobj;
16423 fail:
16424 return NULL;
16425 }
16426
16427
16428 static PyObject *_wrap_DC_GetDeviceOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16429 PyObject *resultobj;
16430 wxDC *arg1 = (wxDC *) 0 ;
16431 int *arg2 = (int *) 0 ;
16432 int *arg3 = (int *) 0 ;
16433 int temp2 ;
16434 int res2 = 0 ;
16435 int temp3 ;
16436 int res3 = 0 ;
16437 PyObject * obj0 = 0 ;
16438 char *kwnames[] = {
16439 (char *) "self", NULL
16440 };
16441
16442 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16443 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOriginTuple",kwnames,&obj0)) goto fail;
16445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16446 if (SWIG_arg_fail(1)) SWIG_fail;
16447 {
16448 PyThreadState* __tstate = wxPyBeginAllowThreads();
16449 ((wxDC const *)arg1)->GetDeviceOrigin(arg2,arg3);
16450
16451 wxPyEndAllowThreads(__tstate);
16452 if (PyErr_Occurred()) SWIG_fail;
16453 }
16454 Py_INCREF(Py_None); resultobj = Py_None;
16455 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16456 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16457 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16458 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16459 return resultobj;
16460 fail:
16461 return NULL;
16462 }
16463
16464
16465 static PyObject *_wrap_DC_SetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16466 PyObject *resultobj;
16467 wxDC *arg1 = (wxDC *) 0 ;
16468 int arg2 ;
16469 int arg3 ;
16470 PyObject * obj0 = 0 ;
16471 PyObject * obj1 = 0 ;
16472 PyObject * obj2 = 0 ;
16473 char *kwnames[] = {
16474 (char *) "self",(char *) "x",(char *) "y", NULL
16475 };
16476
16477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetDeviceOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
16478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16479 if (SWIG_arg_fail(1)) SWIG_fail;
16480 {
16481 arg2 = (int)(SWIG_As_int(obj1));
16482 if (SWIG_arg_fail(2)) SWIG_fail;
16483 }
16484 {
16485 arg3 = (int)(SWIG_As_int(obj2));
16486 if (SWIG_arg_fail(3)) SWIG_fail;
16487 }
16488 {
16489 PyThreadState* __tstate = wxPyBeginAllowThreads();
16490 (arg1)->SetDeviceOrigin(arg2,arg3);
16491
16492 wxPyEndAllowThreads(__tstate);
16493 if (PyErr_Occurred()) SWIG_fail;
16494 }
16495 Py_INCREF(Py_None); resultobj = Py_None;
16496 return resultobj;
16497 fail:
16498 return NULL;
16499 }
16500
16501
16502 static PyObject *_wrap_DC_SetDeviceOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16503 PyObject *resultobj;
16504 wxDC *arg1 = (wxDC *) 0 ;
16505 wxPoint *arg2 = 0 ;
16506 wxPoint temp2 ;
16507 PyObject * obj0 = 0 ;
16508 PyObject * obj1 = 0 ;
16509 char *kwnames[] = {
16510 (char *) "self",(char *) "point", NULL
16511 };
16512
16513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetDeviceOriginPoint",kwnames,&obj0,&obj1)) goto fail;
16514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16515 if (SWIG_arg_fail(1)) SWIG_fail;
16516 {
16517 arg2 = &temp2;
16518 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16519 }
16520 {
16521 PyThreadState* __tstate = wxPyBeginAllowThreads();
16522 wxDC_SetDeviceOriginPoint(arg1,(wxPoint const &)*arg2);
16523
16524 wxPyEndAllowThreads(__tstate);
16525 if (PyErr_Occurred()) SWIG_fail;
16526 }
16527 Py_INCREF(Py_None); resultobj = Py_None;
16528 return resultobj;
16529 fail:
16530 return NULL;
16531 }
16532
16533
16534 static PyObject *_wrap_DC_SetAxisOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16535 PyObject *resultobj;
16536 wxDC *arg1 = (wxDC *) 0 ;
16537 bool arg2 ;
16538 bool arg3 ;
16539 PyObject * obj0 = 0 ;
16540 PyObject * obj1 = 0 ;
16541 PyObject * obj2 = 0 ;
16542 char *kwnames[] = {
16543 (char *) "self",(char *) "xLeftRight",(char *) "yBottomUp", NULL
16544 };
16545
16546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetAxisOrientation",kwnames,&obj0,&obj1,&obj2)) goto fail;
16547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16548 if (SWIG_arg_fail(1)) SWIG_fail;
16549 {
16550 arg2 = (bool)(SWIG_As_bool(obj1));
16551 if (SWIG_arg_fail(2)) SWIG_fail;
16552 }
16553 {
16554 arg3 = (bool)(SWIG_As_bool(obj2));
16555 if (SWIG_arg_fail(3)) SWIG_fail;
16556 }
16557 {
16558 PyThreadState* __tstate = wxPyBeginAllowThreads();
16559 (arg1)->SetAxisOrientation(arg2,arg3);
16560
16561 wxPyEndAllowThreads(__tstate);
16562 if (PyErr_Occurred()) SWIG_fail;
16563 }
16564 Py_INCREF(Py_None); resultobj = Py_None;
16565 return resultobj;
16566 fail:
16567 return NULL;
16568 }
16569
16570
16571 static PyObject *_wrap_DC_GetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
16572 PyObject *resultobj;
16573 wxDC *arg1 = (wxDC *) 0 ;
16574 int result;
16575 PyObject * obj0 = 0 ;
16576 char *kwnames[] = {
16577 (char *) "self", NULL
16578 };
16579
16580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalFunction",kwnames,&obj0)) goto fail;
16581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16582 if (SWIG_arg_fail(1)) SWIG_fail;
16583 {
16584 PyThreadState* __tstate = wxPyBeginAllowThreads();
16585 result = (int)((wxDC const *)arg1)->GetLogicalFunction();
16586
16587 wxPyEndAllowThreads(__tstate);
16588 if (PyErr_Occurred()) SWIG_fail;
16589 }
16590 {
16591 resultobj = SWIG_From_int((int)(result));
16592 }
16593 return resultobj;
16594 fail:
16595 return NULL;
16596 }
16597
16598
16599 static PyObject *_wrap_DC_SetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
16600 PyObject *resultobj;
16601 wxDC *arg1 = (wxDC *) 0 ;
16602 int arg2 ;
16603 PyObject * obj0 = 0 ;
16604 PyObject * obj1 = 0 ;
16605 char *kwnames[] = {
16606 (char *) "self",(char *) "function", NULL
16607 };
16608
16609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalFunction",kwnames,&obj0,&obj1)) goto fail;
16610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16611 if (SWIG_arg_fail(1)) SWIG_fail;
16612 {
16613 arg2 = (int)(SWIG_As_int(obj1));
16614 if (SWIG_arg_fail(2)) SWIG_fail;
16615 }
16616 {
16617 PyThreadState* __tstate = wxPyBeginAllowThreads();
16618 (arg1)->SetLogicalFunction(arg2);
16619
16620 wxPyEndAllowThreads(__tstate);
16621 if (PyErr_Occurred()) SWIG_fail;
16622 }
16623 Py_INCREF(Py_None); resultobj = Py_None;
16624 return resultobj;
16625 fail:
16626 return NULL;
16627 }
16628
16629
16630 static PyObject *_wrap_DC_ComputeScaleAndOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16631 PyObject *resultobj;
16632 wxDC *arg1 = (wxDC *) 0 ;
16633 PyObject * obj0 = 0 ;
16634 char *kwnames[] = {
16635 (char *) "self", NULL
16636 };
16637
16638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ComputeScaleAndOrigin",kwnames,&obj0)) goto fail;
16639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16640 if (SWIG_arg_fail(1)) SWIG_fail;
16641 {
16642 PyThreadState* __tstate = wxPyBeginAllowThreads();
16643 (arg1)->ComputeScaleAndOrigin();
16644
16645 wxPyEndAllowThreads(__tstate);
16646 if (PyErr_Occurred()) SWIG_fail;
16647 }
16648 Py_INCREF(Py_None); resultobj = Py_None;
16649 return resultobj;
16650 fail:
16651 return NULL;
16652 }
16653
16654
16655 static PyObject *_wrap_DC_CalcBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16656 PyObject *resultobj;
16657 wxDC *arg1 = (wxDC *) 0 ;
16658 int arg2 ;
16659 int arg3 ;
16660 PyObject * obj0 = 0 ;
16661 PyObject * obj1 = 0 ;
16662 PyObject * obj2 = 0 ;
16663 char *kwnames[] = {
16664 (char *) "self",(char *) "x",(char *) "y", NULL
16665 };
16666
16667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CalcBoundingBox",kwnames,&obj0,&obj1,&obj2)) goto fail;
16668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16669 if (SWIG_arg_fail(1)) SWIG_fail;
16670 {
16671 arg2 = (int)(SWIG_As_int(obj1));
16672 if (SWIG_arg_fail(2)) SWIG_fail;
16673 }
16674 {
16675 arg3 = (int)(SWIG_As_int(obj2));
16676 if (SWIG_arg_fail(3)) SWIG_fail;
16677 }
16678 {
16679 PyThreadState* __tstate = wxPyBeginAllowThreads();
16680 (arg1)->CalcBoundingBox(arg2,arg3);
16681
16682 wxPyEndAllowThreads(__tstate);
16683 if (PyErr_Occurred()) SWIG_fail;
16684 }
16685 Py_INCREF(Py_None); resultobj = Py_None;
16686 return resultobj;
16687 fail:
16688 return NULL;
16689 }
16690
16691
16692 static PyObject *_wrap_DC_CalcBoundingBoxPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16693 PyObject *resultobj;
16694 wxDC *arg1 = (wxDC *) 0 ;
16695 wxPoint *arg2 = 0 ;
16696 wxPoint temp2 ;
16697 PyObject * obj0 = 0 ;
16698 PyObject * obj1 = 0 ;
16699 char *kwnames[] = {
16700 (char *) "self",(char *) "point", NULL
16701 };
16702
16703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CalcBoundingBoxPoint",kwnames,&obj0,&obj1)) goto fail;
16704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16705 if (SWIG_arg_fail(1)) SWIG_fail;
16706 {
16707 arg2 = &temp2;
16708 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16709 }
16710 {
16711 PyThreadState* __tstate = wxPyBeginAllowThreads();
16712 wxDC_CalcBoundingBoxPoint(arg1,(wxPoint const &)*arg2);
16713
16714 wxPyEndAllowThreads(__tstate);
16715 if (PyErr_Occurred()) SWIG_fail;
16716 }
16717 Py_INCREF(Py_None); resultobj = Py_None;
16718 return resultobj;
16719 fail:
16720 return NULL;
16721 }
16722
16723
16724 static PyObject *_wrap_DC_ResetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16725 PyObject *resultobj;
16726 wxDC *arg1 = (wxDC *) 0 ;
16727 PyObject * obj0 = 0 ;
16728 char *kwnames[] = {
16729 (char *) "self", NULL
16730 };
16731
16732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ResetBoundingBox",kwnames,&obj0)) goto fail;
16733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16734 if (SWIG_arg_fail(1)) SWIG_fail;
16735 {
16736 PyThreadState* __tstate = wxPyBeginAllowThreads();
16737 (arg1)->ResetBoundingBox();
16738
16739 wxPyEndAllowThreads(__tstate);
16740 if (PyErr_Occurred()) SWIG_fail;
16741 }
16742 Py_INCREF(Py_None); resultobj = Py_None;
16743 return resultobj;
16744 fail:
16745 return NULL;
16746 }
16747
16748
16749 static PyObject *_wrap_DC_MinX(PyObject *, PyObject *args, PyObject *kwargs) {
16750 PyObject *resultobj;
16751 wxDC *arg1 = (wxDC *) 0 ;
16752 int result;
16753 PyObject * obj0 = 0 ;
16754 char *kwnames[] = {
16755 (char *) "self", NULL
16756 };
16757
16758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinX",kwnames,&obj0)) goto fail;
16759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16760 if (SWIG_arg_fail(1)) SWIG_fail;
16761 {
16762 PyThreadState* __tstate = wxPyBeginAllowThreads();
16763 result = (int)((wxDC const *)arg1)->MinX();
16764
16765 wxPyEndAllowThreads(__tstate);
16766 if (PyErr_Occurred()) SWIG_fail;
16767 }
16768 {
16769 resultobj = SWIG_From_int((int)(result));
16770 }
16771 return resultobj;
16772 fail:
16773 return NULL;
16774 }
16775
16776
16777 static PyObject *_wrap_DC_MaxX(PyObject *, PyObject *args, PyObject *kwargs) {
16778 PyObject *resultobj;
16779 wxDC *arg1 = (wxDC *) 0 ;
16780 int result;
16781 PyObject * obj0 = 0 ;
16782 char *kwnames[] = {
16783 (char *) "self", NULL
16784 };
16785
16786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxX",kwnames,&obj0)) goto fail;
16787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16788 if (SWIG_arg_fail(1)) SWIG_fail;
16789 {
16790 PyThreadState* __tstate = wxPyBeginAllowThreads();
16791 result = (int)((wxDC const *)arg1)->MaxX();
16792
16793 wxPyEndAllowThreads(__tstate);
16794 if (PyErr_Occurred()) SWIG_fail;
16795 }
16796 {
16797 resultobj = SWIG_From_int((int)(result));
16798 }
16799 return resultobj;
16800 fail:
16801 return NULL;
16802 }
16803
16804
16805 static PyObject *_wrap_DC_MinY(PyObject *, PyObject *args, PyObject *kwargs) {
16806 PyObject *resultobj;
16807 wxDC *arg1 = (wxDC *) 0 ;
16808 int result;
16809 PyObject * obj0 = 0 ;
16810 char *kwnames[] = {
16811 (char *) "self", NULL
16812 };
16813
16814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinY",kwnames,&obj0)) goto fail;
16815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16816 if (SWIG_arg_fail(1)) SWIG_fail;
16817 {
16818 PyThreadState* __tstate = wxPyBeginAllowThreads();
16819 result = (int)((wxDC const *)arg1)->MinY();
16820
16821 wxPyEndAllowThreads(__tstate);
16822 if (PyErr_Occurred()) SWIG_fail;
16823 }
16824 {
16825 resultobj = SWIG_From_int((int)(result));
16826 }
16827 return resultobj;
16828 fail:
16829 return NULL;
16830 }
16831
16832
16833 static PyObject *_wrap_DC_MaxY(PyObject *, PyObject *args, PyObject *kwargs) {
16834 PyObject *resultobj;
16835 wxDC *arg1 = (wxDC *) 0 ;
16836 int result;
16837 PyObject * obj0 = 0 ;
16838 char *kwnames[] = {
16839 (char *) "self", NULL
16840 };
16841
16842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxY",kwnames,&obj0)) goto fail;
16843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16844 if (SWIG_arg_fail(1)) SWIG_fail;
16845 {
16846 PyThreadState* __tstate = wxPyBeginAllowThreads();
16847 result = (int)((wxDC const *)arg1)->MaxY();
16848
16849 wxPyEndAllowThreads(__tstate);
16850 if (PyErr_Occurred()) SWIG_fail;
16851 }
16852 {
16853 resultobj = SWIG_From_int((int)(result));
16854 }
16855 return resultobj;
16856 fail:
16857 return NULL;
16858 }
16859
16860
16861 static PyObject *_wrap_DC_GetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16862 PyObject *resultobj;
16863 wxDC *arg1 = (wxDC *) 0 ;
16864 int *arg2 = (int *) 0 ;
16865 int *arg3 = (int *) 0 ;
16866 int *arg4 = (int *) 0 ;
16867 int *arg5 = (int *) 0 ;
16868 int temp2 ;
16869 int res2 = 0 ;
16870 int temp3 ;
16871 int res3 = 0 ;
16872 int temp4 ;
16873 int res4 = 0 ;
16874 int temp5 ;
16875 int res5 = 0 ;
16876 PyObject * obj0 = 0 ;
16877 char *kwnames[] = {
16878 (char *) "self", NULL
16879 };
16880
16881 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16882 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16883 arg4 = &temp4; res4 = SWIG_NEWOBJ;
16884 arg5 = &temp5; res5 = SWIG_NEWOBJ;
16885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBoundingBox",kwnames,&obj0)) goto fail;
16886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16887 if (SWIG_arg_fail(1)) SWIG_fail;
16888 {
16889 PyThreadState* __tstate = wxPyBeginAllowThreads();
16890 wxDC_GetBoundingBox(arg1,arg2,arg3,arg4,arg5);
16891
16892 wxPyEndAllowThreads(__tstate);
16893 if (PyErr_Occurred()) SWIG_fail;
16894 }
16895 Py_INCREF(Py_None); resultobj = Py_None;
16896 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16897 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16898 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16899 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16900 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
16901 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
16902 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
16903 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
16904 return resultobj;
16905 fail:
16906 return NULL;
16907 }
16908
16909
16910 static PyObject *_wrap_DC__DrawPointList(PyObject *, PyObject *args, PyObject *kwargs) {
16911 PyObject *resultobj;
16912 wxDC *arg1 = (wxDC *) 0 ;
16913 PyObject *arg2 = (PyObject *) 0 ;
16914 PyObject *arg3 = (PyObject *) 0 ;
16915 PyObject *arg4 = (PyObject *) 0 ;
16916 PyObject *result;
16917 PyObject * obj0 = 0 ;
16918 PyObject * obj1 = 0 ;
16919 PyObject * obj2 = 0 ;
16920 PyObject * obj3 = 0 ;
16921 char *kwnames[] = {
16922 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
16923 };
16924
16925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPointList",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 arg2 = obj1;
16929 arg3 = obj2;
16930 arg4 = obj3;
16931 {
16932 PyThreadState* __tstate = wxPyBeginAllowThreads();
16933 result = (PyObject *)wxDC__DrawPointList(arg1,arg2,arg3,arg4);
16934
16935 wxPyEndAllowThreads(__tstate);
16936 if (PyErr_Occurred()) SWIG_fail;
16937 }
16938 resultobj = result;
16939 return resultobj;
16940 fail:
16941 return NULL;
16942 }
16943
16944
16945 static PyObject *_wrap_DC__DrawLineList(PyObject *, PyObject *args, PyObject *kwargs) {
16946 PyObject *resultobj;
16947 wxDC *arg1 = (wxDC *) 0 ;
16948 PyObject *arg2 = (PyObject *) 0 ;
16949 PyObject *arg3 = (PyObject *) 0 ;
16950 PyObject *arg4 = (PyObject *) 0 ;
16951 PyObject *result;
16952 PyObject * obj0 = 0 ;
16953 PyObject * obj1 = 0 ;
16954 PyObject * obj2 = 0 ;
16955 PyObject * obj3 = 0 ;
16956 char *kwnames[] = {
16957 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
16958 };
16959
16960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawLineList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16962 if (SWIG_arg_fail(1)) SWIG_fail;
16963 arg2 = obj1;
16964 arg3 = obj2;
16965 arg4 = obj3;
16966 {
16967 PyThreadState* __tstate = wxPyBeginAllowThreads();
16968 result = (PyObject *)wxDC__DrawLineList(arg1,arg2,arg3,arg4);
16969
16970 wxPyEndAllowThreads(__tstate);
16971 if (PyErr_Occurred()) SWIG_fail;
16972 }
16973 resultobj = result;
16974 return resultobj;
16975 fail:
16976 return NULL;
16977 }
16978
16979
16980 static PyObject *_wrap_DC__DrawRectangleList(PyObject *, PyObject *args, PyObject *kwargs) {
16981 PyObject *resultobj;
16982 wxDC *arg1 = (wxDC *) 0 ;
16983 PyObject *arg2 = (PyObject *) 0 ;
16984 PyObject *arg3 = (PyObject *) 0 ;
16985 PyObject *arg4 = (PyObject *) 0 ;
16986 PyObject *result;
16987 PyObject * obj0 = 0 ;
16988 PyObject * obj1 = 0 ;
16989 PyObject * obj2 = 0 ;
16990 PyObject * obj3 = 0 ;
16991 char *kwnames[] = {
16992 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
16993 };
16994
16995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawRectangleList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16997 if (SWIG_arg_fail(1)) SWIG_fail;
16998 arg2 = obj1;
16999 arg3 = obj2;
17000 arg4 = obj3;
17001 {
17002 PyThreadState* __tstate = wxPyBeginAllowThreads();
17003 result = (PyObject *)wxDC__DrawRectangleList(arg1,arg2,arg3,arg4);
17004
17005 wxPyEndAllowThreads(__tstate);
17006 if (PyErr_Occurred()) SWIG_fail;
17007 }
17008 resultobj = result;
17009 return resultobj;
17010 fail:
17011 return NULL;
17012 }
17013
17014
17015 static PyObject *_wrap_DC__DrawEllipseList(PyObject *, PyObject *args, PyObject *kwargs) {
17016 PyObject *resultobj;
17017 wxDC *arg1 = (wxDC *) 0 ;
17018 PyObject *arg2 = (PyObject *) 0 ;
17019 PyObject *arg3 = (PyObject *) 0 ;
17020 PyObject *arg4 = (PyObject *) 0 ;
17021 PyObject *result;
17022 PyObject * obj0 = 0 ;
17023 PyObject * obj1 = 0 ;
17024 PyObject * obj2 = 0 ;
17025 PyObject * obj3 = 0 ;
17026 char *kwnames[] = {
17027 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17028 };
17029
17030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawEllipseList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17032 if (SWIG_arg_fail(1)) SWIG_fail;
17033 arg2 = obj1;
17034 arg3 = obj2;
17035 arg4 = obj3;
17036 {
17037 PyThreadState* __tstate = wxPyBeginAllowThreads();
17038 result = (PyObject *)wxDC__DrawEllipseList(arg1,arg2,arg3,arg4);
17039
17040 wxPyEndAllowThreads(__tstate);
17041 if (PyErr_Occurred()) SWIG_fail;
17042 }
17043 resultobj = result;
17044 return resultobj;
17045 fail:
17046 return NULL;
17047 }
17048
17049
17050 static PyObject *_wrap_DC__DrawPolygonList(PyObject *, PyObject *args, PyObject *kwargs) {
17051 PyObject *resultobj;
17052 wxDC *arg1 = (wxDC *) 0 ;
17053 PyObject *arg2 = (PyObject *) 0 ;
17054 PyObject *arg3 = (PyObject *) 0 ;
17055 PyObject *arg4 = (PyObject *) 0 ;
17056 PyObject *result;
17057 PyObject * obj0 = 0 ;
17058 PyObject * obj1 = 0 ;
17059 PyObject * obj2 = 0 ;
17060 PyObject * obj3 = 0 ;
17061 char *kwnames[] = {
17062 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17063 };
17064
17065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPolygonList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17067 if (SWIG_arg_fail(1)) SWIG_fail;
17068 arg2 = obj1;
17069 arg3 = obj2;
17070 arg4 = obj3;
17071 {
17072 PyThreadState* __tstate = wxPyBeginAllowThreads();
17073 result = (PyObject *)wxDC__DrawPolygonList(arg1,arg2,arg3,arg4);
17074
17075 wxPyEndAllowThreads(__tstate);
17076 if (PyErr_Occurred()) SWIG_fail;
17077 }
17078 resultobj = result;
17079 return resultobj;
17080 fail:
17081 return NULL;
17082 }
17083
17084
17085 static PyObject *_wrap_DC__DrawTextList(PyObject *, PyObject *args, PyObject *kwargs) {
17086 PyObject *resultobj;
17087 wxDC *arg1 = (wxDC *) 0 ;
17088 PyObject *arg2 = (PyObject *) 0 ;
17089 PyObject *arg3 = (PyObject *) 0 ;
17090 PyObject *arg4 = (PyObject *) 0 ;
17091 PyObject *arg5 = (PyObject *) 0 ;
17092 PyObject *result;
17093 PyObject * obj0 = 0 ;
17094 PyObject * obj1 = 0 ;
17095 PyObject * obj2 = 0 ;
17096 PyObject * obj3 = 0 ;
17097 PyObject * obj4 = 0 ;
17098 char *kwnames[] = {
17099 (char *) "self",(char *) "textList",(char *) "pyPoints",(char *) "foregroundList",(char *) "backgroundList", NULL
17100 };
17101
17102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC__DrawTextList",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
17103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17104 if (SWIG_arg_fail(1)) SWIG_fail;
17105 arg2 = obj1;
17106 arg3 = obj2;
17107 arg4 = obj3;
17108 arg5 = obj4;
17109 {
17110 PyThreadState* __tstate = wxPyBeginAllowThreads();
17111 result = (PyObject *)wxDC__DrawTextList(arg1,arg2,arg3,arg4,arg5);
17112
17113 wxPyEndAllowThreads(__tstate);
17114 if (PyErr_Occurred()) SWIG_fail;
17115 }
17116 resultobj = result;
17117 return resultobj;
17118 fail:
17119 return NULL;
17120 }
17121
17122
17123 static PyObject * DC_swigregister(PyObject *, PyObject *args) {
17124 PyObject *obj;
17125 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17126 SWIG_TypeClientData(SWIGTYPE_p_wxDC, obj);
17127 Py_INCREF(obj);
17128 return Py_BuildValue((char *)"");
17129 }
17130 static PyObject *_wrap_new_MemoryDC(PyObject *, PyObject *args, PyObject *kwargs) {
17131 PyObject *resultobj;
17132 wxMemoryDC *result;
17133 char *kwnames[] = {
17134 NULL
17135 };
17136
17137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryDC",kwnames)) goto fail;
17138 {
17139 if (!wxPyCheckForApp()) SWIG_fail;
17140 PyThreadState* __tstate = wxPyBeginAllowThreads();
17141 result = (wxMemoryDC *)new wxMemoryDC();
17142
17143 wxPyEndAllowThreads(__tstate);
17144 if (PyErr_Occurred()) SWIG_fail;
17145 }
17146 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17147 return resultobj;
17148 fail:
17149 return NULL;
17150 }
17151
17152
17153 static PyObject *_wrap_new_MemoryDCFromDC(PyObject *, PyObject *args, PyObject *kwargs) {
17154 PyObject *resultobj;
17155 wxDC *arg1 = (wxDC *) 0 ;
17156 wxMemoryDC *result;
17157 PyObject * obj0 = 0 ;
17158 char *kwnames[] = {
17159 (char *) "oldDC", NULL
17160 };
17161
17162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_MemoryDCFromDC",kwnames,&obj0)) goto fail;
17163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17164 if (SWIG_arg_fail(1)) SWIG_fail;
17165 {
17166 if (!wxPyCheckForApp()) SWIG_fail;
17167 PyThreadState* __tstate = wxPyBeginAllowThreads();
17168 result = (wxMemoryDC *)new wxMemoryDC(arg1);
17169
17170 wxPyEndAllowThreads(__tstate);
17171 if (PyErr_Occurred()) SWIG_fail;
17172 }
17173 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17174 return resultobj;
17175 fail:
17176 return NULL;
17177 }
17178
17179
17180 static PyObject *_wrap_MemoryDC_SelectObject(PyObject *, PyObject *args, PyObject *kwargs) {
17181 PyObject *resultobj;
17182 wxMemoryDC *arg1 = (wxMemoryDC *) 0 ;
17183 wxBitmap *arg2 = 0 ;
17184 PyObject * obj0 = 0 ;
17185 PyObject * obj1 = 0 ;
17186 char *kwnames[] = {
17187 (char *) "self",(char *) "bitmap", NULL
17188 };
17189
17190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryDC_SelectObject",kwnames,&obj0,&obj1)) goto fail;
17191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryDC, SWIG_POINTER_EXCEPTION | 0);
17192 if (SWIG_arg_fail(1)) SWIG_fail;
17193 {
17194 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17195 if (SWIG_arg_fail(2)) SWIG_fail;
17196 if (arg2 == NULL) {
17197 SWIG_null_ref("wxBitmap");
17198 }
17199 if (SWIG_arg_fail(2)) SWIG_fail;
17200 }
17201 {
17202 PyThreadState* __tstate = wxPyBeginAllowThreads();
17203 (arg1)->SelectObject((wxBitmap const &)*arg2);
17204
17205 wxPyEndAllowThreads(__tstate);
17206 if (PyErr_Occurred()) SWIG_fail;
17207 }
17208 Py_INCREF(Py_None); resultobj = Py_None;
17209 return resultobj;
17210 fail:
17211 return NULL;
17212 }
17213
17214
17215 static PyObject * MemoryDC_swigregister(PyObject *, PyObject *args) {
17216 PyObject *obj;
17217 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17218 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryDC, obj);
17219 Py_INCREF(obj);
17220 return Py_BuildValue((char *)"");
17221 }
17222 static PyObject *_wrap_new_BufferedDC__SWIG_0(PyObject *, PyObject *args) {
17223 PyObject *resultobj;
17224 wxDC *arg1 = (wxDC *) 0 ;
17225 wxBitmap const &arg2_defvalue = wxNullBitmap ;
17226 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
17227 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
17228 wxBufferedDC *result;
17229 PyObject * obj0 = 0 ;
17230 PyObject * obj1 = 0 ;
17231 PyObject * obj2 = 0 ;
17232
17233 if(!PyArg_ParseTuple(args,(char *)"O|OO:new_BufferedDC",&obj0,&obj1,&obj2)) goto fail;
17234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17235 if (SWIG_arg_fail(1)) SWIG_fail;
17236 if (obj1) {
17237 {
17238 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17239 if (SWIG_arg_fail(2)) SWIG_fail;
17240 if (arg2 == NULL) {
17241 SWIG_null_ref("wxBitmap");
17242 }
17243 if (SWIG_arg_fail(2)) SWIG_fail;
17244 }
17245 }
17246 if (obj2) {
17247 {
17248 arg3 = (int)(SWIG_As_int(obj2));
17249 if (SWIG_arg_fail(3)) SWIG_fail;
17250 }
17251 }
17252 {
17253 if (!wxPyCheckForApp()) SWIG_fail;
17254 PyThreadState* __tstate = wxPyBeginAllowThreads();
17255 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxBitmap const &)*arg2,arg3);
17256
17257 wxPyEndAllowThreads(__tstate);
17258 if (PyErr_Occurred()) SWIG_fail;
17259 }
17260 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
17261 return resultobj;
17262 fail:
17263 return NULL;
17264 }
17265
17266
17267 static PyObject *_wrap_new_BufferedDC__SWIG_1(PyObject *, PyObject *args) {
17268 PyObject *resultobj;
17269 wxDC *arg1 = (wxDC *) 0 ;
17270 wxSize *arg2 = 0 ;
17271 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
17272 wxBufferedDC *result;
17273 wxSize temp2 ;
17274 PyObject * obj0 = 0 ;
17275 PyObject * obj1 = 0 ;
17276 PyObject * obj2 = 0 ;
17277
17278 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_BufferedDC",&obj0,&obj1,&obj2)) goto fail;
17279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17280 if (SWIG_arg_fail(1)) SWIG_fail;
17281 {
17282 arg2 = &temp2;
17283 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
17284 }
17285 if (obj2) {
17286 {
17287 arg3 = (int)(SWIG_As_int(obj2));
17288 if (SWIG_arg_fail(3)) SWIG_fail;
17289 }
17290 }
17291 {
17292 if (!wxPyCheckForApp()) SWIG_fail;
17293 PyThreadState* __tstate = wxPyBeginAllowThreads();
17294 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxSize const &)*arg2,arg3);
17295
17296 wxPyEndAllowThreads(__tstate);
17297 if (PyErr_Occurred()) SWIG_fail;
17298 }
17299 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
17300 return resultobj;
17301 fail:
17302 return NULL;
17303 }
17304
17305
17306 static PyObject *_wrap_new_BufferedDC(PyObject *self, PyObject *args) {
17307 int argc;
17308 PyObject *argv[4];
17309 int ii;
17310
17311 argc = PyObject_Length(args);
17312 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
17313 argv[ii] = PyTuple_GetItem(args,ii);
17314 }
17315 if ((argc >= 1) && (argc <= 3)) {
17316 int _v;
17317 {
17318 void *ptr;
17319 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
17320 _v = 0;
17321 PyErr_Clear();
17322 } else {
17323 _v = 1;
17324 }
17325 }
17326 if (_v) {
17327 if (argc <= 1) {
17328 return _wrap_new_BufferedDC__SWIG_0(self,args);
17329 }
17330 {
17331 void *ptr = 0;
17332 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxBitmap, 0) == -1) {
17333 _v = 0;
17334 PyErr_Clear();
17335 } else {
17336 _v = (ptr != 0);
17337 }
17338 }
17339 if (_v) {
17340 if (argc <= 2) {
17341 return _wrap_new_BufferedDC__SWIG_0(self,args);
17342 }
17343 _v = SWIG_Check_int(argv[2]);
17344 if (_v) {
17345 return _wrap_new_BufferedDC__SWIG_0(self,args);
17346 }
17347 }
17348 }
17349 }
17350 if ((argc >= 2) && (argc <= 3)) {
17351 int _v;
17352 {
17353 void *ptr;
17354 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
17355 _v = 0;
17356 PyErr_Clear();
17357 } else {
17358 _v = 1;
17359 }
17360 }
17361 if (_v) {
17362 {
17363 _v = wxPySimple_typecheck(argv[1], wxT("wxSize"), 2);
17364 }
17365 if (_v) {
17366 if (argc <= 2) {
17367 return _wrap_new_BufferedDC__SWIG_1(self,args);
17368 }
17369 _v = SWIG_Check_int(argv[2]);
17370 if (_v) {
17371 return _wrap_new_BufferedDC__SWIG_1(self,args);
17372 }
17373 }
17374 }
17375 }
17376
17377 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_BufferedDC'");
17378 return NULL;
17379 }
17380
17381
17382 static PyObject *_wrap_delete_BufferedDC(PyObject *, PyObject *args, PyObject *kwargs) {
17383 PyObject *resultobj;
17384 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
17385 PyObject * obj0 = 0 ;
17386 char *kwnames[] = {
17387 (char *) "self", NULL
17388 };
17389
17390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BufferedDC",kwnames,&obj0)) goto fail;
17391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
17392 if (SWIG_arg_fail(1)) SWIG_fail;
17393 {
17394 PyThreadState* __tstate = wxPyBeginAllowThreads();
17395 delete arg1;
17396
17397 wxPyEndAllowThreads(__tstate);
17398 if (PyErr_Occurred()) SWIG_fail;
17399 }
17400 Py_INCREF(Py_None); resultobj = Py_None;
17401 return resultobj;
17402 fail:
17403 return NULL;
17404 }
17405
17406
17407 static PyObject *_wrap_BufferedDC_UnMask(PyObject *, PyObject *args, PyObject *kwargs) {
17408 PyObject *resultobj;
17409 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
17410 PyObject * obj0 = 0 ;
17411 char *kwnames[] = {
17412 (char *) "self", NULL
17413 };
17414
17415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BufferedDC_UnMask",kwnames,&obj0)) goto fail;
17416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
17417 if (SWIG_arg_fail(1)) SWIG_fail;
17418 {
17419 PyThreadState* __tstate = wxPyBeginAllowThreads();
17420 (arg1)->UnMask();
17421
17422 wxPyEndAllowThreads(__tstate);
17423 if (PyErr_Occurred()) SWIG_fail;
17424 }
17425 Py_INCREF(Py_None); resultobj = Py_None;
17426 return resultobj;
17427 fail:
17428 return NULL;
17429 }
17430
17431
17432 static PyObject * BufferedDC_swigregister(PyObject *, PyObject *args) {
17433 PyObject *obj;
17434 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17435 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedDC, obj);
17436 Py_INCREF(obj);
17437 return Py_BuildValue((char *)"");
17438 }
17439 static PyObject *_wrap_new_BufferedPaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
17440 PyObject *resultobj;
17441 wxWindow *arg1 = (wxWindow *) 0 ;
17442 wxBitmap const &arg2_defvalue = wxNullBitmap ;
17443 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
17444 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
17445 wxBufferedPaintDC *result;
17446 PyObject * obj0 = 0 ;
17447 PyObject * obj1 = 0 ;
17448 PyObject * obj2 = 0 ;
17449 char *kwnames[] = {
17450 (char *) "window",(char *) "buffer",(char *) "style", NULL
17451 };
17452
17453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_BufferedPaintDC",kwnames,&obj0,&obj1,&obj2)) goto fail;
17454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17455 if (SWIG_arg_fail(1)) SWIG_fail;
17456 if (obj1) {
17457 {
17458 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17459 if (SWIG_arg_fail(2)) SWIG_fail;
17460 if (arg2 == NULL) {
17461 SWIG_null_ref("wxBitmap");
17462 }
17463 if (SWIG_arg_fail(2)) SWIG_fail;
17464 }
17465 }
17466 if (obj2) {
17467 {
17468 arg3 = (int)(SWIG_As_int(obj2));
17469 if (SWIG_arg_fail(3)) SWIG_fail;
17470 }
17471 }
17472 {
17473 if (!wxPyCheckForApp()) SWIG_fail;
17474 PyThreadState* __tstate = wxPyBeginAllowThreads();
17475 result = (wxBufferedPaintDC *)new wxBufferedPaintDC(arg1,(wxBitmap const &)*arg2,arg3);
17476
17477 wxPyEndAllowThreads(__tstate);
17478 if (PyErr_Occurred()) SWIG_fail;
17479 }
17480 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedPaintDC, 1);
17481 return resultobj;
17482 fail:
17483 return NULL;
17484 }
17485
17486
17487 static PyObject * BufferedPaintDC_swigregister(PyObject *, PyObject *args) {
17488 PyObject *obj;
17489 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17490 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedPaintDC, obj);
17491 Py_INCREF(obj);
17492 return Py_BuildValue((char *)"");
17493 }
17494 static PyObject *_wrap_new_ScreenDC(PyObject *, PyObject *args, PyObject *kwargs) {
17495 PyObject *resultobj;
17496 wxScreenDC *result;
17497 char *kwnames[] = {
17498 NULL
17499 };
17500
17501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ScreenDC",kwnames)) goto fail;
17502 {
17503 if (!wxPyCheckForApp()) SWIG_fail;
17504 PyThreadState* __tstate = wxPyBeginAllowThreads();
17505 result = (wxScreenDC *)new wxScreenDC();
17506
17507 wxPyEndAllowThreads(__tstate);
17508 if (PyErr_Occurred()) SWIG_fail;
17509 }
17510 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScreenDC, 1);
17511 return resultobj;
17512 fail:
17513 return NULL;
17514 }
17515
17516
17517 static PyObject *_wrap_ScreenDC_StartDrawingOnTopWin(PyObject *, PyObject *args, PyObject *kwargs) {
17518 PyObject *resultobj;
17519 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17520 wxWindow *arg2 = (wxWindow *) 0 ;
17521 bool result;
17522 PyObject * obj0 = 0 ;
17523 PyObject * obj1 = 0 ;
17524 char *kwnames[] = {
17525 (char *) "self",(char *) "window", NULL
17526 };
17527
17528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScreenDC_StartDrawingOnTopWin",kwnames,&obj0,&obj1)) goto fail;
17529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17530 if (SWIG_arg_fail(1)) SWIG_fail;
17531 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17532 if (SWIG_arg_fail(2)) SWIG_fail;
17533 {
17534 PyThreadState* __tstate = wxPyBeginAllowThreads();
17535 result = (bool)(arg1)->StartDrawingOnTop(arg2);
17536
17537 wxPyEndAllowThreads(__tstate);
17538 if (PyErr_Occurred()) SWIG_fail;
17539 }
17540 {
17541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17542 }
17543 return resultobj;
17544 fail:
17545 return NULL;
17546 }
17547
17548
17549 static PyObject *_wrap_ScreenDC_StartDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
17550 PyObject *resultobj;
17551 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17552 wxRect *arg2 = (wxRect *) NULL ;
17553 bool result;
17554 PyObject * obj0 = 0 ;
17555 PyObject * obj1 = 0 ;
17556 char *kwnames[] = {
17557 (char *) "self",(char *) "rect", NULL
17558 };
17559
17560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ScreenDC_StartDrawingOnTop",kwnames,&obj0,&obj1)) goto fail;
17561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17562 if (SWIG_arg_fail(1)) SWIG_fail;
17563 if (obj1) {
17564 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
17565 if (SWIG_arg_fail(2)) SWIG_fail;
17566 }
17567 {
17568 PyThreadState* __tstate = wxPyBeginAllowThreads();
17569 result = (bool)(arg1)->StartDrawingOnTop(arg2);
17570
17571 wxPyEndAllowThreads(__tstate);
17572 if (PyErr_Occurred()) SWIG_fail;
17573 }
17574 {
17575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17576 }
17577 return resultobj;
17578 fail:
17579 return NULL;
17580 }
17581
17582
17583 static PyObject *_wrap_ScreenDC_EndDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
17584 PyObject *resultobj;
17585 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17586 bool result;
17587 PyObject * obj0 = 0 ;
17588 char *kwnames[] = {
17589 (char *) "self", NULL
17590 };
17591
17592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScreenDC_EndDrawingOnTop",kwnames,&obj0)) goto fail;
17593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17594 if (SWIG_arg_fail(1)) SWIG_fail;
17595 {
17596 PyThreadState* __tstate = wxPyBeginAllowThreads();
17597 result = (bool)(arg1)->EndDrawingOnTop();
17598
17599 wxPyEndAllowThreads(__tstate);
17600 if (PyErr_Occurred()) SWIG_fail;
17601 }
17602 {
17603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17604 }
17605 return resultobj;
17606 fail:
17607 return NULL;
17608 }
17609
17610
17611 static PyObject * ScreenDC_swigregister(PyObject *, PyObject *args) {
17612 PyObject *obj;
17613 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17614 SWIG_TypeClientData(SWIGTYPE_p_wxScreenDC, obj);
17615 Py_INCREF(obj);
17616 return Py_BuildValue((char *)"");
17617 }
17618 static PyObject *_wrap_new_ClientDC(PyObject *, PyObject *args, PyObject *kwargs) {
17619 PyObject *resultobj;
17620 wxWindow *arg1 = (wxWindow *) 0 ;
17621 wxClientDC *result;
17622 PyObject * obj0 = 0 ;
17623 char *kwnames[] = {
17624 (char *) "win", NULL
17625 };
17626
17627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ClientDC",kwnames,&obj0)) goto fail;
17628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17629 if (SWIG_arg_fail(1)) SWIG_fail;
17630 {
17631 if (!wxPyCheckForApp()) SWIG_fail;
17632 PyThreadState* __tstate = wxPyBeginAllowThreads();
17633 result = (wxClientDC *)new wxClientDC(arg1);
17634
17635 wxPyEndAllowThreads(__tstate);
17636 if (PyErr_Occurred()) SWIG_fail;
17637 }
17638 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClientDC, 1);
17639 return resultobj;
17640 fail:
17641 return NULL;
17642 }
17643
17644
17645 static PyObject * ClientDC_swigregister(PyObject *, PyObject *args) {
17646 PyObject *obj;
17647 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17648 SWIG_TypeClientData(SWIGTYPE_p_wxClientDC, obj);
17649 Py_INCREF(obj);
17650 return Py_BuildValue((char *)"");
17651 }
17652 static PyObject *_wrap_new_PaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
17653 PyObject *resultobj;
17654 wxWindow *arg1 = (wxWindow *) 0 ;
17655 wxPaintDC *result;
17656 PyObject * obj0 = 0 ;
17657 char *kwnames[] = {
17658 (char *) "win", NULL
17659 };
17660
17661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PaintDC",kwnames,&obj0)) goto fail;
17662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17663 if (SWIG_arg_fail(1)) SWIG_fail;
17664 {
17665 if (!wxPyCheckForApp()) SWIG_fail;
17666 PyThreadState* __tstate = wxPyBeginAllowThreads();
17667 result = (wxPaintDC *)new wxPaintDC(arg1);
17668
17669 wxPyEndAllowThreads(__tstate);
17670 if (PyErr_Occurred()) SWIG_fail;
17671 }
17672 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintDC, 1);
17673 return resultobj;
17674 fail:
17675 return NULL;
17676 }
17677
17678
17679 static PyObject * PaintDC_swigregister(PyObject *, PyObject *args) {
17680 PyObject *obj;
17681 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17682 SWIG_TypeClientData(SWIGTYPE_p_wxPaintDC, obj);
17683 Py_INCREF(obj);
17684 return Py_BuildValue((char *)"");
17685 }
17686 static PyObject *_wrap_new_WindowDC(PyObject *, PyObject *args, PyObject *kwargs) {
17687 PyObject *resultobj;
17688 wxWindow *arg1 = (wxWindow *) 0 ;
17689 wxWindowDC *result;
17690 PyObject * obj0 = 0 ;
17691 char *kwnames[] = {
17692 (char *) "win", NULL
17693 };
17694
17695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_WindowDC",kwnames,&obj0)) goto fail;
17696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17697 if (SWIG_arg_fail(1)) SWIG_fail;
17698 {
17699 if (!wxPyCheckForApp()) SWIG_fail;
17700 PyThreadState* __tstate = wxPyBeginAllowThreads();
17701 result = (wxWindowDC *)new wxWindowDC(arg1);
17702
17703 wxPyEndAllowThreads(__tstate);
17704 if (PyErr_Occurred()) SWIG_fail;
17705 }
17706 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDC, 1);
17707 return resultobj;
17708 fail:
17709 return NULL;
17710 }
17711
17712
17713 static PyObject * WindowDC_swigregister(PyObject *, PyObject *args) {
17714 PyObject *obj;
17715 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17716 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDC, obj);
17717 Py_INCREF(obj);
17718 return Py_BuildValue((char *)"");
17719 }
17720 static PyObject *_wrap_new_MirrorDC(PyObject *, PyObject *args, PyObject *kwargs) {
17721 PyObject *resultobj;
17722 wxDC *arg1 = 0 ;
17723 bool arg2 ;
17724 wxMirrorDC *result;
17725 PyObject * obj0 = 0 ;
17726 PyObject * obj1 = 0 ;
17727 char *kwnames[] = {
17728 (char *) "dc",(char *) "mirror", NULL
17729 };
17730
17731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_MirrorDC",kwnames,&obj0,&obj1)) goto fail;
17732 {
17733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17734 if (SWIG_arg_fail(1)) SWIG_fail;
17735 if (arg1 == NULL) {
17736 SWIG_null_ref("wxDC");
17737 }
17738 if (SWIG_arg_fail(1)) SWIG_fail;
17739 }
17740 {
17741 arg2 = (bool)(SWIG_As_bool(obj1));
17742 if (SWIG_arg_fail(2)) SWIG_fail;
17743 }
17744 {
17745 if (!wxPyCheckForApp()) SWIG_fail;
17746 PyThreadState* __tstate = wxPyBeginAllowThreads();
17747 result = (wxMirrorDC *)new wxMirrorDC(*arg1,arg2);
17748
17749 wxPyEndAllowThreads(__tstate);
17750 if (PyErr_Occurred()) SWIG_fail;
17751 }
17752 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMirrorDC, 1);
17753 return resultobj;
17754 fail:
17755 return NULL;
17756 }
17757
17758
17759 static PyObject * MirrorDC_swigregister(PyObject *, PyObject *args) {
17760 PyObject *obj;
17761 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17762 SWIG_TypeClientData(SWIGTYPE_p_wxMirrorDC, obj);
17763 Py_INCREF(obj);
17764 return Py_BuildValue((char *)"");
17765 }
17766 static PyObject *_wrap_new_PostScriptDC(PyObject *, PyObject *args, PyObject *kwargs) {
17767 PyObject *resultobj;
17768 wxPrintData *arg1 = 0 ;
17769 wxPostScriptDC *result;
17770 PyObject * obj0 = 0 ;
17771 char *kwnames[] = {
17772 (char *) "printData", NULL
17773 };
17774
17775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PostScriptDC",kwnames,&obj0)) goto fail;
17776 {
17777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
17778 if (SWIG_arg_fail(1)) SWIG_fail;
17779 if (arg1 == NULL) {
17780 SWIG_null_ref("wxPrintData");
17781 }
17782 if (SWIG_arg_fail(1)) SWIG_fail;
17783 }
17784 {
17785 if (!wxPyCheckForApp()) SWIG_fail;
17786 PyThreadState* __tstate = wxPyBeginAllowThreads();
17787 result = (wxPostScriptDC *)new wxPostScriptDC((wxPrintData const &)*arg1);
17788
17789 wxPyEndAllowThreads(__tstate);
17790 if (PyErr_Occurred()) SWIG_fail;
17791 }
17792 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPostScriptDC, 1);
17793 return resultobj;
17794 fail:
17795 return NULL;
17796 }
17797
17798
17799 static PyObject *_wrap_PostScriptDC_GetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
17800 PyObject *resultobj;
17801 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
17802 wxPrintData *result;
17803 PyObject * obj0 = 0 ;
17804 char *kwnames[] = {
17805 (char *) "self", NULL
17806 };
17807
17808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_GetPrintData",kwnames,&obj0)) goto fail;
17809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
17810 if (SWIG_arg_fail(1)) SWIG_fail;
17811 {
17812 PyThreadState* __tstate = wxPyBeginAllowThreads();
17813 {
17814 wxPrintData &_result_ref = (arg1)->GetPrintData();
17815 result = (wxPrintData *) &_result_ref;
17816 }
17817
17818 wxPyEndAllowThreads(__tstate);
17819 if (PyErr_Occurred()) SWIG_fail;
17820 }
17821 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 0);
17822 return resultobj;
17823 fail:
17824 return NULL;
17825 }
17826
17827
17828 static PyObject *_wrap_PostScriptDC_SetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
17829 PyObject *resultobj;
17830 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
17831 wxPrintData *arg2 = 0 ;
17832 PyObject * obj0 = 0 ;
17833 PyObject * obj1 = 0 ;
17834 char *kwnames[] = {
17835 (char *) "self",(char *) "data", NULL
17836 };
17837
17838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostScriptDC_SetPrintData",kwnames,&obj0,&obj1)) goto fail;
17839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
17840 if (SWIG_arg_fail(1)) SWIG_fail;
17841 {
17842 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
17843 if (SWIG_arg_fail(2)) SWIG_fail;
17844 if (arg2 == NULL) {
17845 SWIG_null_ref("wxPrintData");
17846 }
17847 if (SWIG_arg_fail(2)) SWIG_fail;
17848 }
17849 {
17850 PyThreadState* __tstate = wxPyBeginAllowThreads();
17851 (arg1)->SetPrintData((wxPrintData const &)*arg2);
17852
17853 wxPyEndAllowThreads(__tstate);
17854 if (PyErr_Occurred()) SWIG_fail;
17855 }
17856 Py_INCREF(Py_None); resultobj = Py_None;
17857 return resultobj;
17858 fail:
17859 return NULL;
17860 }
17861
17862
17863 static PyObject *_wrap_PostScriptDC_SetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
17864 PyObject *resultobj;
17865 int arg1 ;
17866 PyObject * obj0 = 0 ;
17867 char *kwnames[] = {
17868 (char *) "ppi", NULL
17869 };
17870
17871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_SetResolution",kwnames,&obj0)) goto fail;
17872 {
17873 arg1 = (int)(SWIG_As_int(obj0));
17874 if (SWIG_arg_fail(1)) SWIG_fail;
17875 }
17876 {
17877 PyThreadState* __tstate = wxPyBeginAllowThreads();
17878 wxPostScriptDC::SetResolution(arg1);
17879
17880 wxPyEndAllowThreads(__tstate);
17881 if (PyErr_Occurred()) SWIG_fail;
17882 }
17883 Py_INCREF(Py_None); resultobj = Py_None;
17884 return resultobj;
17885 fail:
17886 return NULL;
17887 }
17888
17889
17890 static PyObject *_wrap_PostScriptDC_GetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
17891 PyObject *resultobj;
17892 int result;
17893 char *kwnames[] = {
17894 NULL
17895 };
17896
17897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PostScriptDC_GetResolution",kwnames)) goto fail;
17898 {
17899 PyThreadState* __tstate = wxPyBeginAllowThreads();
17900 result = (int)wxPostScriptDC::GetResolution();
17901
17902 wxPyEndAllowThreads(__tstate);
17903 if (PyErr_Occurred()) SWIG_fail;
17904 }
17905 {
17906 resultobj = SWIG_From_int((int)(result));
17907 }
17908 return resultobj;
17909 fail:
17910 return NULL;
17911 }
17912
17913
17914 static PyObject * PostScriptDC_swigregister(PyObject *, PyObject *args) {
17915 PyObject *obj;
17916 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17917 SWIG_TypeClientData(SWIGTYPE_p_wxPostScriptDC, obj);
17918 Py_INCREF(obj);
17919 return Py_BuildValue((char *)"");
17920 }
17921 static PyObject *_wrap_new_MetaFile(PyObject *, PyObject *args, PyObject *kwargs) {
17922 PyObject *resultobj;
17923 wxString const &arg1_defvalue = wxPyEmptyString ;
17924 wxString *arg1 = (wxString *) &arg1_defvalue ;
17925 wxMetaFile *result;
17926 bool temp1 = false ;
17927 PyObject * obj0 = 0 ;
17928 char *kwnames[] = {
17929 (char *) "filename", NULL
17930 };
17931
17932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MetaFile",kwnames,&obj0)) goto fail;
17933 if (obj0) {
17934 {
17935 arg1 = wxString_in_helper(obj0);
17936 if (arg1 == NULL) SWIG_fail;
17937 temp1 = true;
17938 }
17939 }
17940 {
17941 if (!wxPyCheckForApp()) SWIG_fail;
17942 PyThreadState* __tstate = wxPyBeginAllowThreads();
17943 result = (wxMetaFile *)new wxMetaFile((wxString const &)*arg1);
17944
17945 wxPyEndAllowThreads(__tstate);
17946 if (PyErr_Occurred()) SWIG_fail;
17947 }
17948 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFile, 1);
17949 {
17950 if (temp1)
17951 delete arg1;
17952 }
17953 return resultobj;
17954 fail:
17955 {
17956 if (temp1)
17957 delete arg1;
17958 }
17959 return NULL;
17960 }
17961
17962
17963 static PyObject * MetaFile_swigregister(PyObject *, PyObject *args) {
17964 PyObject *obj;
17965 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17966 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFile, obj);
17967 Py_INCREF(obj);
17968 return Py_BuildValue((char *)"");
17969 }
17970 static PyObject *_wrap_new_MetaFileDC(PyObject *, PyObject *args, PyObject *kwargs) {
17971 PyObject *resultobj;
17972 wxString const &arg1_defvalue = wxPyEmptyString ;
17973 wxString *arg1 = (wxString *) &arg1_defvalue ;
17974 int arg2 = (int) 0 ;
17975 int arg3 = (int) 0 ;
17976 wxString const &arg4_defvalue = wxPyEmptyString ;
17977 wxString *arg4 = (wxString *) &arg4_defvalue ;
17978 wxMetaFileDC *result;
17979 bool temp1 = false ;
17980 bool temp4 = false ;
17981 PyObject * obj0 = 0 ;
17982 PyObject * obj1 = 0 ;
17983 PyObject * obj2 = 0 ;
17984 PyObject * obj3 = 0 ;
17985 char *kwnames[] = {
17986 (char *) "filename",(char *) "width",(char *) "height",(char *) "description", NULL
17987 };
17988
17989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_MetaFileDC",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17990 if (obj0) {
17991 {
17992 arg1 = wxString_in_helper(obj0);
17993 if (arg1 == NULL) SWIG_fail;
17994 temp1 = true;
17995 }
17996 }
17997 if (obj1) {
17998 {
17999 arg2 = (int)(SWIG_As_int(obj1));
18000 if (SWIG_arg_fail(2)) SWIG_fail;
18001 }
18002 }
18003 if (obj2) {
18004 {
18005 arg3 = (int)(SWIG_As_int(obj2));
18006 if (SWIG_arg_fail(3)) SWIG_fail;
18007 }
18008 }
18009 if (obj3) {
18010 {
18011 arg4 = wxString_in_helper(obj3);
18012 if (arg4 == NULL) SWIG_fail;
18013 temp4 = true;
18014 }
18015 }
18016 {
18017 if (!wxPyCheckForApp()) SWIG_fail;
18018 PyThreadState* __tstate = wxPyBeginAllowThreads();
18019 result = (wxMetaFileDC *)new wxMetaFileDC((wxString const &)*arg1,arg2,arg3,(wxString const &)*arg4);
18020
18021 wxPyEndAllowThreads(__tstate);
18022 if (PyErr_Occurred()) SWIG_fail;
18023 }
18024 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFileDC, 1);
18025 {
18026 if (temp1)
18027 delete arg1;
18028 }
18029 {
18030 if (temp4)
18031 delete arg4;
18032 }
18033 return resultobj;
18034 fail:
18035 {
18036 if (temp1)
18037 delete arg1;
18038 }
18039 {
18040 if (temp4)
18041 delete arg4;
18042 }
18043 return NULL;
18044 }
18045
18046
18047 static PyObject * MetaFileDC_swigregister(PyObject *, PyObject *args) {
18048 PyObject *obj;
18049 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18050 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFileDC, obj);
18051 Py_INCREF(obj);
18052 return Py_BuildValue((char *)"");
18053 }
18054 static PyObject *_wrap_new_PrinterDC(PyObject *, PyObject *args, PyObject *kwargs) {
18055 PyObject *resultobj;
18056 wxPrintData *arg1 = 0 ;
18057 wxPrinterDC *result;
18058 PyObject * obj0 = 0 ;
18059 char *kwnames[] = {
18060 (char *) "printData", NULL
18061 };
18062
18063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PrinterDC",kwnames,&obj0)) goto fail;
18064 {
18065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
18066 if (SWIG_arg_fail(1)) SWIG_fail;
18067 if (arg1 == NULL) {
18068 SWIG_null_ref("wxPrintData");
18069 }
18070 if (SWIG_arg_fail(1)) SWIG_fail;
18071 }
18072 {
18073 if (!wxPyCheckForApp()) SWIG_fail;
18074 PyThreadState* __tstate = wxPyBeginAllowThreads();
18075 result = (wxPrinterDC *)new wxPrinterDC((wxPrintData const &)*arg1);
18076
18077 wxPyEndAllowThreads(__tstate);
18078 if (PyErr_Occurred()) SWIG_fail;
18079 }
18080 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrinterDC, 1);
18081 return resultobj;
18082 fail:
18083 return NULL;
18084 }
18085
18086
18087 static PyObject * PrinterDC_swigregister(PyObject *, PyObject *args) {
18088 PyObject *obj;
18089 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18090 SWIG_TypeClientData(SWIGTYPE_p_wxPrinterDC, obj);
18091 Py_INCREF(obj);
18092 return Py_BuildValue((char *)"");
18093 }
18094 static PyObject *_wrap_new_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
18095 PyObject *resultobj;
18096 int arg1 ;
18097 int arg2 ;
18098 int arg3 = (int) true ;
18099 int arg4 = (int) 1 ;
18100 wxImageList *result;
18101 PyObject * obj0 = 0 ;
18102 PyObject * obj1 = 0 ;
18103 PyObject * obj2 = 0 ;
18104 PyObject * obj3 = 0 ;
18105 char *kwnames[] = {
18106 (char *) "width",(char *) "height",(char *) "mask",(char *) "initialCount", NULL
18107 };
18108
18109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_ImageList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
18110 {
18111 arg1 = (int)(SWIG_As_int(obj0));
18112 if (SWIG_arg_fail(1)) SWIG_fail;
18113 }
18114 {
18115 arg2 = (int)(SWIG_As_int(obj1));
18116 if (SWIG_arg_fail(2)) SWIG_fail;
18117 }
18118 if (obj2) {
18119 {
18120 arg3 = (int)(SWIG_As_int(obj2));
18121 if (SWIG_arg_fail(3)) SWIG_fail;
18122 }
18123 }
18124 if (obj3) {
18125 {
18126 arg4 = (int)(SWIG_As_int(obj3));
18127 if (SWIG_arg_fail(4)) SWIG_fail;
18128 }
18129 }
18130 {
18131 if (!wxPyCheckForApp()) SWIG_fail;
18132 PyThreadState* __tstate = wxPyBeginAllowThreads();
18133 result = (wxImageList *)new wxImageList(arg1,arg2,arg3,arg4);
18134
18135 wxPyEndAllowThreads(__tstate);
18136 if (PyErr_Occurred()) SWIG_fail;
18137 }
18138 {
18139 resultobj = wxPyMake_wxObject(result, 1);
18140 }
18141 return resultobj;
18142 fail:
18143 return NULL;
18144 }
18145
18146
18147 static PyObject *_wrap_delete_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
18148 PyObject *resultobj;
18149 wxImageList *arg1 = (wxImageList *) 0 ;
18150 PyObject * obj0 = 0 ;
18151 char *kwnames[] = {
18152 (char *) "self", NULL
18153 };
18154
18155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ImageList",kwnames,&obj0)) goto fail;
18156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18157 if (SWIG_arg_fail(1)) SWIG_fail;
18158 {
18159 PyThreadState* __tstate = wxPyBeginAllowThreads();
18160 delete arg1;
18161
18162 wxPyEndAllowThreads(__tstate);
18163 if (PyErr_Occurred()) SWIG_fail;
18164 }
18165 Py_INCREF(Py_None); resultobj = Py_None;
18166 return resultobj;
18167 fail:
18168 return NULL;
18169 }
18170
18171
18172 static PyObject *_wrap_ImageList_Add(PyObject *, PyObject *args, PyObject *kwargs) {
18173 PyObject *resultobj;
18174 wxImageList *arg1 = (wxImageList *) 0 ;
18175 wxBitmap *arg2 = 0 ;
18176 wxBitmap const &arg3_defvalue = wxNullBitmap ;
18177 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
18178 int result;
18179 PyObject * obj0 = 0 ;
18180 PyObject * obj1 = 0 ;
18181 PyObject * obj2 = 0 ;
18182 char *kwnames[] = {
18183 (char *) "self",(char *) "bitmap",(char *) "mask", NULL
18184 };
18185
18186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ImageList_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
18187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18188 if (SWIG_arg_fail(1)) SWIG_fail;
18189 {
18190 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18191 if (SWIG_arg_fail(2)) SWIG_fail;
18192 if (arg2 == NULL) {
18193 SWIG_null_ref("wxBitmap");
18194 }
18195 if (SWIG_arg_fail(2)) SWIG_fail;
18196 }
18197 if (obj2) {
18198 {
18199 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18200 if (SWIG_arg_fail(3)) SWIG_fail;
18201 if (arg3 == NULL) {
18202 SWIG_null_ref("wxBitmap");
18203 }
18204 if (SWIG_arg_fail(3)) SWIG_fail;
18205 }
18206 }
18207 {
18208 PyThreadState* __tstate = wxPyBeginAllowThreads();
18209 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
18210
18211 wxPyEndAllowThreads(__tstate);
18212 if (PyErr_Occurred()) SWIG_fail;
18213 }
18214 {
18215 resultobj = SWIG_From_int((int)(result));
18216 }
18217 return resultobj;
18218 fail:
18219 return NULL;
18220 }
18221
18222
18223 static PyObject *_wrap_ImageList_AddWithColourMask(PyObject *, PyObject *args, PyObject *kwargs) {
18224 PyObject *resultobj;
18225 wxImageList *arg1 = (wxImageList *) 0 ;
18226 wxBitmap *arg2 = 0 ;
18227 wxColour *arg3 = 0 ;
18228 int result;
18229 wxColour temp3 ;
18230 PyObject * obj0 = 0 ;
18231 PyObject * obj1 = 0 ;
18232 PyObject * obj2 = 0 ;
18233 char *kwnames[] = {
18234 (char *) "self",(char *) "bitmap",(char *) "maskColour", NULL
18235 };
18236
18237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_AddWithColourMask",kwnames,&obj0,&obj1,&obj2)) goto fail;
18238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18239 if (SWIG_arg_fail(1)) SWIG_fail;
18240 {
18241 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18242 if (SWIG_arg_fail(2)) SWIG_fail;
18243 if (arg2 == NULL) {
18244 SWIG_null_ref("wxBitmap");
18245 }
18246 if (SWIG_arg_fail(2)) SWIG_fail;
18247 }
18248 {
18249 arg3 = &temp3;
18250 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
18251 }
18252 {
18253 PyThreadState* __tstate = wxPyBeginAllowThreads();
18254 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxColour const &)*arg3);
18255
18256 wxPyEndAllowThreads(__tstate);
18257 if (PyErr_Occurred()) SWIG_fail;
18258 }
18259 {
18260 resultobj = SWIG_From_int((int)(result));
18261 }
18262 return resultobj;
18263 fail:
18264 return NULL;
18265 }
18266
18267
18268 static PyObject *_wrap_ImageList_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
18269 PyObject *resultobj;
18270 wxImageList *arg1 = (wxImageList *) 0 ;
18271 wxIcon *arg2 = 0 ;
18272 int result;
18273 PyObject * obj0 = 0 ;
18274 PyObject * obj1 = 0 ;
18275 char *kwnames[] = {
18276 (char *) "self",(char *) "icon", NULL
18277 };
18278
18279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_AddIcon",kwnames,&obj0,&obj1)) goto fail;
18280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18281 if (SWIG_arg_fail(1)) SWIG_fail;
18282 {
18283 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
18284 if (SWIG_arg_fail(2)) SWIG_fail;
18285 if (arg2 == NULL) {
18286 SWIG_null_ref("wxIcon");
18287 }
18288 if (SWIG_arg_fail(2)) SWIG_fail;
18289 }
18290 {
18291 PyThreadState* __tstate = wxPyBeginAllowThreads();
18292 result = (int)(arg1)->Add((wxIcon const &)*arg2);
18293
18294 wxPyEndAllowThreads(__tstate);
18295 if (PyErr_Occurred()) SWIG_fail;
18296 }
18297 {
18298 resultobj = SWIG_From_int((int)(result));
18299 }
18300 return resultobj;
18301 fail:
18302 return NULL;
18303 }
18304
18305
18306 static PyObject *_wrap_ImageList_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
18307 PyObject *resultobj;
18308 wxImageList *arg1 = (wxImageList *) 0 ;
18309 int arg2 ;
18310 SwigValueWrapper<wxBitmap > result;
18311 PyObject * obj0 = 0 ;
18312 PyObject * obj1 = 0 ;
18313 char *kwnames[] = {
18314 (char *) "self",(char *) "index", NULL
18315 };
18316
18317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetBitmap",kwnames,&obj0,&obj1)) goto fail;
18318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18319 if (SWIG_arg_fail(1)) SWIG_fail;
18320 {
18321 arg2 = (int)(SWIG_As_int(obj1));
18322 if (SWIG_arg_fail(2)) SWIG_fail;
18323 }
18324 {
18325 PyThreadState* __tstate = wxPyBeginAllowThreads();
18326 result = ((wxImageList const *)arg1)->GetBitmap(arg2);
18327
18328 wxPyEndAllowThreads(__tstate);
18329 if (PyErr_Occurred()) SWIG_fail;
18330 }
18331 {
18332 wxBitmap * resultptr;
18333 resultptr = new wxBitmap((wxBitmap &)(result));
18334 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
18335 }
18336 return resultobj;
18337 fail:
18338 return NULL;
18339 }
18340
18341
18342 static PyObject *_wrap_ImageList_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
18343 PyObject *resultobj;
18344 wxImageList *arg1 = (wxImageList *) 0 ;
18345 int arg2 ;
18346 wxIcon result;
18347 PyObject * obj0 = 0 ;
18348 PyObject * obj1 = 0 ;
18349 char *kwnames[] = {
18350 (char *) "self",(char *) "index", NULL
18351 };
18352
18353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetIcon",kwnames,&obj0,&obj1)) goto fail;
18354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18355 if (SWIG_arg_fail(1)) SWIG_fail;
18356 {
18357 arg2 = (int)(SWIG_As_int(obj1));
18358 if (SWIG_arg_fail(2)) SWIG_fail;
18359 }
18360 {
18361 PyThreadState* __tstate = wxPyBeginAllowThreads();
18362 result = ((wxImageList const *)arg1)->GetIcon(arg2);
18363
18364 wxPyEndAllowThreads(__tstate);
18365 if (PyErr_Occurred()) SWIG_fail;
18366 }
18367 {
18368 wxIcon * resultptr;
18369 resultptr = new wxIcon((wxIcon &)(result));
18370 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
18371 }
18372 return resultobj;
18373 fail:
18374 return NULL;
18375 }
18376
18377
18378 static PyObject *_wrap_ImageList_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
18379 PyObject *resultobj;
18380 wxImageList *arg1 = (wxImageList *) 0 ;
18381 int arg2 ;
18382 wxBitmap *arg3 = 0 ;
18383 bool result;
18384 PyObject * obj0 = 0 ;
18385 PyObject * obj1 = 0 ;
18386 PyObject * obj2 = 0 ;
18387 char *kwnames[] = {
18388 (char *) "self",(char *) "index",(char *) "bitmap", NULL
18389 };
18390
18391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_Replace",kwnames,&obj0,&obj1,&obj2)) goto fail;
18392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18393 if (SWIG_arg_fail(1)) SWIG_fail;
18394 {
18395 arg2 = (int)(SWIG_As_int(obj1));
18396 if (SWIG_arg_fail(2)) SWIG_fail;
18397 }
18398 {
18399 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18400 if (SWIG_arg_fail(3)) SWIG_fail;
18401 if (arg3 == NULL) {
18402 SWIG_null_ref("wxBitmap");
18403 }
18404 if (SWIG_arg_fail(3)) SWIG_fail;
18405 }
18406 {
18407 PyThreadState* __tstate = wxPyBeginAllowThreads();
18408 result = (bool)(arg1)->Replace(arg2,(wxBitmap const &)*arg3);
18409
18410 wxPyEndAllowThreads(__tstate);
18411 if (PyErr_Occurred()) SWIG_fail;
18412 }
18413 {
18414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18415 }
18416 return resultobj;
18417 fail:
18418 return NULL;
18419 }
18420
18421
18422 static PyObject *_wrap_ImageList_Draw(PyObject *, PyObject *args, PyObject *kwargs) {
18423 PyObject *resultobj;
18424 wxImageList *arg1 = (wxImageList *) 0 ;
18425 int arg2 ;
18426 wxDC *arg3 = 0 ;
18427 int arg4 ;
18428 int arg5 ;
18429 int arg6 = (int) wxIMAGELIST_DRAW_NORMAL ;
18430 bool arg7 = (bool) (bool)false ;
18431 bool result;
18432 PyObject * obj0 = 0 ;
18433 PyObject * obj1 = 0 ;
18434 PyObject * obj2 = 0 ;
18435 PyObject * obj3 = 0 ;
18436 PyObject * obj4 = 0 ;
18437 PyObject * obj5 = 0 ;
18438 PyObject * obj6 = 0 ;
18439 char *kwnames[] = {
18440 (char *) "self",(char *) "index",(char *) "dc",(char *) "x",(char *) "x",(char *) "flags",(char *) "solidBackground", NULL
18441 };
18442
18443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OO:ImageList_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
18444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18445 if (SWIG_arg_fail(1)) SWIG_fail;
18446 {
18447 arg2 = (int)(SWIG_As_int(obj1));
18448 if (SWIG_arg_fail(2)) SWIG_fail;
18449 }
18450 {
18451 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
18452 if (SWIG_arg_fail(3)) SWIG_fail;
18453 if (arg3 == NULL) {
18454 SWIG_null_ref("wxDC");
18455 }
18456 if (SWIG_arg_fail(3)) SWIG_fail;
18457 }
18458 {
18459 arg4 = (int)(SWIG_As_int(obj3));
18460 if (SWIG_arg_fail(4)) SWIG_fail;
18461 }
18462 {
18463 arg5 = (int)(SWIG_As_int(obj4));
18464 if (SWIG_arg_fail(5)) SWIG_fail;
18465 }
18466 if (obj5) {
18467 {
18468 arg6 = (int)(SWIG_As_int(obj5));
18469 if (SWIG_arg_fail(6)) SWIG_fail;
18470 }
18471 }
18472 if (obj6) {
18473 {
18474 arg7 = (bool const)(SWIG_As_bool(obj6));
18475 if (SWIG_arg_fail(7)) SWIG_fail;
18476 }
18477 }
18478 {
18479 PyThreadState* __tstate = wxPyBeginAllowThreads();
18480 result = (bool)(arg1)->Draw(arg2,*arg3,arg4,arg5,arg6,arg7);
18481
18482 wxPyEndAllowThreads(__tstate);
18483 if (PyErr_Occurred()) SWIG_fail;
18484 }
18485 {
18486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18487 }
18488 return resultobj;
18489 fail:
18490 return NULL;
18491 }
18492
18493
18494 static PyObject *_wrap_ImageList_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
18495 PyObject *resultobj;
18496 wxImageList *arg1 = (wxImageList *) 0 ;
18497 int result;
18498 PyObject * obj0 = 0 ;
18499 char *kwnames[] = {
18500 (char *) "self", NULL
18501 };
18502
18503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_GetImageCount",kwnames,&obj0)) goto fail;
18504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18505 if (SWIG_arg_fail(1)) SWIG_fail;
18506 {
18507 PyThreadState* __tstate = wxPyBeginAllowThreads();
18508 result = (int)(arg1)->GetImageCount();
18509
18510 wxPyEndAllowThreads(__tstate);
18511 if (PyErr_Occurred()) SWIG_fail;
18512 }
18513 {
18514 resultobj = SWIG_From_int((int)(result));
18515 }
18516 return resultobj;
18517 fail:
18518 return NULL;
18519 }
18520
18521
18522 static PyObject *_wrap_ImageList_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
18523 PyObject *resultobj;
18524 wxImageList *arg1 = (wxImageList *) 0 ;
18525 int arg2 ;
18526 bool result;
18527 PyObject * obj0 = 0 ;
18528 PyObject * obj1 = 0 ;
18529 char *kwnames[] = {
18530 (char *) "self",(char *) "index", NULL
18531 };
18532
18533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_Remove",kwnames,&obj0,&obj1)) goto fail;
18534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18535 if (SWIG_arg_fail(1)) SWIG_fail;
18536 {
18537 arg2 = (int)(SWIG_As_int(obj1));
18538 if (SWIG_arg_fail(2)) SWIG_fail;
18539 }
18540 {
18541 PyThreadState* __tstate = wxPyBeginAllowThreads();
18542 result = (bool)(arg1)->Remove(arg2);
18543
18544 wxPyEndAllowThreads(__tstate);
18545 if (PyErr_Occurred()) SWIG_fail;
18546 }
18547 {
18548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18549 }
18550 return resultobj;
18551 fail:
18552 return NULL;
18553 }
18554
18555
18556 static PyObject *_wrap_ImageList_RemoveAll(PyObject *, PyObject *args, PyObject *kwargs) {
18557 PyObject *resultobj;
18558 wxImageList *arg1 = (wxImageList *) 0 ;
18559 bool result;
18560 PyObject * obj0 = 0 ;
18561 char *kwnames[] = {
18562 (char *) "self", NULL
18563 };
18564
18565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_RemoveAll",kwnames,&obj0)) goto fail;
18566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18567 if (SWIG_arg_fail(1)) SWIG_fail;
18568 {
18569 PyThreadState* __tstate = wxPyBeginAllowThreads();
18570 result = (bool)(arg1)->RemoveAll();
18571
18572 wxPyEndAllowThreads(__tstate);
18573 if (PyErr_Occurred()) SWIG_fail;
18574 }
18575 {
18576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18577 }
18578 return resultobj;
18579 fail:
18580 return NULL;
18581 }
18582
18583
18584 static PyObject *_wrap_ImageList_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18585 PyObject *resultobj;
18586 wxImageList *arg1 = (wxImageList *) 0 ;
18587 int arg2 ;
18588 int *arg3 = 0 ;
18589 int *arg4 = 0 ;
18590 int temp3 ;
18591 int res3 = 0 ;
18592 int temp4 ;
18593 int res4 = 0 ;
18594 PyObject * obj0 = 0 ;
18595 PyObject * obj1 = 0 ;
18596 char *kwnames[] = {
18597 (char *) "self",(char *) "index", NULL
18598 };
18599
18600 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18601 arg4 = &temp4; res4 = SWIG_NEWOBJ;
18602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetSize",kwnames,&obj0,&obj1)) goto fail;
18603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18604 if (SWIG_arg_fail(1)) SWIG_fail;
18605 {
18606 arg2 = (int)(SWIG_As_int(obj1));
18607 if (SWIG_arg_fail(2)) SWIG_fail;
18608 }
18609 {
18610 PyThreadState* __tstate = wxPyBeginAllowThreads();
18611 (arg1)->GetSize(arg2,*arg3,*arg4);
18612
18613 wxPyEndAllowThreads(__tstate);
18614 if (PyErr_Occurred()) SWIG_fail;
18615 }
18616 Py_INCREF(Py_None); resultobj = Py_None;
18617 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18618 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
18619 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
18620 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
18621 return resultobj;
18622 fail:
18623 return NULL;
18624 }
18625
18626
18627 static PyObject * ImageList_swigregister(PyObject *, PyObject *args) {
18628 PyObject *obj;
18629 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18630 SWIG_TypeClientData(SWIGTYPE_p_wxImageList, obj);
18631 Py_INCREF(obj);
18632 return Py_BuildValue((char *)"");
18633 }
18634 static int _wrap_NORMAL_FONT_set(PyObject *) {
18635 PyErr_SetString(PyExc_TypeError,"Variable NORMAL_FONT is read-only.");
18636 return 1;
18637 }
18638
18639
18640 static PyObject *_wrap_NORMAL_FONT_get(void) {
18641 PyObject *pyobj;
18642
18643 pyobj = SWIG_NewPointerObj((void *)(wxNORMAL_FONT), SWIGTYPE_p_wxFont, 0);
18644 return pyobj;
18645 }
18646
18647
18648 static int _wrap_SMALL_FONT_set(PyObject *) {
18649 PyErr_SetString(PyExc_TypeError,"Variable SMALL_FONT is read-only.");
18650 return 1;
18651 }
18652
18653
18654 static PyObject *_wrap_SMALL_FONT_get(void) {
18655 PyObject *pyobj;
18656
18657 pyobj = SWIG_NewPointerObj((void *)(wxSMALL_FONT), SWIGTYPE_p_wxFont, 0);
18658 return pyobj;
18659 }
18660
18661
18662 static int _wrap_ITALIC_FONT_set(PyObject *) {
18663 PyErr_SetString(PyExc_TypeError,"Variable ITALIC_FONT is read-only.");
18664 return 1;
18665 }
18666
18667
18668 static PyObject *_wrap_ITALIC_FONT_get(void) {
18669 PyObject *pyobj;
18670
18671 pyobj = SWIG_NewPointerObj((void *)(wxITALIC_FONT), SWIGTYPE_p_wxFont, 0);
18672 return pyobj;
18673 }
18674
18675
18676 static int _wrap_SWISS_FONT_set(PyObject *) {
18677 PyErr_SetString(PyExc_TypeError,"Variable SWISS_FONT is read-only.");
18678 return 1;
18679 }
18680
18681
18682 static PyObject *_wrap_SWISS_FONT_get(void) {
18683 PyObject *pyobj;
18684
18685 pyobj = SWIG_NewPointerObj((void *)(wxSWISS_FONT), SWIGTYPE_p_wxFont, 0);
18686 return pyobj;
18687 }
18688
18689
18690 static int _wrap_RED_PEN_set(PyObject *) {
18691 PyErr_SetString(PyExc_TypeError,"Variable RED_PEN is read-only.");
18692 return 1;
18693 }
18694
18695
18696 static PyObject *_wrap_RED_PEN_get(void) {
18697 PyObject *pyobj;
18698
18699 pyobj = SWIG_NewPointerObj((void *)(wxRED_PEN), SWIGTYPE_p_wxPen, 0);
18700 return pyobj;
18701 }
18702
18703
18704 static int _wrap_CYAN_PEN_set(PyObject *) {
18705 PyErr_SetString(PyExc_TypeError,"Variable CYAN_PEN is read-only.");
18706 return 1;
18707 }
18708
18709
18710 static PyObject *_wrap_CYAN_PEN_get(void) {
18711 PyObject *pyobj;
18712
18713 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_PEN), SWIGTYPE_p_wxPen, 0);
18714 return pyobj;
18715 }
18716
18717
18718 static int _wrap_GREEN_PEN_set(PyObject *) {
18719 PyErr_SetString(PyExc_TypeError,"Variable GREEN_PEN is read-only.");
18720 return 1;
18721 }
18722
18723
18724 static PyObject *_wrap_GREEN_PEN_get(void) {
18725 PyObject *pyobj;
18726
18727 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_PEN), SWIGTYPE_p_wxPen, 0);
18728 return pyobj;
18729 }
18730
18731
18732 static int _wrap_BLACK_PEN_set(PyObject *) {
18733 PyErr_SetString(PyExc_TypeError,"Variable BLACK_PEN is read-only.");
18734 return 1;
18735 }
18736
18737
18738 static PyObject *_wrap_BLACK_PEN_get(void) {
18739 PyObject *pyobj;
18740
18741 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_PEN), SWIGTYPE_p_wxPen, 0);
18742 return pyobj;
18743 }
18744
18745
18746 static int _wrap_WHITE_PEN_set(PyObject *) {
18747 PyErr_SetString(PyExc_TypeError,"Variable WHITE_PEN is read-only.");
18748 return 1;
18749 }
18750
18751
18752 static PyObject *_wrap_WHITE_PEN_get(void) {
18753 PyObject *pyobj;
18754
18755 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_PEN), SWIGTYPE_p_wxPen, 0);
18756 return pyobj;
18757 }
18758
18759
18760 static int _wrap_TRANSPARENT_PEN_set(PyObject *) {
18761 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_PEN is read-only.");
18762 return 1;
18763 }
18764
18765
18766 static PyObject *_wrap_TRANSPARENT_PEN_get(void) {
18767 PyObject *pyobj;
18768
18769 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_PEN), SWIGTYPE_p_wxPen, 0);
18770 return pyobj;
18771 }
18772
18773
18774 static int _wrap_BLACK_DASHED_PEN_set(PyObject *) {
18775 PyErr_SetString(PyExc_TypeError,"Variable BLACK_DASHED_PEN is read-only.");
18776 return 1;
18777 }
18778
18779
18780 static PyObject *_wrap_BLACK_DASHED_PEN_get(void) {
18781 PyObject *pyobj;
18782
18783 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_DASHED_PEN), SWIGTYPE_p_wxPen, 0);
18784 return pyobj;
18785 }
18786
18787
18788 static int _wrap_GREY_PEN_set(PyObject *) {
18789 PyErr_SetString(PyExc_TypeError,"Variable GREY_PEN is read-only.");
18790 return 1;
18791 }
18792
18793
18794 static PyObject *_wrap_GREY_PEN_get(void) {
18795 PyObject *pyobj;
18796
18797 pyobj = SWIG_NewPointerObj((void *)(wxGREY_PEN), SWIGTYPE_p_wxPen, 0);
18798 return pyobj;
18799 }
18800
18801
18802 static int _wrap_MEDIUM_GREY_PEN_set(PyObject *) {
18803 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_PEN is read-only.");
18804 return 1;
18805 }
18806
18807
18808 static PyObject *_wrap_MEDIUM_GREY_PEN_get(void) {
18809 PyObject *pyobj;
18810
18811 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_PEN), SWIGTYPE_p_wxPen, 0);
18812 return pyobj;
18813 }
18814
18815
18816 static int _wrap_LIGHT_GREY_PEN_set(PyObject *) {
18817 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_PEN is read-only.");
18818 return 1;
18819 }
18820
18821
18822 static PyObject *_wrap_LIGHT_GREY_PEN_get(void) {
18823 PyObject *pyobj;
18824
18825 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_PEN), SWIGTYPE_p_wxPen, 0);
18826 return pyobj;
18827 }
18828
18829
18830 static int _wrap_BLUE_BRUSH_set(PyObject *) {
18831 PyErr_SetString(PyExc_TypeError,"Variable BLUE_BRUSH is read-only.");
18832 return 1;
18833 }
18834
18835
18836 static PyObject *_wrap_BLUE_BRUSH_get(void) {
18837 PyObject *pyobj;
18838
18839 pyobj = SWIG_NewPointerObj((void *)(wxBLUE_BRUSH), SWIGTYPE_p_wxBrush, 0);
18840 return pyobj;
18841 }
18842
18843
18844 static int _wrap_GREEN_BRUSH_set(PyObject *) {
18845 PyErr_SetString(PyExc_TypeError,"Variable GREEN_BRUSH is read-only.");
18846 return 1;
18847 }
18848
18849
18850 static PyObject *_wrap_GREEN_BRUSH_get(void) {
18851 PyObject *pyobj;
18852
18853 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_BRUSH), SWIGTYPE_p_wxBrush, 0);
18854 return pyobj;
18855 }
18856
18857
18858 static int _wrap_WHITE_BRUSH_set(PyObject *) {
18859 PyErr_SetString(PyExc_TypeError,"Variable WHITE_BRUSH is read-only.");
18860 return 1;
18861 }
18862
18863
18864 static PyObject *_wrap_WHITE_BRUSH_get(void) {
18865 PyObject *pyobj;
18866
18867 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_BRUSH), SWIGTYPE_p_wxBrush, 0);
18868 return pyobj;
18869 }
18870
18871
18872 static int _wrap_BLACK_BRUSH_set(PyObject *) {
18873 PyErr_SetString(PyExc_TypeError,"Variable BLACK_BRUSH is read-only.");
18874 return 1;
18875 }
18876
18877
18878 static PyObject *_wrap_BLACK_BRUSH_get(void) {
18879 PyObject *pyobj;
18880
18881 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_BRUSH), SWIGTYPE_p_wxBrush, 0);
18882 return pyobj;
18883 }
18884
18885
18886 static int _wrap_TRANSPARENT_BRUSH_set(PyObject *) {
18887 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_BRUSH is read-only.");
18888 return 1;
18889 }
18890
18891
18892 static PyObject *_wrap_TRANSPARENT_BRUSH_get(void) {
18893 PyObject *pyobj;
18894
18895 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_BRUSH), SWIGTYPE_p_wxBrush, 0);
18896 return pyobj;
18897 }
18898
18899
18900 static int _wrap_CYAN_BRUSH_set(PyObject *) {
18901 PyErr_SetString(PyExc_TypeError,"Variable CYAN_BRUSH is read-only.");
18902 return 1;
18903 }
18904
18905
18906 static PyObject *_wrap_CYAN_BRUSH_get(void) {
18907 PyObject *pyobj;
18908
18909 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_BRUSH), SWIGTYPE_p_wxBrush, 0);
18910 return pyobj;
18911 }
18912
18913
18914 static int _wrap_RED_BRUSH_set(PyObject *) {
18915 PyErr_SetString(PyExc_TypeError,"Variable RED_BRUSH is read-only.");
18916 return 1;
18917 }
18918
18919
18920 static PyObject *_wrap_RED_BRUSH_get(void) {
18921 PyObject *pyobj;
18922
18923 pyobj = SWIG_NewPointerObj((void *)(wxRED_BRUSH), SWIGTYPE_p_wxBrush, 0);
18924 return pyobj;
18925 }
18926
18927
18928 static int _wrap_GREY_BRUSH_set(PyObject *) {
18929 PyErr_SetString(PyExc_TypeError,"Variable GREY_BRUSH is read-only.");
18930 return 1;
18931 }
18932
18933
18934 static PyObject *_wrap_GREY_BRUSH_get(void) {
18935 PyObject *pyobj;
18936
18937 pyobj = SWIG_NewPointerObj((void *)(wxGREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
18938 return pyobj;
18939 }
18940
18941
18942 static int _wrap_MEDIUM_GREY_BRUSH_set(PyObject *) {
18943 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_BRUSH is read-only.");
18944 return 1;
18945 }
18946
18947
18948 static PyObject *_wrap_MEDIUM_GREY_BRUSH_get(void) {
18949 PyObject *pyobj;
18950
18951 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
18952 return pyobj;
18953 }
18954
18955
18956 static int _wrap_LIGHT_GREY_BRUSH_set(PyObject *) {
18957 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_BRUSH is read-only.");
18958 return 1;
18959 }
18960
18961
18962 static PyObject *_wrap_LIGHT_GREY_BRUSH_get(void) {
18963 PyObject *pyobj;
18964
18965 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
18966 return pyobj;
18967 }
18968
18969
18970 static int _wrap_BLACK_set(PyObject *) {
18971 PyErr_SetString(PyExc_TypeError,"Variable BLACK is read-only.");
18972 return 1;
18973 }
18974
18975
18976 static PyObject *_wrap_BLACK_get(void) {
18977 PyObject *pyobj;
18978
18979 pyobj = SWIG_NewPointerObj((void *)(wxBLACK), SWIGTYPE_p_wxColour, 0);
18980 return pyobj;
18981 }
18982
18983
18984 static int _wrap_WHITE_set(PyObject *) {
18985 PyErr_SetString(PyExc_TypeError,"Variable WHITE is read-only.");
18986 return 1;
18987 }
18988
18989
18990 static PyObject *_wrap_WHITE_get(void) {
18991 PyObject *pyobj;
18992
18993 pyobj = SWIG_NewPointerObj((void *)(wxWHITE), SWIGTYPE_p_wxColour, 0);
18994 return pyobj;
18995 }
18996
18997
18998 static int _wrap_RED_set(PyObject *) {
18999 PyErr_SetString(PyExc_TypeError,"Variable RED is read-only.");
19000 return 1;
19001 }
19002
19003
19004 static PyObject *_wrap_RED_get(void) {
19005 PyObject *pyobj;
19006
19007 pyobj = SWIG_NewPointerObj((void *)(wxRED), SWIGTYPE_p_wxColour, 0);
19008 return pyobj;
19009 }
19010
19011
19012 static int _wrap_BLUE_set(PyObject *) {
19013 PyErr_SetString(PyExc_TypeError,"Variable BLUE is read-only.");
19014 return 1;
19015 }
19016
19017
19018 static PyObject *_wrap_BLUE_get(void) {
19019 PyObject *pyobj;
19020
19021 pyobj = SWIG_NewPointerObj((void *)(wxBLUE), SWIGTYPE_p_wxColour, 0);
19022 return pyobj;
19023 }
19024
19025
19026 static int _wrap_GREEN_set(PyObject *) {
19027 PyErr_SetString(PyExc_TypeError,"Variable GREEN is read-only.");
19028 return 1;
19029 }
19030
19031
19032 static PyObject *_wrap_GREEN_get(void) {
19033 PyObject *pyobj;
19034
19035 pyobj = SWIG_NewPointerObj((void *)(wxGREEN), SWIGTYPE_p_wxColour, 0);
19036 return pyobj;
19037 }
19038
19039
19040 static int _wrap_CYAN_set(PyObject *) {
19041 PyErr_SetString(PyExc_TypeError,"Variable CYAN is read-only.");
19042 return 1;
19043 }
19044
19045
19046 static PyObject *_wrap_CYAN_get(void) {
19047 PyObject *pyobj;
19048
19049 pyobj = SWIG_NewPointerObj((void *)(wxCYAN), SWIGTYPE_p_wxColour, 0);
19050 return pyobj;
19051 }
19052
19053
19054 static int _wrap_LIGHT_GREY_set(PyObject *) {
19055 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY is read-only.");
19056 return 1;
19057 }
19058
19059
19060 static PyObject *_wrap_LIGHT_GREY_get(void) {
19061 PyObject *pyobj;
19062
19063 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY), SWIGTYPE_p_wxColour, 0);
19064 return pyobj;
19065 }
19066
19067
19068 static int _wrap_STANDARD_CURSOR_set(PyObject *) {
19069 PyErr_SetString(PyExc_TypeError,"Variable STANDARD_CURSOR is read-only.");
19070 return 1;
19071 }
19072
19073
19074 static PyObject *_wrap_STANDARD_CURSOR_get(void) {
19075 PyObject *pyobj;
19076
19077 pyobj = SWIG_NewPointerObj((void *)(wxSTANDARD_CURSOR), SWIGTYPE_p_wxCursor, 0);
19078 return pyobj;
19079 }
19080
19081
19082 static int _wrap_HOURGLASS_CURSOR_set(PyObject *) {
19083 PyErr_SetString(PyExc_TypeError,"Variable HOURGLASS_CURSOR is read-only.");
19084 return 1;
19085 }
19086
19087
19088 static PyObject *_wrap_HOURGLASS_CURSOR_get(void) {
19089 PyObject *pyobj;
19090
19091 pyobj = SWIG_NewPointerObj((void *)(wxHOURGLASS_CURSOR), SWIGTYPE_p_wxCursor, 0);
19092 return pyobj;
19093 }
19094
19095
19096 static int _wrap_CROSS_CURSOR_set(PyObject *) {
19097 PyErr_SetString(PyExc_TypeError,"Variable CROSS_CURSOR is read-only.");
19098 return 1;
19099 }
19100
19101
19102 static PyObject *_wrap_CROSS_CURSOR_get(void) {
19103 PyObject *pyobj;
19104
19105 pyobj = SWIG_NewPointerObj((void *)(wxCROSS_CURSOR), SWIGTYPE_p_wxCursor, 0);
19106 return pyobj;
19107 }
19108
19109
19110 static int _wrap_NullBitmap_set(PyObject *) {
19111 PyErr_SetString(PyExc_TypeError,"Variable NullBitmap is read-only.");
19112 return 1;
19113 }
19114
19115
19116 static PyObject *_wrap_NullBitmap_get(void) {
19117 PyObject *pyobj;
19118
19119 pyobj = SWIG_NewPointerObj((void *)(&wxNullBitmap), SWIGTYPE_p_wxBitmap, 0);
19120 return pyobj;
19121 }
19122
19123
19124 static int _wrap_NullIcon_set(PyObject *) {
19125 PyErr_SetString(PyExc_TypeError,"Variable NullIcon is read-only.");
19126 return 1;
19127 }
19128
19129
19130 static PyObject *_wrap_NullIcon_get(void) {
19131 PyObject *pyobj;
19132
19133 pyobj = SWIG_NewPointerObj((void *)(&wxNullIcon), SWIGTYPE_p_wxIcon, 0);
19134 return pyobj;
19135 }
19136
19137
19138 static int _wrap_NullCursor_set(PyObject *) {
19139 PyErr_SetString(PyExc_TypeError,"Variable NullCursor is read-only.");
19140 return 1;
19141 }
19142
19143
19144 static PyObject *_wrap_NullCursor_get(void) {
19145 PyObject *pyobj;
19146
19147 pyobj = SWIG_NewPointerObj((void *)(&wxNullCursor), SWIGTYPE_p_wxCursor, 0);
19148 return pyobj;
19149 }
19150
19151
19152 static int _wrap_NullPen_set(PyObject *) {
19153 PyErr_SetString(PyExc_TypeError,"Variable NullPen is read-only.");
19154 return 1;
19155 }
19156
19157
19158 static PyObject *_wrap_NullPen_get(void) {
19159 PyObject *pyobj;
19160
19161 pyobj = SWIG_NewPointerObj((void *)(&wxNullPen), SWIGTYPE_p_wxPen, 0);
19162 return pyobj;
19163 }
19164
19165
19166 static int _wrap_NullBrush_set(PyObject *) {
19167 PyErr_SetString(PyExc_TypeError,"Variable NullBrush is read-only.");
19168 return 1;
19169 }
19170
19171
19172 static PyObject *_wrap_NullBrush_get(void) {
19173 PyObject *pyobj;
19174
19175 pyobj = SWIG_NewPointerObj((void *)(&wxNullBrush), SWIGTYPE_p_wxBrush, 0);
19176 return pyobj;
19177 }
19178
19179
19180 static int _wrap_NullPalette_set(PyObject *) {
19181 PyErr_SetString(PyExc_TypeError,"Variable NullPalette is read-only.");
19182 return 1;
19183 }
19184
19185
19186 static PyObject *_wrap_NullPalette_get(void) {
19187 PyObject *pyobj;
19188
19189 pyobj = SWIG_NewPointerObj((void *)(&wxNullPalette), SWIGTYPE_p_wxPalette, 0);
19190 return pyobj;
19191 }
19192
19193
19194 static int _wrap_NullFont_set(PyObject *) {
19195 PyErr_SetString(PyExc_TypeError,"Variable NullFont is read-only.");
19196 return 1;
19197 }
19198
19199
19200 static PyObject *_wrap_NullFont_get(void) {
19201 PyObject *pyobj;
19202
19203 pyobj = SWIG_NewPointerObj((void *)(&wxNullFont), SWIGTYPE_p_wxFont, 0);
19204 return pyobj;
19205 }
19206
19207
19208 static int _wrap_NullColour_set(PyObject *) {
19209 PyErr_SetString(PyExc_TypeError,"Variable NullColour is read-only.");
19210 return 1;
19211 }
19212
19213
19214 static PyObject *_wrap_NullColour_get(void) {
19215 PyObject *pyobj;
19216
19217 pyobj = SWIG_NewPointerObj((void *)(&wxNullColour), SWIGTYPE_p_wxColour, 0);
19218 return pyobj;
19219 }
19220
19221
19222 static PyObject *_wrap_PenList_AddPen(PyObject *, PyObject *args, PyObject *kwargs) {
19223 PyObject *resultobj;
19224 wxPenList *arg1 = (wxPenList *) 0 ;
19225 wxPen *arg2 = (wxPen *) 0 ;
19226 PyObject * obj0 = 0 ;
19227 PyObject * obj1 = 0 ;
19228 char *kwnames[] = {
19229 (char *) "self",(char *) "pen", NULL
19230 };
19231
19232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_AddPen",kwnames,&obj0,&obj1)) goto fail;
19233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19234 if (SWIG_arg_fail(1)) SWIG_fail;
19235 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
19236 if (SWIG_arg_fail(2)) SWIG_fail;
19237 {
19238 PyThreadState* __tstate = wxPyBeginAllowThreads();
19239 (arg1)->AddPen(arg2);
19240
19241 wxPyEndAllowThreads(__tstate);
19242 if (PyErr_Occurred()) SWIG_fail;
19243 }
19244 Py_INCREF(Py_None); resultobj = Py_None;
19245 return resultobj;
19246 fail:
19247 return NULL;
19248 }
19249
19250
19251 static PyObject *_wrap_PenList_FindOrCreatePen(PyObject *, PyObject *args, PyObject *kwargs) {
19252 PyObject *resultobj;
19253 wxPenList *arg1 = (wxPenList *) 0 ;
19254 wxColour *arg2 = 0 ;
19255 int arg3 ;
19256 int arg4 ;
19257 wxPen *result;
19258 wxColour temp2 ;
19259 PyObject * obj0 = 0 ;
19260 PyObject * obj1 = 0 ;
19261 PyObject * obj2 = 0 ;
19262 PyObject * obj3 = 0 ;
19263 char *kwnames[] = {
19264 (char *) "self",(char *) "colour",(char *) "width",(char *) "style", NULL
19265 };
19266
19267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PenList_FindOrCreatePen",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19269 if (SWIG_arg_fail(1)) SWIG_fail;
19270 {
19271 arg2 = &temp2;
19272 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19273 }
19274 {
19275 arg3 = (int)(SWIG_As_int(obj2));
19276 if (SWIG_arg_fail(3)) SWIG_fail;
19277 }
19278 {
19279 arg4 = (int)(SWIG_As_int(obj3));
19280 if (SWIG_arg_fail(4)) SWIG_fail;
19281 }
19282 {
19283 PyThreadState* __tstate = wxPyBeginAllowThreads();
19284 result = (wxPen *)(arg1)->FindOrCreatePen((wxColour const &)*arg2,arg3,arg4);
19285
19286 wxPyEndAllowThreads(__tstate);
19287 if (PyErr_Occurred()) SWIG_fail;
19288 }
19289 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 0);
19290 return resultobj;
19291 fail:
19292 return NULL;
19293 }
19294
19295
19296 static PyObject *_wrap_PenList_RemovePen(PyObject *, PyObject *args, PyObject *kwargs) {
19297 PyObject *resultobj;
19298 wxPenList *arg1 = (wxPenList *) 0 ;
19299 wxPen *arg2 = (wxPen *) 0 ;
19300 PyObject * obj0 = 0 ;
19301 PyObject * obj1 = 0 ;
19302 char *kwnames[] = {
19303 (char *) "self",(char *) "pen", NULL
19304 };
19305
19306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_RemovePen",kwnames,&obj0,&obj1)) goto fail;
19307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19308 if (SWIG_arg_fail(1)) SWIG_fail;
19309 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
19310 if (SWIG_arg_fail(2)) SWIG_fail;
19311 {
19312 PyThreadState* __tstate = wxPyBeginAllowThreads();
19313 (arg1)->RemovePen(arg2);
19314
19315 wxPyEndAllowThreads(__tstate);
19316 if (PyErr_Occurred()) SWIG_fail;
19317 }
19318 Py_INCREF(Py_None); resultobj = Py_None;
19319 return resultobj;
19320 fail:
19321 return NULL;
19322 }
19323
19324
19325 static PyObject *_wrap_PenList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
19326 PyObject *resultobj;
19327 wxPenList *arg1 = (wxPenList *) 0 ;
19328 int result;
19329 PyObject * obj0 = 0 ;
19330 char *kwnames[] = {
19331 (char *) "self", NULL
19332 };
19333
19334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PenList_GetCount",kwnames,&obj0)) goto fail;
19335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19336 if (SWIG_arg_fail(1)) SWIG_fail;
19337 {
19338 PyThreadState* __tstate = wxPyBeginAllowThreads();
19339 result = (int)(arg1)->GetCount();
19340
19341 wxPyEndAllowThreads(__tstate);
19342 if (PyErr_Occurred()) SWIG_fail;
19343 }
19344 {
19345 resultobj = SWIG_From_int((int)(result));
19346 }
19347 return resultobj;
19348 fail:
19349 return NULL;
19350 }
19351
19352
19353 static PyObject * PenList_swigregister(PyObject *, PyObject *args) {
19354 PyObject *obj;
19355 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19356 SWIG_TypeClientData(SWIGTYPE_p_wxPenList, obj);
19357 Py_INCREF(obj);
19358 return Py_BuildValue((char *)"");
19359 }
19360 static PyObject *_wrap_BrushList_AddBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19361 PyObject *resultobj;
19362 wxBrushList *arg1 = (wxBrushList *) 0 ;
19363 wxBrush *arg2 = (wxBrush *) 0 ;
19364 PyObject * obj0 = 0 ;
19365 PyObject * obj1 = 0 ;
19366 char *kwnames[] = {
19367 (char *) "self",(char *) "brush", NULL
19368 };
19369
19370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_AddBrush",kwnames,&obj0,&obj1)) goto fail;
19371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19372 if (SWIG_arg_fail(1)) SWIG_fail;
19373 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
19374 if (SWIG_arg_fail(2)) SWIG_fail;
19375 {
19376 PyThreadState* __tstate = wxPyBeginAllowThreads();
19377 (arg1)->AddBrush(arg2);
19378
19379 wxPyEndAllowThreads(__tstate);
19380 if (PyErr_Occurred()) SWIG_fail;
19381 }
19382 Py_INCREF(Py_None); resultobj = Py_None;
19383 return resultobj;
19384 fail:
19385 return NULL;
19386 }
19387
19388
19389 static PyObject *_wrap_BrushList_FindOrCreateBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19390 PyObject *resultobj;
19391 wxBrushList *arg1 = (wxBrushList *) 0 ;
19392 wxColour *arg2 = 0 ;
19393 int arg3 = (int) wxSOLID ;
19394 wxBrush *result;
19395 wxColour temp2 ;
19396 PyObject * obj0 = 0 ;
19397 PyObject * obj1 = 0 ;
19398 PyObject * obj2 = 0 ;
19399 char *kwnames[] = {
19400 (char *) "self",(char *) "colour",(char *) "style", NULL
19401 };
19402
19403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:BrushList_FindOrCreateBrush",kwnames,&obj0,&obj1,&obj2)) goto fail;
19404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19405 if (SWIG_arg_fail(1)) SWIG_fail;
19406 {
19407 arg2 = &temp2;
19408 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19409 }
19410 if (obj2) {
19411 {
19412 arg3 = (int)(SWIG_As_int(obj2));
19413 if (SWIG_arg_fail(3)) SWIG_fail;
19414 }
19415 }
19416 {
19417 PyThreadState* __tstate = wxPyBeginAllowThreads();
19418 result = (wxBrush *)(arg1)->FindOrCreateBrush((wxColour const &)*arg2,arg3);
19419
19420 wxPyEndAllowThreads(__tstate);
19421 if (PyErr_Occurred()) SWIG_fail;
19422 }
19423 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 0);
19424 return resultobj;
19425 fail:
19426 return NULL;
19427 }
19428
19429
19430 static PyObject *_wrap_BrushList_RemoveBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19431 PyObject *resultobj;
19432 wxBrushList *arg1 = (wxBrushList *) 0 ;
19433 wxBrush *arg2 = (wxBrush *) 0 ;
19434 PyObject * obj0 = 0 ;
19435 PyObject * obj1 = 0 ;
19436 char *kwnames[] = {
19437 (char *) "self",(char *) "brush", NULL
19438 };
19439
19440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_RemoveBrush",kwnames,&obj0,&obj1)) goto fail;
19441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19442 if (SWIG_arg_fail(1)) SWIG_fail;
19443 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
19444 if (SWIG_arg_fail(2)) SWIG_fail;
19445 {
19446 PyThreadState* __tstate = wxPyBeginAllowThreads();
19447 (arg1)->RemoveBrush(arg2);
19448
19449 wxPyEndAllowThreads(__tstate);
19450 if (PyErr_Occurred()) SWIG_fail;
19451 }
19452 Py_INCREF(Py_None); resultobj = Py_None;
19453 return resultobj;
19454 fail:
19455 return NULL;
19456 }
19457
19458
19459 static PyObject *_wrap_BrushList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
19460 PyObject *resultobj;
19461 wxBrushList *arg1 = (wxBrushList *) 0 ;
19462 int result;
19463 PyObject * obj0 = 0 ;
19464 char *kwnames[] = {
19465 (char *) "self", NULL
19466 };
19467
19468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BrushList_GetCount",kwnames,&obj0)) goto fail;
19469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19470 if (SWIG_arg_fail(1)) SWIG_fail;
19471 {
19472 PyThreadState* __tstate = wxPyBeginAllowThreads();
19473 result = (int)(arg1)->GetCount();
19474
19475 wxPyEndAllowThreads(__tstate);
19476 if (PyErr_Occurred()) SWIG_fail;
19477 }
19478 {
19479 resultobj = SWIG_From_int((int)(result));
19480 }
19481 return resultobj;
19482 fail:
19483 return NULL;
19484 }
19485
19486
19487 static PyObject * BrushList_swigregister(PyObject *, PyObject *args) {
19488 PyObject *obj;
19489 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19490 SWIG_TypeClientData(SWIGTYPE_p_wxBrushList, obj);
19491 Py_INCREF(obj);
19492 return Py_BuildValue((char *)"");
19493 }
19494 static PyObject *_wrap_new_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
19495 PyObject *resultobj;
19496 wxColourDatabase *result;
19497 char *kwnames[] = {
19498 NULL
19499 };
19500
19501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ColourDatabase",kwnames)) goto fail;
19502 {
19503 if (!wxPyCheckForApp()) SWIG_fail;
19504 PyThreadState* __tstate = wxPyBeginAllowThreads();
19505 result = (wxColourDatabase *)new wxColourDatabase();
19506
19507 wxPyEndAllowThreads(__tstate);
19508 if (PyErr_Occurred()) SWIG_fail;
19509 }
19510 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColourDatabase, 1);
19511 return resultobj;
19512 fail:
19513 return NULL;
19514 }
19515
19516
19517 static PyObject *_wrap_delete_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
19518 PyObject *resultobj;
19519 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19520 PyObject * obj0 = 0 ;
19521 char *kwnames[] = {
19522 (char *) "self", NULL
19523 };
19524
19525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ColourDatabase",kwnames,&obj0)) goto fail;
19526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19527 if (SWIG_arg_fail(1)) SWIG_fail;
19528 {
19529 PyThreadState* __tstate = wxPyBeginAllowThreads();
19530 delete arg1;
19531
19532 wxPyEndAllowThreads(__tstate);
19533 if (PyErr_Occurred()) SWIG_fail;
19534 }
19535 Py_INCREF(Py_None); resultobj = Py_None;
19536 return resultobj;
19537 fail:
19538 return NULL;
19539 }
19540
19541
19542 static PyObject *_wrap_ColourDatabase_Find(PyObject *, PyObject *args, PyObject *kwargs) {
19543 PyObject *resultobj;
19544 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19545 wxString *arg2 = 0 ;
19546 wxColour result;
19547 bool temp2 = false ;
19548 PyObject * obj0 = 0 ;
19549 PyObject * obj1 = 0 ;
19550 char *kwnames[] = {
19551 (char *) "self",(char *) "name", NULL
19552 };
19553
19554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_Find",kwnames,&obj0,&obj1)) goto fail;
19555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19556 if (SWIG_arg_fail(1)) SWIG_fail;
19557 {
19558 arg2 = wxString_in_helper(obj1);
19559 if (arg2 == NULL) SWIG_fail;
19560 temp2 = true;
19561 }
19562 {
19563 PyThreadState* __tstate = wxPyBeginAllowThreads();
19564 result = ((wxColourDatabase const *)arg1)->Find((wxString const &)*arg2);
19565
19566 wxPyEndAllowThreads(__tstate);
19567 if (PyErr_Occurred()) SWIG_fail;
19568 }
19569 {
19570 wxColour * resultptr;
19571 resultptr = new wxColour((wxColour &)(result));
19572 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
19573 }
19574 {
19575 if (temp2)
19576 delete arg2;
19577 }
19578 return resultobj;
19579 fail:
19580 {
19581 if (temp2)
19582 delete arg2;
19583 }
19584 return NULL;
19585 }
19586
19587
19588 static PyObject *_wrap_ColourDatabase_FindName(PyObject *, PyObject *args, PyObject *kwargs) {
19589 PyObject *resultobj;
19590 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19591 wxColour *arg2 = 0 ;
19592 wxString result;
19593 wxColour temp2 ;
19594 PyObject * obj0 = 0 ;
19595 PyObject * obj1 = 0 ;
19596 char *kwnames[] = {
19597 (char *) "self",(char *) "colour", NULL
19598 };
19599
19600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_FindName",kwnames,&obj0,&obj1)) goto fail;
19601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19602 if (SWIG_arg_fail(1)) SWIG_fail;
19603 {
19604 arg2 = &temp2;
19605 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19606 }
19607 {
19608 PyThreadState* __tstate = wxPyBeginAllowThreads();
19609 result = ((wxColourDatabase const *)arg1)->FindName((wxColour const &)*arg2);
19610
19611 wxPyEndAllowThreads(__tstate);
19612 if (PyErr_Occurred()) SWIG_fail;
19613 }
19614 {
19615 #if wxUSE_UNICODE
19616 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19617 #else
19618 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19619 #endif
19620 }
19621 return resultobj;
19622 fail:
19623 return NULL;
19624 }
19625
19626
19627 static PyObject *_wrap_ColourDatabase_AddColour(PyObject *, PyObject *args, PyObject *kwargs) {
19628 PyObject *resultobj;
19629 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19630 wxString *arg2 = 0 ;
19631 wxColour *arg3 = 0 ;
19632 bool temp2 = false ;
19633 wxColour temp3 ;
19634 PyObject * obj0 = 0 ;
19635 PyObject * obj1 = 0 ;
19636 PyObject * obj2 = 0 ;
19637 char *kwnames[] = {
19638 (char *) "self",(char *) "name",(char *) "colour", NULL
19639 };
19640
19641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ColourDatabase_AddColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
19642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19643 if (SWIG_arg_fail(1)) SWIG_fail;
19644 {
19645 arg2 = wxString_in_helper(obj1);
19646 if (arg2 == NULL) SWIG_fail;
19647 temp2 = true;
19648 }
19649 {
19650 arg3 = &temp3;
19651 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
19652 }
19653 {
19654 PyThreadState* __tstate = wxPyBeginAllowThreads();
19655 (arg1)->AddColour((wxString const &)*arg2,(wxColour const &)*arg3);
19656
19657 wxPyEndAllowThreads(__tstate);
19658 if (PyErr_Occurred()) SWIG_fail;
19659 }
19660 Py_INCREF(Py_None); resultobj = Py_None;
19661 {
19662 if (temp2)
19663 delete arg2;
19664 }
19665 return resultobj;
19666 fail:
19667 {
19668 if (temp2)
19669 delete arg2;
19670 }
19671 return NULL;
19672 }
19673
19674
19675 static PyObject *_wrap_ColourDatabase_Append(PyObject *, PyObject *args, PyObject *kwargs) {
19676 PyObject *resultobj;
19677 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19678 wxString *arg2 = 0 ;
19679 int arg3 ;
19680 int arg4 ;
19681 int arg5 ;
19682 bool temp2 = false ;
19683 PyObject * obj0 = 0 ;
19684 PyObject * obj1 = 0 ;
19685 PyObject * obj2 = 0 ;
19686 PyObject * obj3 = 0 ;
19687 PyObject * obj4 = 0 ;
19688 char *kwnames[] = {
19689 (char *) "self",(char *) "name",(char *) "red",(char *) "green",(char *) "blue", NULL
19690 };
19691
19692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:ColourDatabase_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19694 if (SWIG_arg_fail(1)) SWIG_fail;
19695 {
19696 arg2 = wxString_in_helper(obj1);
19697 if (arg2 == NULL) SWIG_fail;
19698 temp2 = true;
19699 }
19700 {
19701 arg3 = (int)(SWIG_As_int(obj2));
19702 if (SWIG_arg_fail(3)) SWIG_fail;
19703 }
19704 {
19705 arg4 = (int)(SWIG_As_int(obj3));
19706 if (SWIG_arg_fail(4)) SWIG_fail;
19707 }
19708 {
19709 arg5 = (int)(SWIG_As_int(obj4));
19710 if (SWIG_arg_fail(5)) SWIG_fail;
19711 }
19712 {
19713 PyThreadState* __tstate = wxPyBeginAllowThreads();
19714 wxColourDatabase_Append(arg1,(wxString const &)*arg2,arg3,arg4,arg5);
19715
19716 wxPyEndAllowThreads(__tstate);
19717 if (PyErr_Occurred()) SWIG_fail;
19718 }
19719 Py_INCREF(Py_None); resultobj = Py_None;
19720 {
19721 if (temp2)
19722 delete arg2;
19723 }
19724 return resultobj;
19725 fail:
19726 {
19727 if (temp2)
19728 delete arg2;
19729 }
19730 return NULL;
19731 }
19732
19733
19734 static PyObject * ColourDatabase_swigregister(PyObject *, PyObject *args) {
19735 PyObject *obj;
19736 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19737 SWIG_TypeClientData(SWIGTYPE_p_wxColourDatabase, obj);
19738 Py_INCREF(obj);
19739 return Py_BuildValue((char *)"");
19740 }
19741 static PyObject *_wrap_FontList_AddFont(PyObject *, PyObject *args, PyObject *kwargs) {
19742 PyObject *resultobj;
19743 wxFontList *arg1 = (wxFontList *) 0 ;
19744 wxFont *arg2 = (wxFont *) 0 ;
19745 PyObject * obj0 = 0 ;
19746 PyObject * obj1 = 0 ;
19747 char *kwnames[] = {
19748 (char *) "self",(char *) "font", NULL
19749 };
19750
19751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_AddFont",kwnames,&obj0,&obj1)) goto fail;
19752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
19753 if (SWIG_arg_fail(1)) SWIG_fail;
19754 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
19755 if (SWIG_arg_fail(2)) SWIG_fail;
19756 {
19757 PyThreadState* __tstate = wxPyBeginAllowThreads();
19758 (arg1)->AddFont(arg2);
19759
19760 wxPyEndAllowThreads(__tstate);
19761 if (PyErr_Occurred()) SWIG_fail;
19762 }
19763 Py_INCREF(Py_None); resultobj = Py_None;
19764 return resultobj;
19765 fail:
19766 return NULL;
19767 }
19768
19769
19770 static PyObject *_wrap_FontList_FindOrCreateFont(PyObject *, PyObject *args, PyObject *kwargs) {
19771 PyObject *resultobj;
19772 wxFontList *arg1 = (wxFontList *) 0 ;
19773 int arg2 ;
19774 int arg3 ;
19775 int arg4 ;
19776 int arg5 ;
19777 bool arg6 = (bool) false ;
19778 wxString const &arg7_defvalue = wxPyEmptyString ;
19779 wxString *arg7 = (wxString *) &arg7_defvalue ;
19780 wxFontEncoding arg8 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
19781 wxFont *result;
19782 bool temp7 = false ;
19783 PyObject * obj0 = 0 ;
19784 PyObject * obj1 = 0 ;
19785 PyObject * obj2 = 0 ;
19786 PyObject * obj3 = 0 ;
19787 PyObject * obj4 = 0 ;
19788 PyObject * obj5 = 0 ;
19789 PyObject * obj6 = 0 ;
19790 PyObject * obj7 = 0 ;
19791 char *kwnames[] = {
19792 (char *) "self",(char *) "point_size",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "facename",(char *) "encoding", NULL
19793 };
19794
19795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:FontList_FindOrCreateFont",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
19796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
19797 if (SWIG_arg_fail(1)) SWIG_fail;
19798 {
19799 arg2 = (int)(SWIG_As_int(obj1));
19800 if (SWIG_arg_fail(2)) SWIG_fail;
19801 }
19802 {
19803 arg3 = (int)(SWIG_As_int(obj2));
19804 if (SWIG_arg_fail(3)) SWIG_fail;
19805 }
19806 {
19807 arg4 = (int)(SWIG_As_int(obj3));
19808 if (SWIG_arg_fail(4)) SWIG_fail;
19809 }
19810 {
19811 arg5 = (int)(SWIG_As_int(obj4));
19812 if (SWIG_arg_fail(5)) SWIG_fail;
19813 }
19814 if (obj5) {
19815 {
19816 arg6 = (bool)(SWIG_As_bool(obj5));
19817 if (SWIG_arg_fail(6)) SWIG_fail;
19818 }
19819 }
19820 if (obj6) {
19821 {
19822 arg7 = wxString_in_helper(obj6);
19823 if (arg7 == NULL) SWIG_fail;
19824 temp7 = true;
19825 }
19826 }
19827 if (obj7) {
19828 {
19829 arg8 = (wxFontEncoding)(SWIG_As_int(obj7));
19830 if (SWIG_arg_fail(8)) SWIG_fail;
19831 }
19832 }
19833 {
19834 PyThreadState* __tstate = wxPyBeginAllowThreads();
19835 result = (wxFont *)(arg1)->FindOrCreateFont(arg2,arg3,arg4,arg5,arg6,(wxString const &)*arg7,(wxFontEncoding )arg8);
19836
19837 wxPyEndAllowThreads(__tstate);
19838 if (PyErr_Occurred()) SWIG_fail;
19839 }
19840 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
19841 {
19842 if (temp7)
19843 delete arg7;
19844 }
19845 return resultobj;
19846 fail:
19847 {
19848 if (temp7)
19849 delete arg7;
19850 }
19851 return NULL;
19852 }
19853
19854
19855 static PyObject *_wrap_FontList_RemoveFont(PyObject *, PyObject *args, PyObject *kwargs) {
19856 PyObject *resultobj;
19857 wxFontList *arg1 = (wxFontList *) 0 ;
19858 wxFont *arg2 = (wxFont *) 0 ;
19859 PyObject * obj0 = 0 ;
19860 PyObject * obj1 = 0 ;
19861 char *kwnames[] = {
19862 (char *) "self",(char *) "font", NULL
19863 };
19864
19865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_RemoveFont",kwnames,&obj0,&obj1)) goto fail;
19866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
19867 if (SWIG_arg_fail(1)) SWIG_fail;
19868 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
19869 if (SWIG_arg_fail(2)) SWIG_fail;
19870 {
19871 PyThreadState* __tstate = wxPyBeginAllowThreads();
19872 (arg1)->RemoveFont(arg2);
19873
19874 wxPyEndAllowThreads(__tstate);
19875 if (PyErr_Occurred()) SWIG_fail;
19876 }
19877 Py_INCREF(Py_None); resultobj = Py_None;
19878 return resultobj;
19879 fail:
19880 return NULL;
19881 }
19882
19883
19884 static PyObject *_wrap_FontList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
19885 PyObject *resultobj;
19886 wxFontList *arg1 = (wxFontList *) 0 ;
19887 int result;
19888 PyObject * obj0 = 0 ;
19889 char *kwnames[] = {
19890 (char *) "self", NULL
19891 };
19892
19893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontList_GetCount",kwnames,&obj0)) goto fail;
19894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
19895 if (SWIG_arg_fail(1)) SWIG_fail;
19896 {
19897 PyThreadState* __tstate = wxPyBeginAllowThreads();
19898 result = (int)(arg1)->GetCount();
19899
19900 wxPyEndAllowThreads(__tstate);
19901 if (PyErr_Occurred()) SWIG_fail;
19902 }
19903 {
19904 resultobj = SWIG_From_int((int)(result));
19905 }
19906 return resultobj;
19907 fail:
19908 return NULL;
19909 }
19910
19911
19912 static PyObject * FontList_swigregister(PyObject *, PyObject *args) {
19913 PyObject *obj;
19914 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19915 SWIG_TypeClientData(SWIGTYPE_p_wxFontList, obj);
19916 Py_INCREF(obj);
19917 return Py_BuildValue((char *)"");
19918 }
19919 static int _wrap_TheFontList_set(PyObject *) {
19920 PyErr_SetString(PyExc_TypeError,"Variable TheFontList is read-only.");
19921 return 1;
19922 }
19923
19924
19925 static PyObject *_wrap_TheFontList_get(void) {
19926 PyObject *pyobj;
19927
19928 pyobj = SWIG_NewPointerObj((void *)(wxTheFontList), SWIGTYPE_p_wxFontList, 0);
19929 return pyobj;
19930 }
19931
19932
19933 static int _wrap_ThePenList_set(PyObject *) {
19934 PyErr_SetString(PyExc_TypeError,"Variable ThePenList is read-only.");
19935 return 1;
19936 }
19937
19938
19939 static PyObject *_wrap_ThePenList_get(void) {
19940 PyObject *pyobj;
19941
19942 pyobj = SWIG_NewPointerObj((void *)(wxThePenList), SWIGTYPE_p_wxPenList, 0);
19943 return pyobj;
19944 }
19945
19946
19947 static int _wrap_TheBrushList_set(PyObject *) {
19948 PyErr_SetString(PyExc_TypeError,"Variable TheBrushList is read-only.");
19949 return 1;
19950 }
19951
19952
19953 static PyObject *_wrap_TheBrushList_get(void) {
19954 PyObject *pyobj;
19955
19956 pyobj = SWIG_NewPointerObj((void *)(wxTheBrushList), SWIGTYPE_p_wxBrushList, 0);
19957 return pyobj;
19958 }
19959
19960
19961 static int _wrap_TheColourDatabase_set(PyObject *) {
19962 PyErr_SetString(PyExc_TypeError,"Variable TheColourDatabase is read-only.");
19963 return 1;
19964 }
19965
19966
19967 static PyObject *_wrap_TheColourDatabase_get(void) {
19968 PyObject *pyobj;
19969
19970 pyobj = SWIG_NewPointerObj((void *)(wxTheColourDatabase), SWIGTYPE_p_wxColourDatabase, 0);
19971 return pyobj;
19972 }
19973
19974
19975 static PyObject *_wrap_new_Effects(PyObject *, PyObject *args, PyObject *kwargs) {
19976 PyObject *resultobj;
19977 wxEffects *result;
19978 char *kwnames[] = {
19979 NULL
19980 };
19981
19982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Effects",kwnames)) goto fail;
19983 {
19984 PyThreadState* __tstate = wxPyBeginAllowThreads();
19985 result = (wxEffects *)new wxEffects();
19986
19987 wxPyEndAllowThreads(__tstate);
19988 if (PyErr_Occurred()) SWIG_fail;
19989 }
19990 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEffects, 1);
19991 return resultobj;
19992 fail:
19993 return NULL;
19994 }
19995
19996
19997 static PyObject *_wrap_Effects_GetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
19998 PyObject *resultobj;
19999 wxEffects *arg1 = (wxEffects *) 0 ;
20000 wxColour result;
20001 PyObject * obj0 = 0 ;
20002 char *kwnames[] = {
20003 (char *) "self", NULL
20004 };
20005
20006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetHighlightColour",kwnames,&obj0)) goto fail;
20007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20008 if (SWIG_arg_fail(1)) SWIG_fail;
20009 {
20010 PyThreadState* __tstate = wxPyBeginAllowThreads();
20011 result = ((wxEffects const *)arg1)->GetHighlightColour();
20012
20013 wxPyEndAllowThreads(__tstate);
20014 if (PyErr_Occurred()) SWIG_fail;
20015 }
20016 {
20017 wxColour * resultptr;
20018 resultptr = new wxColour((wxColour &)(result));
20019 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20020 }
20021 return resultobj;
20022 fail:
20023 return NULL;
20024 }
20025
20026
20027 static PyObject *_wrap_Effects_GetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20028 PyObject *resultobj;
20029 wxEffects *arg1 = (wxEffects *) 0 ;
20030 wxColour result;
20031 PyObject * obj0 = 0 ;
20032 char *kwnames[] = {
20033 (char *) "self", NULL
20034 };
20035
20036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetLightShadow",kwnames,&obj0)) goto fail;
20037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20038 if (SWIG_arg_fail(1)) SWIG_fail;
20039 {
20040 PyThreadState* __tstate = wxPyBeginAllowThreads();
20041 result = ((wxEffects const *)arg1)->GetLightShadow();
20042
20043 wxPyEndAllowThreads(__tstate);
20044 if (PyErr_Occurred()) SWIG_fail;
20045 }
20046 {
20047 wxColour * resultptr;
20048 resultptr = new wxColour((wxColour &)(result));
20049 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20050 }
20051 return resultobj;
20052 fail:
20053 return NULL;
20054 }
20055
20056
20057 static PyObject *_wrap_Effects_GetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
20058 PyObject *resultobj;
20059 wxEffects *arg1 = (wxEffects *) 0 ;
20060 wxColour result;
20061 PyObject * obj0 = 0 ;
20062 char *kwnames[] = {
20063 (char *) "self", NULL
20064 };
20065
20066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetFaceColour",kwnames,&obj0)) goto fail;
20067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20068 if (SWIG_arg_fail(1)) SWIG_fail;
20069 {
20070 PyThreadState* __tstate = wxPyBeginAllowThreads();
20071 result = ((wxEffects const *)arg1)->GetFaceColour();
20072
20073 wxPyEndAllowThreads(__tstate);
20074 if (PyErr_Occurred()) SWIG_fail;
20075 }
20076 {
20077 wxColour * resultptr;
20078 resultptr = new wxColour((wxColour &)(result));
20079 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20080 }
20081 return resultobj;
20082 fail:
20083 return NULL;
20084 }
20085
20086
20087 static PyObject *_wrap_Effects_GetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20088 PyObject *resultobj;
20089 wxEffects *arg1 = (wxEffects *) 0 ;
20090 wxColour result;
20091 PyObject * obj0 = 0 ;
20092 char *kwnames[] = {
20093 (char *) "self", NULL
20094 };
20095
20096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetMediumShadow",kwnames,&obj0)) goto fail;
20097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20098 if (SWIG_arg_fail(1)) SWIG_fail;
20099 {
20100 PyThreadState* __tstate = wxPyBeginAllowThreads();
20101 result = ((wxEffects const *)arg1)->GetMediumShadow();
20102
20103 wxPyEndAllowThreads(__tstate);
20104 if (PyErr_Occurred()) SWIG_fail;
20105 }
20106 {
20107 wxColour * resultptr;
20108 resultptr = new wxColour((wxColour &)(result));
20109 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20110 }
20111 return resultobj;
20112 fail:
20113 return NULL;
20114 }
20115
20116
20117 static PyObject *_wrap_Effects_GetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20118 PyObject *resultobj;
20119 wxEffects *arg1 = (wxEffects *) 0 ;
20120 wxColour result;
20121 PyObject * obj0 = 0 ;
20122 char *kwnames[] = {
20123 (char *) "self", NULL
20124 };
20125
20126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetDarkShadow",kwnames,&obj0)) goto fail;
20127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20128 if (SWIG_arg_fail(1)) SWIG_fail;
20129 {
20130 PyThreadState* __tstate = wxPyBeginAllowThreads();
20131 result = ((wxEffects const *)arg1)->GetDarkShadow();
20132
20133 wxPyEndAllowThreads(__tstate);
20134 if (PyErr_Occurred()) SWIG_fail;
20135 }
20136 {
20137 wxColour * resultptr;
20138 resultptr = new wxColour((wxColour &)(result));
20139 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20140 }
20141 return resultobj;
20142 fail:
20143 return NULL;
20144 }
20145
20146
20147 static PyObject *_wrap_Effects_SetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
20148 PyObject *resultobj;
20149 wxEffects *arg1 = (wxEffects *) 0 ;
20150 wxColour *arg2 = 0 ;
20151 wxColour temp2 ;
20152 PyObject * obj0 = 0 ;
20153 PyObject * obj1 = 0 ;
20154 char *kwnames[] = {
20155 (char *) "self",(char *) "c", NULL
20156 };
20157
20158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetHighlightColour",kwnames,&obj0,&obj1)) goto fail;
20159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20160 if (SWIG_arg_fail(1)) SWIG_fail;
20161 {
20162 arg2 = &temp2;
20163 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20164 }
20165 {
20166 PyThreadState* __tstate = wxPyBeginAllowThreads();
20167 (arg1)->SetHighlightColour((wxColour const &)*arg2);
20168
20169 wxPyEndAllowThreads(__tstate);
20170 if (PyErr_Occurred()) SWIG_fail;
20171 }
20172 Py_INCREF(Py_None); resultobj = Py_None;
20173 return resultobj;
20174 fail:
20175 return NULL;
20176 }
20177
20178
20179 static PyObject *_wrap_Effects_SetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20180 PyObject *resultobj;
20181 wxEffects *arg1 = (wxEffects *) 0 ;
20182 wxColour *arg2 = 0 ;
20183 wxColour temp2 ;
20184 PyObject * obj0 = 0 ;
20185 PyObject * obj1 = 0 ;
20186 char *kwnames[] = {
20187 (char *) "self",(char *) "c", NULL
20188 };
20189
20190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetLightShadow",kwnames,&obj0,&obj1)) goto fail;
20191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20192 if (SWIG_arg_fail(1)) SWIG_fail;
20193 {
20194 arg2 = &temp2;
20195 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20196 }
20197 {
20198 PyThreadState* __tstate = wxPyBeginAllowThreads();
20199 (arg1)->SetLightShadow((wxColour const &)*arg2);
20200
20201 wxPyEndAllowThreads(__tstate);
20202 if (PyErr_Occurred()) SWIG_fail;
20203 }
20204 Py_INCREF(Py_None); resultobj = Py_None;
20205 return resultobj;
20206 fail:
20207 return NULL;
20208 }
20209
20210
20211 static PyObject *_wrap_Effects_SetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
20212 PyObject *resultobj;
20213 wxEffects *arg1 = (wxEffects *) 0 ;
20214 wxColour *arg2 = 0 ;
20215 wxColour temp2 ;
20216 PyObject * obj0 = 0 ;
20217 PyObject * obj1 = 0 ;
20218 char *kwnames[] = {
20219 (char *) "self",(char *) "c", NULL
20220 };
20221
20222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetFaceColour",kwnames,&obj0,&obj1)) goto fail;
20223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20224 if (SWIG_arg_fail(1)) SWIG_fail;
20225 {
20226 arg2 = &temp2;
20227 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20228 }
20229 {
20230 PyThreadState* __tstate = wxPyBeginAllowThreads();
20231 (arg1)->SetFaceColour((wxColour const &)*arg2);
20232
20233 wxPyEndAllowThreads(__tstate);
20234 if (PyErr_Occurred()) SWIG_fail;
20235 }
20236 Py_INCREF(Py_None); resultobj = Py_None;
20237 return resultobj;
20238 fail:
20239 return NULL;
20240 }
20241
20242
20243 static PyObject *_wrap_Effects_SetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20244 PyObject *resultobj;
20245 wxEffects *arg1 = (wxEffects *) 0 ;
20246 wxColour *arg2 = 0 ;
20247 wxColour temp2 ;
20248 PyObject * obj0 = 0 ;
20249 PyObject * obj1 = 0 ;
20250 char *kwnames[] = {
20251 (char *) "self",(char *) "c", NULL
20252 };
20253
20254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetMediumShadow",kwnames,&obj0,&obj1)) goto fail;
20255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20256 if (SWIG_arg_fail(1)) SWIG_fail;
20257 {
20258 arg2 = &temp2;
20259 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20260 }
20261 {
20262 PyThreadState* __tstate = wxPyBeginAllowThreads();
20263 (arg1)->SetMediumShadow((wxColour const &)*arg2);
20264
20265 wxPyEndAllowThreads(__tstate);
20266 if (PyErr_Occurred()) SWIG_fail;
20267 }
20268 Py_INCREF(Py_None); resultobj = Py_None;
20269 return resultobj;
20270 fail:
20271 return NULL;
20272 }
20273
20274
20275 static PyObject *_wrap_Effects_SetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20276 PyObject *resultobj;
20277 wxEffects *arg1 = (wxEffects *) 0 ;
20278 wxColour *arg2 = 0 ;
20279 wxColour temp2 ;
20280 PyObject * obj0 = 0 ;
20281 PyObject * obj1 = 0 ;
20282 char *kwnames[] = {
20283 (char *) "self",(char *) "c", NULL
20284 };
20285
20286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetDarkShadow",kwnames,&obj0,&obj1)) goto fail;
20287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20288 if (SWIG_arg_fail(1)) SWIG_fail;
20289 {
20290 arg2 = &temp2;
20291 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20292 }
20293 {
20294 PyThreadState* __tstate = wxPyBeginAllowThreads();
20295 (arg1)->SetDarkShadow((wxColour const &)*arg2);
20296
20297 wxPyEndAllowThreads(__tstate);
20298 if (PyErr_Occurred()) SWIG_fail;
20299 }
20300 Py_INCREF(Py_None); resultobj = Py_None;
20301 return resultobj;
20302 fail:
20303 return NULL;
20304 }
20305
20306
20307 static PyObject *_wrap_Effects_Set(PyObject *, PyObject *args, PyObject *kwargs) {
20308 PyObject *resultobj;
20309 wxEffects *arg1 = (wxEffects *) 0 ;
20310 wxColour *arg2 = 0 ;
20311 wxColour *arg3 = 0 ;
20312 wxColour *arg4 = 0 ;
20313 wxColour *arg5 = 0 ;
20314 wxColour *arg6 = 0 ;
20315 wxColour temp2 ;
20316 wxColour temp3 ;
20317 wxColour temp4 ;
20318 wxColour temp5 ;
20319 wxColour temp6 ;
20320 PyObject * obj0 = 0 ;
20321 PyObject * obj1 = 0 ;
20322 PyObject * obj2 = 0 ;
20323 PyObject * obj3 = 0 ;
20324 PyObject * obj4 = 0 ;
20325 PyObject * obj5 = 0 ;
20326 char *kwnames[] = {
20327 (char *) "self",(char *) "highlightColour",(char *) "lightShadow",(char *) "faceColour",(char *) "mediumShadow",(char *) "darkShadow", NULL
20328 };
20329
20330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Effects_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
20331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20332 if (SWIG_arg_fail(1)) SWIG_fail;
20333 {
20334 arg2 = &temp2;
20335 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20336 }
20337 {
20338 arg3 = &temp3;
20339 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
20340 }
20341 {
20342 arg4 = &temp4;
20343 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
20344 }
20345 {
20346 arg5 = &temp5;
20347 if ( ! wxColour_helper(obj4, &arg5)) SWIG_fail;
20348 }
20349 {
20350 arg6 = &temp6;
20351 if ( ! wxColour_helper(obj5, &arg6)) SWIG_fail;
20352 }
20353 {
20354 PyThreadState* __tstate = wxPyBeginAllowThreads();
20355 (arg1)->Set((wxColour const &)*arg2,(wxColour const &)*arg3,(wxColour const &)*arg4,(wxColour const &)*arg5,(wxColour const &)*arg6);
20356
20357 wxPyEndAllowThreads(__tstate);
20358 if (PyErr_Occurred()) SWIG_fail;
20359 }
20360 Py_INCREF(Py_None); resultobj = Py_None;
20361 return resultobj;
20362 fail:
20363 return NULL;
20364 }
20365
20366
20367 static PyObject *_wrap_Effects_DrawSunkenEdge(PyObject *, PyObject *args, PyObject *kwargs) {
20368 PyObject *resultobj;
20369 wxEffects *arg1 = (wxEffects *) 0 ;
20370 wxDC *arg2 = 0 ;
20371 wxRect *arg3 = 0 ;
20372 int arg4 = (int) 1 ;
20373 wxRect temp3 ;
20374 PyObject * obj0 = 0 ;
20375 PyObject * obj1 = 0 ;
20376 PyObject * obj2 = 0 ;
20377 PyObject * obj3 = 0 ;
20378 char *kwnames[] = {
20379 (char *) "self",(char *) "dc",(char *) "rect",(char *) "borderSize", NULL
20380 };
20381
20382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Effects_DrawSunkenEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20384 if (SWIG_arg_fail(1)) SWIG_fail;
20385 {
20386 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20387 if (SWIG_arg_fail(2)) SWIG_fail;
20388 if (arg2 == NULL) {
20389 SWIG_null_ref("wxDC");
20390 }
20391 if (SWIG_arg_fail(2)) SWIG_fail;
20392 }
20393 {
20394 arg3 = &temp3;
20395 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
20396 }
20397 if (obj3) {
20398 {
20399 arg4 = (int)(SWIG_As_int(obj3));
20400 if (SWIG_arg_fail(4)) SWIG_fail;
20401 }
20402 }
20403 {
20404 PyThreadState* __tstate = wxPyBeginAllowThreads();
20405 (arg1)->DrawSunkenEdge(*arg2,(wxRect const &)*arg3,arg4);
20406
20407 wxPyEndAllowThreads(__tstate);
20408 if (PyErr_Occurred()) SWIG_fail;
20409 }
20410 Py_INCREF(Py_None); resultobj = Py_None;
20411 return resultobj;
20412 fail:
20413 return NULL;
20414 }
20415
20416
20417 static PyObject *_wrap_Effects_TileBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
20418 PyObject *resultobj;
20419 wxEffects *arg1 = (wxEffects *) 0 ;
20420 wxRect *arg2 = 0 ;
20421 wxDC *arg3 = 0 ;
20422 wxBitmap *arg4 = 0 ;
20423 bool result;
20424 wxRect temp2 ;
20425 PyObject * obj0 = 0 ;
20426 PyObject * obj1 = 0 ;
20427 PyObject * obj2 = 0 ;
20428 PyObject * obj3 = 0 ;
20429 char *kwnames[] = {
20430 (char *) "self",(char *) "rect",(char *) "dc",(char *) "bitmap", NULL
20431 };
20432
20433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Effects_TileBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20435 if (SWIG_arg_fail(1)) SWIG_fail;
20436 {
20437 arg2 = &temp2;
20438 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
20439 }
20440 {
20441 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20442 if (SWIG_arg_fail(3)) SWIG_fail;
20443 if (arg3 == NULL) {
20444 SWIG_null_ref("wxDC");
20445 }
20446 if (SWIG_arg_fail(3)) SWIG_fail;
20447 }
20448 {
20449 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
20450 if (SWIG_arg_fail(4)) SWIG_fail;
20451 if (arg4 == NULL) {
20452 SWIG_null_ref("wxBitmap");
20453 }
20454 if (SWIG_arg_fail(4)) SWIG_fail;
20455 }
20456 {
20457 PyThreadState* __tstate = wxPyBeginAllowThreads();
20458 result = (bool)(arg1)->TileBitmap((wxRect const &)*arg2,*arg3,*arg4);
20459
20460 wxPyEndAllowThreads(__tstate);
20461 if (PyErr_Occurred()) SWIG_fail;
20462 }
20463 {
20464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20465 }
20466 return resultobj;
20467 fail:
20468 return NULL;
20469 }
20470
20471
20472 static PyObject * Effects_swigregister(PyObject *, PyObject *args) {
20473 PyObject *obj;
20474 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20475 SWIG_TypeClientData(SWIGTYPE_p_wxEffects, obj);
20476 Py_INCREF(obj);
20477 return Py_BuildValue((char *)"");
20478 }
20479 static PyMethodDef SwigMethods[] = {
20480 { (char *)"new_GDIObject", (PyCFunction) _wrap_new_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
20481 { (char *)"delete_GDIObject", (PyCFunction) _wrap_delete_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
20482 { (char *)"GDIObject_GetVisible", (PyCFunction) _wrap_GDIObject_GetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20483 { (char *)"GDIObject_SetVisible", (PyCFunction) _wrap_GDIObject_SetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20484 { (char *)"GDIObject_IsNull", (PyCFunction) _wrap_GDIObject_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
20485 { (char *)"GDIObject_swigregister", GDIObject_swigregister, METH_VARARGS, NULL},
20486 { (char *)"new_Colour", (PyCFunction) _wrap_new_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
20487 { (char *)"new_NamedColour", (PyCFunction) _wrap_new_NamedColour, METH_VARARGS | METH_KEYWORDS, NULL},
20488 { (char *)"new_ColourRGB", (PyCFunction) _wrap_new_ColourRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20489 { (char *)"delete_Colour", (PyCFunction) _wrap_delete_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
20490 { (char *)"Colour_Red", (PyCFunction) _wrap_Colour_Red, METH_VARARGS | METH_KEYWORDS, NULL},
20491 { (char *)"Colour_Green", (PyCFunction) _wrap_Colour_Green, METH_VARARGS | METH_KEYWORDS, NULL},
20492 { (char *)"Colour_Blue", (PyCFunction) _wrap_Colour_Blue, METH_VARARGS | METH_KEYWORDS, NULL},
20493 { (char *)"Colour_Ok", (PyCFunction) _wrap_Colour_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20494 { (char *)"Colour_Set", (PyCFunction) _wrap_Colour_Set, METH_VARARGS | METH_KEYWORDS, NULL},
20495 { (char *)"Colour_SetRGB", (PyCFunction) _wrap_Colour_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20496 { (char *)"Colour_SetFromName", (PyCFunction) _wrap_Colour_SetFromName, METH_VARARGS | METH_KEYWORDS, NULL},
20497 { (char *)"Colour_GetPixel", (PyCFunction) _wrap_Colour_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
20498 { (char *)"Colour___eq__", (PyCFunction) _wrap_Colour___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20499 { (char *)"Colour___ne__", (PyCFunction) _wrap_Colour___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20500 { (char *)"Colour_Get", (PyCFunction) _wrap_Colour_Get, METH_VARARGS | METH_KEYWORDS, NULL},
20501 { (char *)"Colour_GetRGB", (PyCFunction) _wrap_Colour_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20502 { (char *)"Colour_swigregister", Colour_swigregister, METH_VARARGS, NULL},
20503 { (char *)"new_Palette", (PyCFunction) _wrap_new_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
20504 { (char *)"delete_Palette", (PyCFunction) _wrap_delete_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
20505 { (char *)"Palette_GetPixel", (PyCFunction) _wrap_Palette_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
20506 { (char *)"Palette_GetRGB", (PyCFunction) _wrap_Palette_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20507 { (char *)"Palette_GetColoursCount", (PyCFunction) _wrap_Palette_GetColoursCount, METH_VARARGS | METH_KEYWORDS, NULL},
20508 { (char *)"Palette_Ok", (PyCFunction) _wrap_Palette_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20509 { (char *)"Palette_swigregister", Palette_swigregister, METH_VARARGS, NULL},
20510 { (char *)"new_Pen", (PyCFunction) _wrap_new_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
20511 { (char *)"delete_Pen", (PyCFunction) _wrap_delete_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
20512 { (char *)"Pen_GetCap", (PyCFunction) _wrap_Pen_GetCap, METH_VARARGS | METH_KEYWORDS, NULL},
20513 { (char *)"Pen_GetColour", (PyCFunction) _wrap_Pen_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20514 { (char *)"Pen_GetJoin", (PyCFunction) _wrap_Pen_GetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
20515 { (char *)"Pen_GetStyle", (PyCFunction) _wrap_Pen_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20516 { (char *)"Pen_GetWidth", (PyCFunction) _wrap_Pen_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20517 { (char *)"Pen_Ok", (PyCFunction) _wrap_Pen_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20518 { (char *)"Pen_SetCap", (PyCFunction) _wrap_Pen_SetCap, METH_VARARGS | METH_KEYWORDS, NULL},
20519 { (char *)"Pen_SetColour", (PyCFunction) _wrap_Pen_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20520 { (char *)"Pen_SetJoin", (PyCFunction) _wrap_Pen_SetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
20521 { (char *)"Pen_SetStyle", (PyCFunction) _wrap_Pen_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20522 { (char *)"Pen_SetWidth", (PyCFunction) _wrap_Pen_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20523 { (char *)"Pen_SetDashes", (PyCFunction) _wrap_Pen_SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
20524 { (char *)"Pen_GetDashes", (PyCFunction) _wrap_Pen_GetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
20525 { (char *)"Pen__SetDashes", (PyCFunction) _wrap_Pen__SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
20526 { (char *)"Pen_GetDashCount", (PyCFunction) _wrap_Pen_GetDashCount, METH_VARARGS | METH_KEYWORDS, NULL},
20527 { (char *)"Pen___eq__", (PyCFunction) _wrap_Pen___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20528 { (char *)"Pen___ne__", (PyCFunction) _wrap_Pen___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20529 { (char *)"Pen_swigregister", Pen_swigregister, METH_VARARGS, NULL},
20530 { (char *)"new_Brush", (PyCFunction) _wrap_new_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
20531 { (char *)"delete_Brush", (PyCFunction) _wrap_delete_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
20532 { (char *)"Brush_SetColour", (PyCFunction) _wrap_Brush_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20533 { (char *)"Brush_SetStyle", (PyCFunction) _wrap_Brush_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20534 { (char *)"Brush_SetStipple", (PyCFunction) _wrap_Brush_SetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
20535 { (char *)"Brush_GetColour", (PyCFunction) _wrap_Brush_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20536 { (char *)"Brush_GetStyle", (PyCFunction) _wrap_Brush_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20537 { (char *)"Brush_GetStipple", (PyCFunction) _wrap_Brush_GetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
20538 { (char *)"Brush_IsHatch", (PyCFunction) _wrap_Brush_IsHatch, METH_VARARGS | METH_KEYWORDS, NULL},
20539 { (char *)"Brush_Ok", (PyCFunction) _wrap_Brush_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20540 { (char *)"Brush_swigregister", Brush_swigregister, METH_VARARGS, NULL},
20541 { (char *)"new_Bitmap", (PyCFunction) _wrap_new_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20542 { (char *)"delete_Bitmap", (PyCFunction) _wrap_delete_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20543 { (char *)"new_EmptyBitmap", (PyCFunction) _wrap_new_EmptyBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20544 { (char *)"new_BitmapFromIcon", (PyCFunction) _wrap_new_BitmapFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20545 { (char *)"new_BitmapFromImage", (PyCFunction) _wrap_new_BitmapFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
20546 { (char *)"new_BitmapFromXPMData", (PyCFunction) _wrap_new_BitmapFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
20547 { (char *)"new_BitmapFromBits", (PyCFunction) _wrap_new_BitmapFromBits, METH_VARARGS | METH_KEYWORDS, NULL},
20548 { (char *)"Bitmap_Ok", (PyCFunction) _wrap_Bitmap_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20549 { (char *)"Bitmap_GetWidth", (PyCFunction) _wrap_Bitmap_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20550 { (char *)"Bitmap_GetHeight", (PyCFunction) _wrap_Bitmap_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20551 { (char *)"Bitmap_GetDepth", (PyCFunction) _wrap_Bitmap_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20552 { (char *)"Bitmap_GetSize", (PyCFunction) _wrap_Bitmap_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20553 { (char *)"Bitmap_ConvertToImage", (PyCFunction) _wrap_Bitmap_ConvertToImage, METH_VARARGS | METH_KEYWORDS, NULL},
20554 { (char *)"Bitmap_GetMask", (PyCFunction) _wrap_Bitmap_GetMask, METH_VARARGS | METH_KEYWORDS, NULL},
20555 { (char *)"Bitmap_SetMask", (PyCFunction) _wrap_Bitmap_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
20556 { (char *)"Bitmap_SetMaskColour", (PyCFunction) _wrap_Bitmap_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
20557 { (char *)"Bitmap_GetSubBitmap", (PyCFunction) _wrap_Bitmap_GetSubBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20558 { (char *)"Bitmap_SaveFile", (PyCFunction) _wrap_Bitmap_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
20559 { (char *)"Bitmap_LoadFile", (PyCFunction) _wrap_Bitmap_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
20560 { (char *)"Bitmap_GetPalette", (PyCFunction) _wrap_Bitmap_GetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
20561 { (char *)"Bitmap_CopyFromIcon", (PyCFunction) _wrap_Bitmap_CopyFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20562 { (char *)"Bitmap_SetHeight", (PyCFunction) _wrap_Bitmap_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20563 { (char *)"Bitmap_SetWidth", (PyCFunction) _wrap_Bitmap_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20564 { (char *)"Bitmap_SetDepth", (PyCFunction) _wrap_Bitmap_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20565 { (char *)"Bitmap_SetSize", (PyCFunction) _wrap_Bitmap_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20566 { (char *)"Bitmap___eq__", (PyCFunction) _wrap_Bitmap___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20567 { (char *)"Bitmap___ne__", (PyCFunction) _wrap_Bitmap___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20568 { (char *)"Bitmap_swigregister", Bitmap_swigregister, METH_VARARGS, NULL},
20569 { (char *)"new_Mask", (PyCFunction) _wrap_new_Mask, METH_VARARGS | METH_KEYWORDS, NULL},
20570 { (char *)"Mask_swigregister", Mask_swigregister, METH_VARARGS, NULL},
20571 { (char *)"new_Icon", (PyCFunction) _wrap_new_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
20572 { (char *)"delete_Icon", (PyCFunction) _wrap_delete_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
20573 { (char *)"new_EmptyIcon", (PyCFunction) _wrap_new_EmptyIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20574 { (char *)"new_IconFromLocation", (PyCFunction) _wrap_new_IconFromLocation, METH_VARARGS | METH_KEYWORDS, NULL},
20575 { (char *)"new_IconFromBitmap", (PyCFunction) _wrap_new_IconFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20576 { (char *)"new_IconFromXPMData", (PyCFunction) _wrap_new_IconFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
20577 { (char *)"Icon_LoadFile", (PyCFunction) _wrap_Icon_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
20578 { (char *)"Icon_Ok", (PyCFunction) _wrap_Icon_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20579 { (char *)"Icon_GetWidth", (PyCFunction) _wrap_Icon_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20580 { (char *)"Icon_GetHeight", (PyCFunction) _wrap_Icon_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20581 { (char *)"Icon_GetDepth", (PyCFunction) _wrap_Icon_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20582 { (char *)"Icon_SetWidth", (PyCFunction) _wrap_Icon_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20583 { (char *)"Icon_SetHeight", (PyCFunction) _wrap_Icon_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20584 { (char *)"Icon_SetDepth", (PyCFunction) _wrap_Icon_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20585 { (char *)"Icon_CopyFromBitmap", (PyCFunction) _wrap_Icon_CopyFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20586 { (char *)"Icon_swigregister", Icon_swigregister, METH_VARARGS, NULL},
20587 { (char *)"new_IconLocation", (PyCFunction) _wrap_new_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
20588 { (char *)"delete_IconLocation", (PyCFunction) _wrap_delete_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
20589 { (char *)"IconLocation_IsOk", (PyCFunction) _wrap_IconLocation_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
20590 { (char *)"IconLocation_SetFileName", (PyCFunction) _wrap_IconLocation_SetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
20591 { (char *)"IconLocation_GetFileName", (PyCFunction) _wrap_IconLocation_GetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
20592 { (char *)"IconLocation_SetIndex", (PyCFunction) _wrap_IconLocation_SetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
20593 { (char *)"IconLocation_GetIndex", (PyCFunction) _wrap_IconLocation_GetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
20594 { (char *)"IconLocation_swigregister", IconLocation_swigregister, METH_VARARGS, NULL},
20595 { (char *)"new_IconBundle", (PyCFunction) _wrap_new_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
20596 { (char *)"new_IconBundleFromFile", (PyCFunction) _wrap_new_IconBundleFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
20597 { (char *)"new_IconBundleFromIcon", (PyCFunction) _wrap_new_IconBundleFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20598 { (char *)"delete_IconBundle", (PyCFunction) _wrap_delete_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
20599 { (char *)"IconBundle_AddIcon", (PyCFunction) _wrap_IconBundle_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20600 { (char *)"IconBundle_AddIconFromFile", (PyCFunction) _wrap_IconBundle_AddIconFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
20601 { (char *)"IconBundle_GetIcon", (PyCFunction) _wrap_IconBundle_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20602 { (char *)"IconBundle_swigregister", IconBundle_swigregister, METH_VARARGS, NULL},
20603 { (char *)"new_Cursor", (PyCFunction) _wrap_new_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
20604 { (char *)"delete_Cursor", (PyCFunction) _wrap_delete_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
20605 { (char *)"new_StockCursor", (PyCFunction) _wrap_new_StockCursor, METH_VARARGS | METH_KEYWORDS, NULL},
20606 { (char *)"new_CursorFromImage", (PyCFunction) _wrap_new_CursorFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
20607 { (char *)"Cursor_Ok", (PyCFunction) _wrap_Cursor_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20608 { (char *)"Cursor_swigregister", Cursor_swigregister, METH_VARARGS, NULL},
20609 { (char *)"new_Region", (PyCFunction) _wrap_new_Region, METH_VARARGS | METH_KEYWORDS, NULL},
20610 { (char *)"new_RegionFromBitmap", (PyCFunction) _wrap_new_RegionFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20611 { (char *)"new_RegionFromBitmapColour", (PyCFunction) _wrap_new_RegionFromBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
20612 { (char *)"new_RegionFromPoints", (PyCFunction) _wrap_new_RegionFromPoints, METH_VARARGS | METH_KEYWORDS, NULL},
20613 { (char *)"delete_Region", (PyCFunction) _wrap_delete_Region, METH_VARARGS | METH_KEYWORDS, NULL},
20614 { (char *)"Region_Clear", (PyCFunction) _wrap_Region_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
20615 { (char *)"Region_Offset", (PyCFunction) _wrap_Region_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
20616 { (char *)"Region_Contains", (PyCFunction) _wrap_Region_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
20617 { (char *)"Region_ContainsPoint", (PyCFunction) _wrap_Region_ContainsPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20618 { (char *)"Region_ContainsRect", (PyCFunction) _wrap_Region_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
20619 { (char *)"Region_ContainsRectDim", (PyCFunction) _wrap_Region_ContainsRectDim, METH_VARARGS | METH_KEYWORDS, NULL},
20620 { (char *)"Region_GetBox", (PyCFunction) _wrap_Region_GetBox, METH_VARARGS | METH_KEYWORDS, NULL},
20621 { (char *)"Region_Intersect", (PyCFunction) _wrap_Region_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
20622 { (char *)"Region_IntersectRect", (PyCFunction) _wrap_Region_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
20623 { (char *)"Region_IntersectRegion", (PyCFunction) _wrap_Region_IntersectRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20624 { (char *)"Region_IsEmpty", (PyCFunction) _wrap_Region_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
20625 { (char *)"Region_Union", (PyCFunction) _wrap_Region_Union, METH_VARARGS | METH_KEYWORDS, NULL},
20626 { (char *)"Region_UnionRect", (PyCFunction) _wrap_Region_UnionRect, METH_VARARGS | METH_KEYWORDS, NULL},
20627 { (char *)"Region_UnionRegion", (PyCFunction) _wrap_Region_UnionRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20628 { (char *)"Region_Subtract", (PyCFunction) _wrap_Region_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
20629 { (char *)"Region_SubtractRect", (PyCFunction) _wrap_Region_SubtractRect, METH_VARARGS | METH_KEYWORDS, NULL},
20630 { (char *)"Region_SubtractRegion", (PyCFunction) _wrap_Region_SubtractRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20631 { (char *)"Region_Xor", (PyCFunction) _wrap_Region_Xor, METH_VARARGS | METH_KEYWORDS, NULL},
20632 { (char *)"Region_XorRect", (PyCFunction) _wrap_Region_XorRect, METH_VARARGS | METH_KEYWORDS, NULL},
20633 { (char *)"Region_XorRegion", (PyCFunction) _wrap_Region_XorRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20634 { (char *)"Region_ConvertToBitmap", (PyCFunction) _wrap_Region_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20635 { (char *)"Region_UnionBitmap", (PyCFunction) _wrap_Region_UnionBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20636 { (char *)"Region_UnionBitmapColour", (PyCFunction) _wrap_Region_UnionBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
20637 { (char *)"Region_swigregister", Region_swigregister, METH_VARARGS, NULL},
20638 { (char *)"new_RegionIterator", (PyCFunction) _wrap_new_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
20639 { (char *)"delete_RegionIterator", (PyCFunction) _wrap_delete_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
20640 { (char *)"RegionIterator_GetX", (PyCFunction) _wrap_RegionIterator_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
20641 { (char *)"RegionIterator_GetY", (PyCFunction) _wrap_RegionIterator_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
20642 { (char *)"RegionIterator_GetW", (PyCFunction) _wrap_RegionIterator_GetW, METH_VARARGS | METH_KEYWORDS, NULL},
20643 { (char *)"RegionIterator_GetWidth", (PyCFunction) _wrap_RegionIterator_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20644 { (char *)"RegionIterator_GetH", (PyCFunction) _wrap_RegionIterator_GetH, METH_VARARGS | METH_KEYWORDS, NULL},
20645 { (char *)"RegionIterator_GetHeight", (PyCFunction) _wrap_RegionIterator_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20646 { (char *)"RegionIterator_GetRect", (PyCFunction) _wrap_RegionIterator_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
20647 { (char *)"RegionIterator_HaveRects", (PyCFunction) _wrap_RegionIterator_HaveRects, METH_VARARGS | METH_KEYWORDS, NULL},
20648 { (char *)"RegionIterator_Reset", (PyCFunction) _wrap_RegionIterator_Reset, METH_VARARGS | METH_KEYWORDS, NULL},
20649 { (char *)"RegionIterator_Next", (PyCFunction) _wrap_RegionIterator_Next, METH_VARARGS | METH_KEYWORDS, NULL},
20650 { (char *)"RegionIterator___nonzero__", (PyCFunction) _wrap_RegionIterator___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
20651 { (char *)"RegionIterator_swigregister", RegionIterator_swigregister, METH_VARARGS, NULL},
20652 { (char *)"new_NativeFontInfo", (PyCFunction) _wrap_new_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20653 { (char *)"delete_NativeFontInfo", (PyCFunction) _wrap_delete_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20654 { (char *)"NativeFontInfo_Init", (PyCFunction) _wrap_NativeFontInfo_Init, METH_VARARGS | METH_KEYWORDS, NULL},
20655 { (char *)"NativeFontInfo_InitFromFont", (PyCFunction) _wrap_NativeFontInfo_InitFromFont, METH_VARARGS | METH_KEYWORDS, NULL},
20656 { (char *)"NativeFontInfo_GetPointSize", (PyCFunction) _wrap_NativeFontInfo_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20657 { (char *)"NativeFontInfo_GetStyle", (PyCFunction) _wrap_NativeFontInfo_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20658 { (char *)"NativeFontInfo_GetWeight", (PyCFunction) _wrap_NativeFontInfo_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20659 { (char *)"NativeFontInfo_GetUnderlined", (PyCFunction) _wrap_NativeFontInfo_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20660 { (char *)"NativeFontInfo_GetFaceName", (PyCFunction) _wrap_NativeFontInfo_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20661 { (char *)"NativeFontInfo_GetFamily", (PyCFunction) _wrap_NativeFontInfo_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20662 { (char *)"NativeFontInfo_GetEncoding", (PyCFunction) _wrap_NativeFontInfo_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20663 { (char *)"NativeFontInfo_SetPointSize", (PyCFunction) _wrap_NativeFontInfo_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20664 { (char *)"NativeFontInfo_SetStyle", (PyCFunction) _wrap_NativeFontInfo_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20665 { (char *)"NativeFontInfo_SetWeight", (PyCFunction) _wrap_NativeFontInfo_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20666 { (char *)"NativeFontInfo_SetUnderlined", (PyCFunction) _wrap_NativeFontInfo_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20667 { (char *)"NativeFontInfo_SetFaceName", (PyCFunction) _wrap_NativeFontInfo_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20668 { (char *)"NativeFontInfo_SetFamily", (PyCFunction) _wrap_NativeFontInfo_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20669 { (char *)"NativeFontInfo_SetEncoding", (PyCFunction) _wrap_NativeFontInfo_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20670 { (char *)"NativeFontInfo_FromString", (PyCFunction) _wrap_NativeFontInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
20671 { (char *)"NativeFontInfo_ToString", (PyCFunction) _wrap_NativeFontInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
20672 { (char *)"NativeFontInfo___str__", (PyCFunction) _wrap_NativeFontInfo___str__, METH_VARARGS | METH_KEYWORDS, NULL},
20673 { (char *)"NativeFontInfo_FromUserString", (PyCFunction) _wrap_NativeFontInfo_FromUserString, METH_VARARGS | METH_KEYWORDS, NULL},
20674 { (char *)"NativeFontInfo_ToUserString", (PyCFunction) _wrap_NativeFontInfo_ToUserString, METH_VARARGS | METH_KEYWORDS, NULL},
20675 { (char *)"NativeFontInfo_swigregister", NativeFontInfo_swigregister, METH_VARARGS, NULL},
20676 { (char *)"NativeEncodingInfo_facename_set", (PyCFunction) _wrap_NativeEncodingInfo_facename_set, METH_VARARGS | METH_KEYWORDS, NULL},
20677 { (char *)"NativeEncodingInfo_facename_get", (PyCFunction) _wrap_NativeEncodingInfo_facename_get, METH_VARARGS | METH_KEYWORDS, NULL},
20678 { (char *)"NativeEncodingInfo_encoding_set", (PyCFunction) _wrap_NativeEncodingInfo_encoding_set, METH_VARARGS | METH_KEYWORDS, NULL},
20679 { (char *)"NativeEncodingInfo_encoding_get", (PyCFunction) _wrap_NativeEncodingInfo_encoding_get, METH_VARARGS | METH_KEYWORDS, NULL},
20680 { (char *)"new_NativeEncodingInfo", (PyCFunction) _wrap_new_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20681 { (char *)"delete_NativeEncodingInfo", (PyCFunction) _wrap_delete_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20682 { (char *)"NativeEncodingInfo_FromString", (PyCFunction) _wrap_NativeEncodingInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
20683 { (char *)"NativeEncodingInfo_ToString", (PyCFunction) _wrap_NativeEncodingInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
20684 { (char *)"NativeEncodingInfo_swigregister", NativeEncodingInfo_swigregister, METH_VARARGS, NULL},
20685 { (char *)"GetNativeFontEncoding", (PyCFunction) _wrap_GetNativeFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20686 { (char *)"TestFontEncoding", (PyCFunction) _wrap_TestFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20687 { (char *)"new_FontMapper", (PyCFunction) _wrap_new_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
20688 { (char *)"delete_FontMapper", (PyCFunction) _wrap_delete_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
20689 { (char *)"FontMapper_Get", (PyCFunction) _wrap_FontMapper_Get, METH_VARARGS | METH_KEYWORDS, NULL},
20690 { (char *)"FontMapper_Set", (PyCFunction) _wrap_FontMapper_Set, METH_VARARGS | METH_KEYWORDS, NULL},
20691 { (char *)"FontMapper_CharsetToEncoding", (PyCFunction) _wrap_FontMapper_CharsetToEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20692 { (char *)"FontMapper_GetSupportedEncodingsCount", (PyCFunction) _wrap_FontMapper_GetSupportedEncodingsCount, METH_VARARGS | METH_KEYWORDS, NULL},
20693 { (char *)"FontMapper_GetEncoding", (PyCFunction) _wrap_FontMapper_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20694 { (char *)"FontMapper_GetEncodingName", (PyCFunction) _wrap_FontMapper_GetEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
20695 { (char *)"FontMapper_GetEncodingDescription", (PyCFunction) _wrap_FontMapper_GetEncodingDescription, METH_VARARGS | METH_KEYWORDS, NULL},
20696 { (char *)"FontMapper_GetEncodingFromName", (PyCFunction) _wrap_FontMapper_GetEncodingFromName, METH_VARARGS | METH_KEYWORDS, NULL},
20697 { (char *)"FontMapper_SetConfig", (PyCFunction) _wrap_FontMapper_SetConfig, METH_VARARGS | METH_KEYWORDS, NULL},
20698 { (char *)"FontMapper_SetConfigPath", (PyCFunction) _wrap_FontMapper_SetConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
20699 { (char *)"FontMapper_GetDefaultConfigPath", (PyCFunction) _wrap_FontMapper_GetDefaultConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
20700 { (char *)"FontMapper_GetAltForEncoding", (PyCFunction) _wrap_FontMapper_GetAltForEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20701 { (char *)"FontMapper_IsEncodingAvailable", (PyCFunction) _wrap_FontMapper_IsEncodingAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
20702 { (char *)"FontMapper_SetDialogParent", (PyCFunction) _wrap_FontMapper_SetDialogParent, METH_VARARGS | METH_KEYWORDS, NULL},
20703 { (char *)"FontMapper_SetDialogTitle", (PyCFunction) _wrap_FontMapper_SetDialogTitle, METH_VARARGS | METH_KEYWORDS, NULL},
20704 { (char *)"FontMapper_swigregister", FontMapper_swigregister, METH_VARARGS, NULL},
20705 { (char *)"new_Font", (PyCFunction) _wrap_new_Font, METH_VARARGS | METH_KEYWORDS, NULL},
20706 { (char *)"delete_Font", (PyCFunction) _wrap_delete_Font, METH_VARARGS | METH_KEYWORDS, NULL},
20707 { (char *)"new_FontFromNativeInfo", (PyCFunction) _wrap_new_FontFromNativeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20708 { (char *)"new_FontFromNativeInfoString", (PyCFunction) _wrap_new_FontFromNativeInfoString, METH_VARARGS | METH_KEYWORDS, NULL},
20709 { (char *)"new_Font2", (PyCFunction) _wrap_new_Font2, METH_VARARGS | METH_KEYWORDS, NULL},
20710 { (char *)"new_FontFromPixelSize", (PyCFunction) _wrap_new_FontFromPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20711 { (char *)"Font_Ok", (PyCFunction) _wrap_Font_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20712 { (char *)"Font___eq__", (PyCFunction) _wrap_Font___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20713 { (char *)"Font___ne__", (PyCFunction) _wrap_Font___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20714 { (char *)"Font_GetPointSize", (PyCFunction) _wrap_Font_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20715 { (char *)"Font_GetPixelSize", (PyCFunction) _wrap_Font_GetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20716 { (char *)"Font_IsUsingSizeInPixels", (PyCFunction) _wrap_Font_IsUsingSizeInPixels, METH_VARARGS | METH_KEYWORDS, NULL},
20717 { (char *)"Font_GetFamily", (PyCFunction) _wrap_Font_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20718 { (char *)"Font_GetStyle", (PyCFunction) _wrap_Font_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20719 { (char *)"Font_GetWeight", (PyCFunction) _wrap_Font_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20720 { (char *)"Font_GetUnderlined", (PyCFunction) _wrap_Font_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20721 { (char *)"Font_GetFaceName", (PyCFunction) _wrap_Font_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20722 { (char *)"Font_GetEncoding", (PyCFunction) _wrap_Font_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20723 { (char *)"Font_GetNativeFontInfo", (PyCFunction) _wrap_Font_GetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20724 { (char *)"Font_IsFixedWidth", (PyCFunction) _wrap_Font_IsFixedWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20725 { (char *)"Font_GetNativeFontInfoDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoDesc, METH_VARARGS | METH_KEYWORDS, NULL},
20726 { (char *)"Font_GetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
20727 { (char *)"Font_SetPointSize", (PyCFunction) _wrap_Font_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20728 { (char *)"Font_SetPixelSize", (PyCFunction) _wrap_Font_SetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20729 { (char *)"Font_SetFamily", (PyCFunction) _wrap_Font_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20730 { (char *)"Font_SetStyle", (PyCFunction) _wrap_Font_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20731 { (char *)"Font_SetWeight", (PyCFunction) _wrap_Font_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20732 { (char *)"Font_SetFaceName", (PyCFunction) _wrap_Font_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20733 { (char *)"Font_SetUnderlined", (PyCFunction) _wrap_Font_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20734 { (char *)"Font_SetEncoding", (PyCFunction) _wrap_Font_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20735 { (char *)"Font_SetNativeFontInfo", (PyCFunction) _wrap_Font_SetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20736 { (char *)"Font_SetNativeFontInfoFromString", (PyCFunction) _wrap_Font_SetNativeFontInfoFromString, METH_VARARGS | METH_KEYWORDS, NULL},
20737 { (char *)"Font_SetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_SetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
20738 { (char *)"Font_GetFamilyString", (PyCFunction) _wrap_Font_GetFamilyString, METH_VARARGS | METH_KEYWORDS, NULL},
20739 { (char *)"Font_GetStyleString", (PyCFunction) _wrap_Font_GetStyleString, METH_VARARGS | METH_KEYWORDS, NULL},
20740 { (char *)"Font_GetWeightString", (PyCFunction) _wrap_Font_GetWeightString, METH_VARARGS | METH_KEYWORDS, NULL},
20741 { (char *)"Font_SetNoAntiAliasing", (PyCFunction) _wrap_Font_SetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
20742 { (char *)"Font_GetNoAntiAliasing", (PyCFunction) _wrap_Font_GetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
20743 { (char *)"Font_GetDefaultEncoding", (PyCFunction) _wrap_Font_GetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20744 { (char *)"Font_SetDefaultEncoding", (PyCFunction) _wrap_Font_SetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20745 { (char *)"Font_swigregister", Font_swigregister, METH_VARARGS, NULL},
20746 { (char *)"new_FontEnumerator", (PyCFunction) _wrap_new_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
20747 { (char *)"delete_FontEnumerator", (PyCFunction) _wrap_delete_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
20748 { (char *)"FontEnumerator__setCallbackInfo", (PyCFunction) _wrap_FontEnumerator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20749 { (char *)"FontEnumerator_EnumerateFacenames", (PyCFunction) _wrap_FontEnumerator_EnumerateFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
20750 { (char *)"FontEnumerator_EnumerateEncodings", (PyCFunction) _wrap_FontEnumerator_EnumerateEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
20751 { (char *)"FontEnumerator_GetEncodings", (PyCFunction) _wrap_FontEnumerator_GetEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
20752 { (char *)"FontEnumerator_GetFacenames", (PyCFunction) _wrap_FontEnumerator_GetFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
20753 { (char *)"FontEnumerator_swigregister", FontEnumerator_swigregister, METH_VARARGS, NULL},
20754 { (char *)"LanguageInfo_Language_set", (PyCFunction) _wrap_LanguageInfo_Language_set, METH_VARARGS | METH_KEYWORDS, NULL},
20755 { (char *)"LanguageInfo_Language_get", (PyCFunction) _wrap_LanguageInfo_Language_get, METH_VARARGS | METH_KEYWORDS, NULL},
20756 { (char *)"LanguageInfo_CanonicalName_set", (PyCFunction) _wrap_LanguageInfo_CanonicalName_set, METH_VARARGS | METH_KEYWORDS, NULL},
20757 { (char *)"LanguageInfo_CanonicalName_get", (PyCFunction) _wrap_LanguageInfo_CanonicalName_get, METH_VARARGS | METH_KEYWORDS, NULL},
20758 { (char *)"LanguageInfo_Description_set", (PyCFunction) _wrap_LanguageInfo_Description_set, METH_VARARGS | METH_KEYWORDS, NULL},
20759 { (char *)"LanguageInfo_Description_get", (PyCFunction) _wrap_LanguageInfo_Description_get, METH_VARARGS | METH_KEYWORDS, NULL},
20760 { (char *)"LanguageInfo_swigregister", LanguageInfo_swigregister, METH_VARARGS, NULL},
20761 { (char *)"new_Locale", (PyCFunction) _wrap_new_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
20762 { (char *)"delete_Locale", (PyCFunction) _wrap_delete_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
20763 { (char *)"Locale_Init1", (PyCFunction) _wrap_Locale_Init1, METH_VARARGS | METH_KEYWORDS, NULL},
20764 { (char *)"Locale_Init2", (PyCFunction) _wrap_Locale_Init2, METH_VARARGS | METH_KEYWORDS, NULL},
20765 { (char *)"Locale_GetSystemLanguage", (PyCFunction) _wrap_Locale_GetSystemLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
20766 { (char *)"Locale_GetSystemEncoding", (PyCFunction) _wrap_Locale_GetSystemEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20767 { (char *)"Locale_GetSystemEncodingName", (PyCFunction) _wrap_Locale_GetSystemEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
20768 { (char *)"Locale_IsOk", (PyCFunction) _wrap_Locale_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
20769 { (char *)"Locale_GetLocale", (PyCFunction) _wrap_Locale_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
20770 { (char *)"Locale_GetLanguage", (PyCFunction) _wrap_Locale_GetLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
20771 { (char *)"Locale_GetSysName", (PyCFunction) _wrap_Locale_GetSysName, METH_VARARGS | METH_KEYWORDS, NULL},
20772 { (char *)"Locale_GetCanonicalName", (PyCFunction) _wrap_Locale_GetCanonicalName, METH_VARARGS | METH_KEYWORDS, NULL},
20773 { (char *)"Locale_AddCatalogLookupPathPrefix", (PyCFunction) _wrap_Locale_AddCatalogLookupPathPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
20774 { (char *)"Locale_AddCatalog", (PyCFunction) _wrap_Locale_AddCatalog, METH_VARARGS | METH_KEYWORDS, NULL},
20775 { (char *)"Locale_IsLoaded", (PyCFunction) _wrap_Locale_IsLoaded, METH_VARARGS | METH_KEYWORDS, NULL},
20776 { (char *)"Locale_GetLanguageInfo", (PyCFunction) _wrap_Locale_GetLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20777 { (char *)"Locale_GetLanguageName", (PyCFunction) _wrap_Locale_GetLanguageName, METH_VARARGS | METH_KEYWORDS, NULL},
20778 { (char *)"Locale_FindLanguageInfo", (PyCFunction) _wrap_Locale_FindLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20779 { (char *)"Locale_AddLanguage", (PyCFunction) _wrap_Locale_AddLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
20780 { (char *)"Locale_GetString", (PyCFunction) _wrap_Locale_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
20781 { (char *)"Locale_GetName", (PyCFunction) _wrap_Locale_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
20782 { (char *)"Locale_swigregister", Locale_swigregister, METH_VARARGS, NULL},
20783 { (char *)"GetLocale", (PyCFunction) _wrap_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
20784 { (char *)"GetTranslation", _wrap_GetTranslation, METH_VARARGS, NULL},
20785 { (char *)"new_EncodingConverter", (PyCFunction) _wrap_new_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
20786 { (char *)"delete_EncodingConverter", (PyCFunction) _wrap_delete_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
20787 { (char *)"EncodingConverter_Init", (PyCFunction) _wrap_EncodingConverter_Init, METH_VARARGS | METH_KEYWORDS, NULL},
20788 { (char *)"EncodingConverter_Convert", (PyCFunction) _wrap_EncodingConverter_Convert, METH_VARARGS | METH_KEYWORDS, NULL},
20789 { (char *)"EncodingConverter_GetPlatformEquivalents", (PyCFunction) _wrap_EncodingConverter_GetPlatformEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
20790 { (char *)"EncodingConverter_GetAllEquivalents", (PyCFunction) _wrap_EncodingConverter_GetAllEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
20791 { (char *)"EncodingConverter_CanConvert", (PyCFunction) _wrap_EncodingConverter_CanConvert, METH_VARARGS | METH_KEYWORDS, NULL},
20792 { (char *)"EncodingConverter_swigregister", EncodingConverter_swigregister, METH_VARARGS, NULL},
20793 { (char *)"delete_DC", (PyCFunction) _wrap_delete_DC, METH_VARARGS | METH_KEYWORDS, NULL},
20794 { (char *)"DC_BeginDrawing", (PyCFunction) _wrap_DC_BeginDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
20795 { (char *)"DC_EndDrawing", (PyCFunction) _wrap_DC_EndDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
20796 { (char *)"DC_FloodFill", (PyCFunction) _wrap_DC_FloodFill, METH_VARARGS | METH_KEYWORDS, NULL},
20797 { (char *)"DC_FloodFillPoint", (PyCFunction) _wrap_DC_FloodFillPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20798 { (char *)"DC_GetPixel", (PyCFunction) _wrap_DC_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
20799 { (char *)"DC_GetPixelPoint", (PyCFunction) _wrap_DC_GetPixelPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20800 { (char *)"DC_DrawLine", (PyCFunction) _wrap_DC_DrawLine, METH_VARARGS | METH_KEYWORDS, NULL},
20801 { (char *)"DC_DrawLinePoint", (PyCFunction) _wrap_DC_DrawLinePoint, METH_VARARGS | METH_KEYWORDS, NULL},
20802 { (char *)"DC_CrossHair", (PyCFunction) _wrap_DC_CrossHair, METH_VARARGS | METH_KEYWORDS, NULL},
20803 { (char *)"DC_CrossHairPoint", (PyCFunction) _wrap_DC_CrossHairPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20804 { (char *)"DC_DrawArc", (PyCFunction) _wrap_DC_DrawArc, METH_VARARGS | METH_KEYWORDS, NULL},
20805 { (char *)"DC_DrawArcPoint", (PyCFunction) _wrap_DC_DrawArcPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20806 { (char *)"DC_DrawCheckMark", (PyCFunction) _wrap_DC_DrawCheckMark, METH_VARARGS | METH_KEYWORDS, NULL},
20807 { (char *)"DC_DrawCheckMarkRect", (PyCFunction) _wrap_DC_DrawCheckMarkRect, METH_VARARGS | METH_KEYWORDS, NULL},
20808 { (char *)"DC_DrawEllipticArc", (PyCFunction) _wrap_DC_DrawEllipticArc, METH_VARARGS | METH_KEYWORDS, NULL},
20809 { (char *)"DC_DrawEllipticArcPointSize", (PyCFunction) _wrap_DC_DrawEllipticArcPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20810 { (char *)"DC_DrawPoint", (PyCFunction) _wrap_DC_DrawPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20811 { (char *)"DC_DrawPointPoint", (PyCFunction) _wrap_DC_DrawPointPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20812 { (char *)"DC_DrawRectangle", (PyCFunction) _wrap_DC_DrawRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
20813 { (char *)"DC_DrawRectangleRect", (PyCFunction) _wrap_DC_DrawRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
20814 { (char *)"DC_DrawRectanglePointSize", (PyCFunction) _wrap_DC_DrawRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20815 { (char *)"DC_DrawRoundedRectangle", (PyCFunction) _wrap_DC_DrawRoundedRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
20816 { (char *)"DC_DrawRoundedRectangleRect", (PyCFunction) _wrap_DC_DrawRoundedRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
20817 { (char *)"DC_DrawRoundedRectanglePointSize", (PyCFunction) _wrap_DC_DrawRoundedRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20818 { (char *)"DC_DrawCircle", (PyCFunction) _wrap_DC_DrawCircle, METH_VARARGS | METH_KEYWORDS, NULL},
20819 { (char *)"DC_DrawCirclePoint", (PyCFunction) _wrap_DC_DrawCirclePoint, METH_VARARGS | METH_KEYWORDS, NULL},
20820 { (char *)"DC_DrawEllipse", (PyCFunction) _wrap_DC_DrawEllipse, METH_VARARGS | METH_KEYWORDS, NULL},
20821 { (char *)"DC_DrawEllipseRect", (PyCFunction) _wrap_DC_DrawEllipseRect, METH_VARARGS | METH_KEYWORDS, NULL},
20822 { (char *)"DC_DrawEllipsePointSize", (PyCFunction) _wrap_DC_DrawEllipsePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20823 { (char *)"DC_DrawIcon", (PyCFunction) _wrap_DC_DrawIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20824 { (char *)"DC_DrawIconPoint", (PyCFunction) _wrap_DC_DrawIconPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20825 { (char *)"DC_DrawBitmap", (PyCFunction) _wrap_DC_DrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20826 { (char *)"DC_DrawBitmapPoint", (PyCFunction) _wrap_DC_DrawBitmapPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20827 { (char *)"DC_DrawText", (PyCFunction) _wrap_DC_DrawText, METH_VARARGS | METH_KEYWORDS, NULL},
20828 { (char *)"DC_DrawTextPoint", (PyCFunction) _wrap_DC_DrawTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20829 { (char *)"DC_DrawRotatedText", (PyCFunction) _wrap_DC_DrawRotatedText, METH_VARARGS | METH_KEYWORDS, NULL},
20830 { (char *)"DC_DrawRotatedTextPoint", (PyCFunction) _wrap_DC_DrawRotatedTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20831 { (char *)"DC_Blit", (PyCFunction) _wrap_DC_Blit, METH_VARARGS | METH_KEYWORDS, NULL},
20832 { (char *)"DC_BlitPointSize", (PyCFunction) _wrap_DC_BlitPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20833 { (char *)"DC_SetClippingRegion", (PyCFunction) _wrap_DC_SetClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20834 { (char *)"DC_SetClippingRegionPointSize", (PyCFunction) _wrap_DC_SetClippingRegionPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20835 { (char *)"DC_SetClippingRegionAsRegion", (PyCFunction) _wrap_DC_SetClippingRegionAsRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20836 { (char *)"DC_SetClippingRect", (PyCFunction) _wrap_DC_SetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
20837 { (char *)"DC_DrawLines", (PyCFunction) _wrap_DC_DrawLines, METH_VARARGS | METH_KEYWORDS, NULL},
20838 { (char *)"DC_DrawPolygon", (PyCFunction) _wrap_DC_DrawPolygon, METH_VARARGS | METH_KEYWORDS, NULL},
20839 { (char *)"DC_DrawLabel", (PyCFunction) _wrap_DC_DrawLabel, METH_VARARGS | METH_KEYWORDS, NULL},
20840 { (char *)"DC_DrawImageLabel", (PyCFunction) _wrap_DC_DrawImageLabel, METH_VARARGS | METH_KEYWORDS, NULL},
20841 { (char *)"DC_DrawSpline", (PyCFunction) _wrap_DC_DrawSpline, METH_VARARGS | METH_KEYWORDS, NULL},
20842 { (char *)"DC_Clear", (PyCFunction) _wrap_DC_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
20843 { (char *)"DC_StartDoc", (PyCFunction) _wrap_DC_StartDoc, METH_VARARGS | METH_KEYWORDS, NULL},
20844 { (char *)"DC_EndDoc", (PyCFunction) _wrap_DC_EndDoc, METH_VARARGS | METH_KEYWORDS, NULL},
20845 { (char *)"DC_StartPage", (PyCFunction) _wrap_DC_StartPage, METH_VARARGS | METH_KEYWORDS, NULL},
20846 { (char *)"DC_EndPage", (PyCFunction) _wrap_DC_EndPage, METH_VARARGS | METH_KEYWORDS, NULL},
20847 { (char *)"DC_SetFont", (PyCFunction) _wrap_DC_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
20848 { (char *)"DC_SetPen", (PyCFunction) _wrap_DC_SetPen, METH_VARARGS | METH_KEYWORDS, NULL},
20849 { (char *)"DC_SetBrush", (PyCFunction) _wrap_DC_SetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
20850 { (char *)"DC_SetBackground", (PyCFunction) _wrap_DC_SetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20851 { (char *)"DC_SetBackgroundMode", (PyCFunction) _wrap_DC_SetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
20852 { (char *)"DC_SetPalette", (PyCFunction) _wrap_DC_SetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
20853 { (char *)"DC_DestroyClippingRegion", (PyCFunction) _wrap_DC_DestroyClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20854 { (char *)"DC_GetClippingBox", (PyCFunction) _wrap_DC_GetClippingBox, METH_VARARGS | METH_KEYWORDS, NULL},
20855 { (char *)"DC_GetClippingRect", (PyCFunction) _wrap_DC_GetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
20856 { (char *)"DC_GetCharHeight", (PyCFunction) _wrap_DC_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20857 { (char *)"DC_GetCharWidth", (PyCFunction) _wrap_DC_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20858 { (char *)"DC_GetTextExtent", (PyCFunction) _wrap_DC_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
20859 { (char *)"DC_GetFullTextExtent", (PyCFunction) _wrap_DC_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
20860 { (char *)"DC_GetMultiLineTextExtent", (PyCFunction) _wrap_DC_GetMultiLineTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
20861 { (char *)"DC_GetPartialTextExtents", (PyCFunction) _wrap_DC_GetPartialTextExtents, METH_VARARGS | METH_KEYWORDS, NULL},
20862 { (char *)"DC_GetSize", (PyCFunction) _wrap_DC_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20863 { (char *)"DC_GetSizeTuple", (PyCFunction) _wrap_DC_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
20864 { (char *)"DC_GetSizeMM", (PyCFunction) _wrap_DC_GetSizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
20865 { (char *)"DC_GetSizeMMTuple", (PyCFunction) _wrap_DC_GetSizeMMTuple, METH_VARARGS | METH_KEYWORDS, NULL},
20866 { (char *)"DC_DeviceToLogicalX", (PyCFunction) _wrap_DC_DeviceToLogicalX, METH_VARARGS | METH_KEYWORDS, NULL},
20867 { (char *)"DC_DeviceToLogicalY", (PyCFunction) _wrap_DC_DeviceToLogicalY, METH_VARARGS | METH_KEYWORDS, NULL},
20868 { (char *)"DC_DeviceToLogicalXRel", (PyCFunction) _wrap_DC_DeviceToLogicalXRel, METH_VARARGS | METH_KEYWORDS, NULL},
20869 { (char *)"DC_DeviceToLogicalYRel", (PyCFunction) _wrap_DC_DeviceToLogicalYRel, METH_VARARGS | METH_KEYWORDS, NULL},
20870 { (char *)"DC_LogicalToDeviceX", (PyCFunction) _wrap_DC_LogicalToDeviceX, METH_VARARGS | METH_KEYWORDS, NULL},
20871 { (char *)"DC_LogicalToDeviceY", (PyCFunction) _wrap_DC_LogicalToDeviceY, METH_VARARGS | METH_KEYWORDS, NULL},
20872 { (char *)"DC_LogicalToDeviceXRel", (PyCFunction) _wrap_DC_LogicalToDeviceXRel, METH_VARARGS | METH_KEYWORDS, NULL},
20873 { (char *)"DC_LogicalToDeviceYRel", (PyCFunction) _wrap_DC_LogicalToDeviceYRel, METH_VARARGS | METH_KEYWORDS, NULL},
20874 { (char *)"DC_CanDrawBitmap", (PyCFunction) _wrap_DC_CanDrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20875 { (char *)"DC_CanGetTextExtent", (PyCFunction) _wrap_DC_CanGetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
20876 { (char *)"DC_GetDepth", (PyCFunction) _wrap_DC_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20877 { (char *)"DC_GetPPI", (PyCFunction) _wrap_DC_GetPPI, METH_VARARGS | METH_KEYWORDS, NULL},
20878 { (char *)"DC_Ok", (PyCFunction) _wrap_DC_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20879 { (char *)"DC_GetBackgroundMode", (PyCFunction) _wrap_DC_GetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
20880 { (char *)"DC_GetBackground", (PyCFunction) _wrap_DC_GetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20881 { (char *)"DC_GetBrush", (PyCFunction) _wrap_DC_GetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
20882 { (char *)"DC_GetFont", (PyCFunction) _wrap_DC_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
20883 { (char *)"DC_GetPen", (PyCFunction) _wrap_DC_GetPen, METH_VARARGS | METH_KEYWORDS, NULL},
20884 { (char *)"DC_GetTextBackground", (PyCFunction) _wrap_DC_GetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20885 { (char *)"DC_GetTextForeground", (PyCFunction) _wrap_DC_GetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
20886 { (char *)"DC_SetTextForeground", (PyCFunction) _wrap_DC_SetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
20887 { (char *)"DC_SetTextBackground", (PyCFunction) _wrap_DC_SetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20888 { (char *)"DC_GetMapMode", (PyCFunction) _wrap_DC_GetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
20889 { (char *)"DC_SetMapMode", (PyCFunction) _wrap_DC_SetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
20890 { (char *)"DC_GetUserScale", (PyCFunction) _wrap_DC_GetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
20891 { (char *)"DC_SetUserScale", (PyCFunction) _wrap_DC_SetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
20892 { (char *)"DC_GetLogicalScale", (PyCFunction) _wrap_DC_GetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
20893 { (char *)"DC_SetLogicalScale", (PyCFunction) _wrap_DC_SetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
20894 { (char *)"DC_GetLogicalOrigin", (PyCFunction) _wrap_DC_GetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
20895 { (char *)"DC_GetLogicalOriginTuple", (PyCFunction) _wrap_DC_GetLogicalOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
20896 { (char *)"DC_SetLogicalOrigin", (PyCFunction) _wrap_DC_SetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
20897 { (char *)"DC_SetLogicalOriginPoint", (PyCFunction) _wrap_DC_SetLogicalOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20898 { (char *)"DC_GetDeviceOrigin", (PyCFunction) _wrap_DC_GetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
20899 { (char *)"DC_GetDeviceOriginTuple", (PyCFunction) _wrap_DC_GetDeviceOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
20900 { (char *)"DC_SetDeviceOrigin", (PyCFunction) _wrap_DC_SetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
20901 { (char *)"DC_SetDeviceOriginPoint", (PyCFunction) _wrap_DC_SetDeviceOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20902 { (char *)"DC_SetAxisOrientation", (PyCFunction) _wrap_DC_SetAxisOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
20903 { (char *)"DC_GetLogicalFunction", (PyCFunction) _wrap_DC_GetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
20904 { (char *)"DC_SetLogicalFunction", (PyCFunction) _wrap_DC_SetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
20905 { (char *)"DC_ComputeScaleAndOrigin", (PyCFunction) _wrap_DC_ComputeScaleAndOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
20906 { (char *)"DC_CalcBoundingBox", (PyCFunction) _wrap_DC_CalcBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
20907 { (char *)"DC_CalcBoundingBoxPoint", (PyCFunction) _wrap_DC_CalcBoundingBoxPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20908 { (char *)"DC_ResetBoundingBox", (PyCFunction) _wrap_DC_ResetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
20909 { (char *)"DC_MinX", (PyCFunction) _wrap_DC_MinX, METH_VARARGS | METH_KEYWORDS, NULL},
20910 { (char *)"DC_MaxX", (PyCFunction) _wrap_DC_MaxX, METH_VARARGS | METH_KEYWORDS, NULL},
20911 { (char *)"DC_MinY", (PyCFunction) _wrap_DC_MinY, METH_VARARGS | METH_KEYWORDS, NULL},
20912 { (char *)"DC_MaxY", (PyCFunction) _wrap_DC_MaxY, METH_VARARGS | METH_KEYWORDS, NULL},
20913 { (char *)"DC_GetBoundingBox", (PyCFunction) _wrap_DC_GetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
20914 { (char *)"DC__DrawPointList", (PyCFunction) _wrap_DC__DrawPointList, METH_VARARGS | METH_KEYWORDS, NULL},
20915 { (char *)"DC__DrawLineList", (PyCFunction) _wrap_DC__DrawLineList, METH_VARARGS | METH_KEYWORDS, NULL},
20916 { (char *)"DC__DrawRectangleList", (PyCFunction) _wrap_DC__DrawRectangleList, METH_VARARGS | METH_KEYWORDS, NULL},
20917 { (char *)"DC__DrawEllipseList", (PyCFunction) _wrap_DC__DrawEllipseList, METH_VARARGS | METH_KEYWORDS, NULL},
20918 { (char *)"DC__DrawPolygonList", (PyCFunction) _wrap_DC__DrawPolygonList, METH_VARARGS | METH_KEYWORDS, NULL},
20919 { (char *)"DC__DrawTextList", (PyCFunction) _wrap_DC__DrawTextList, METH_VARARGS | METH_KEYWORDS, NULL},
20920 { (char *)"DC_swigregister", DC_swigregister, METH_VARARGS, NULL},
20921 { (char *)"new_MemoryDC", (PyCFunction) _wrap_new_MemoryDC, METH_VARARGS | METH_KEYWORDS, NULL},
20922 { (char *)"new_MemoryDCFromDC", (PyCFunction) _wrap_new_MemoryDCFromDC, METH_VARARGS | METH_KEYWORDS, NULL},
20923 { (char *)"MemoryDC_SelectObject", (PyCFunction) _wrap_MemoryDC_SelectObject, METH_VARARGS | METH_KEYWORDS, NULL},
20924 { (char *)"MemoryDC_swigregister", MemoryDC_swigregister, METH_VARARGS, NULL},
20925 { (char *)"new_BufferedDC", _wrap_new_BufferedDC, METH_VARARGS, NULL},
20926 { (char *)"delete_BufferedDC", (PyCFunction) _wrap_delete_BufferedDC, METH_VARARGS | METH_KEYWORDS, NULL},
20927 { (char *)"BufferedDC_UnMask", (PyCFunction) _wrap_BufferedDC_UnMask, METH_VARARGS | METH_KEYWORDS, NULL},
20928 { (char *)"BufferedDC_swigregister", BufferedDC_swigregister, METH_VARARGS, NULL},
20929 { (char *)"new_BufferedPaintDC", (PyCFunction) _wrap_new_BufferedPaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
20930 { (char *)"BufferedPaintDC_swigregister", BufferedPaintDC_swigregister, METH_VARARGS, NULL},
20931 { (char *)"new_ScreenDC", (PyCFunction) _wrap_new_ScreenDC, METH_VARARGS | METH_KEYWORDS, NULL},
20932 { (char *)"ScreenDC_StartDrawingOnTopWin", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTopWin, METH_VARARGS | METH_KEYWORDS, NULL},
20933 { (char *)"ScreenDC_StartDrawingOnTop", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
20934 { (char *)"ScreenDC_EndDrawingOnTop", (PyCFunction) _wrap_ScreenDC_EndDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
20935 { (char *)"ScreenDC_swigregister", ScreenDC_swigregister, METH_VARARGS, NULL},
20936 { (char *)"new_ClientDC", (PyCFunction) _wrap_new_ClientDC, METH_VARARGS | METH_KEYWORDS, NULL},
20937 { (char *)"ClientDC_swigregister", ClientDC_swigregister, METH_VARARGS, NULL},
20938 { (char *)"new_PaintDC", (PyCFunction) _wrap_new_PaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
20939 { (char *)"PaintDC_swigregister", PaintDC_swigregister, METH_VARARGS, NULL},
20940 { (char *)"new_WindowDC", (PyCFunction) _wrap_new_WindowDC, METH_VARARGS | METH_KEYWORDS, NULL},
20941 { (char *)"WindowDC_swigregister", WindowDC_swigregister, METH_VARARGS, NULL},
20942 { (char *)"new_MirrorDC", (PyCFunction) _wrap_new_MirrorDC, METH_VARARGS | METH_KEYWORDS, NULL},
20943 { (char *)"MirrorDC_swigregister", MirrorDC_swigregister, METH_VARARGS, NULL},
20944 { (char *)"new_PostScriptDC", (PyCFunction) _wrap_new_PostScriptDC, METH_VARARGS | METH_KEYWORDS, NULL},
20945 { (char *)"PostScriptDC_GetPrintData", (PyCFunction) _wrap_PostScriptDC_GetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
20946 { (char *)"PostScriptDC_SetPrintData", (PyCFunction) _wrap_PostScriptDC_SetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
20947 { (char *)"PostScriptDC_SetResolution", (PyCFunction) _wrap_PostScriptDC_SetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
20948 { (char *)"PostScriptDC_GetResolution", (PyCFunction) _wrap_PostScriptDC_GetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
20949 { (char *)"PostScriptDC_swigregister", PostScriptDC_swigregister, METH_VARARGS, NULL},
20950 { (char *)"new_MetaFile", (PyCFunction) _wrap_new_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
20951 { (char *)"MetaFile_swigregister", MetaFile_swigregister, METH_VARARGS, NULL},
20952 { (char *)"new_MetaFileDC", (PyCFunction) _wrap_new_MetaFileDC, METH_VARARGS | METH_KEYWORDS, NULL},
20953 { (char *)"MetaFileDC_swigregister", MetaFileDC_swigregister, METH_VARARGS, NULL},
20954 { (char *)"new_PrinterDC", (PyCFunction) _wrap_new_PrinterDC, METH_VARARGS | METH_KEYWORDS, NULL},
20955 { (char *)"PrinterDC_swigregister", PrinterDC_swigregister, METH_VARARGS, NULL},
20956 { (char *)"new_ImageList", (PyCFunction) _wrap_new_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
20957 { (char *)"delete_ImageList", (PyCFunction) _wrap_delete_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
20958 { (char *)"ImageList_Add", (PyCFunction) _wrap_ImageList_Add, METH_VARARGS | METH_KEYWORDS, NULL},
20959 { (char *)"ImageList_AddWithColourMask", (PyCFunction) _wrap_ImageList_AddWithColourMask, METH_VARARGS | METH_KEYWORDS, NULL},
20960 { (char *)"ImageList_AddIcon", (PyCFunction) _wrap_ImageList_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20961 { (char *)"ImageList_GetBitmap", (PyCFunction) _wrap_ImageList_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20962 { (char *)"ImageList_GetIcon", (PyCFunction) _wrap_ImageList_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20963 { (char *)"ImageList_Replace", (PyCFunction) _wrap_ImageList_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
20964 { (char *)"ImageList_Draw", (PyCFunction) _wrap_ImageList_Draw, METH_VARARGS | METH_KEYWORDS, NULL},
20965 { (char *)"ImageList_GetImageCount", (PyCFunction) _wrap_ImageList_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
20966 { (char *)"ImageList_Remove", (PyCFunction) _wrap_ImageList_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
20967 { (char *)"ImageList_RemoveAll", (PyCFunction) _wrap_ImageList_RemoveAll, METH_VARARGS | METH_KEYWORDS, NULL},
20968 { (char *)"ImageList_GetSize", (PyCFunction) _wrap_ImageList_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20969 { (char *)"ImageList_swigregister", ImageList_swigregister, METH_VARARGS, NULL},
20970 { (char *)"PenList_AddPen", (PyCFunction) _wrap_PenList_AddPen, METH_VARARGS | METH_KEYWORDS, NULL},
20971 { (char *)"PenList_FindOrCreatePen", (PyCFunction) _wrap_PenList_FindOrCreatePen, METH_VARARGS | METH_KEYWORDS, NULL},
20972 { (char *)"PenList_RemovePen", (PyCFunction) _wrap_PenList_RemovePen, METH_VARARGS | METH_KEYWORDS, NULL},
20973 { (char *)"PenList_GetCount", (PyCFunction) _wrap_PenList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
20974 { (char *)"PenList_swigregister", PenList_swigregister, METH_VARARGS, NULL},
20975 { (char *)"BrushList_AddBrush", (PyCFunction) _wrap_BrushList_AddBrush, METH_VARARGS | METH_KEYWORDS, NULL},
20976 { (char *)"BrushList_FindOrCreateBrush", (PyCFunction) _wrap_BrushList_FindOrCreateBrush, METH_VARARGS | METH_KEYWORDS, NULL},
20977 { (char *)"BrushList_RemoveBrush", (PyCFunction) _wrap_BrushList_RemoveBrush, METH_VARARGS | METH_KEYWORDS, NULL},
20978 { (char *)"BrushList_GetCount", (PyCFunction) _wrap_BrushList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
20979 { (char *)"BrushList_swigregister", BrushList_swigregister, METH_VARARGS, NULL},
20980 { (char *)"new_ColourDatabase", (PyCFunction) _wrap_new_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
20981 { (char *)"delete_ColourDatabase", (PyCFunction) _wrap_delete_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
20982 { (char *)"ColourDatabase_Find", (PyCFunction) _wrap_ColourDatabase_Find, METH_VARARGS | METH_KEYWORDS, NULL},
20983 { (char *)"ColourDatabase_FindName", (PyCFunction) _wrap_ColourDatabase_FindName, METH_VARARGS | METH_KEYWORDS, NULL},
20984 { (char *)"ColourDatabase_AddColour", (PyCFunction) _wrap_ColourDatabase_AddColour, METH_VARARGS | METH_KEYWORDS, NULL},
20985 { (char *)"ColourDatabase_Append", (PyCFunction) _wrap_ColourDatabase_Append, METH_VARARGS | METH_KEYWORDS, NULL},
20986 { (char *)"ColourDatabase_swigregister", ColourDatabase_swigregister, METH_VARARGS, NULL},
20987 { (char *)"FontList_AddFont", (PyCFunction) _wrap_FontList_AddFont, METH_VARARGS | METH_KEYWORDS, NULL},
20988 { (char *)"FontList_FindOrCreateFont", (PyCFunction) _wrap_FontList_FindOrCreateFont, METH_VARARGS | METH_KEYWORDS, NULL},
20989 { (char *)"FontList_RemoveFont", (PyCFunction) _wrap_FontList_RemoveFont, METH_VARARGS | METH_KEYWORDS, NULL},
20990 { (char *)"FontList_GetCount", (PyCFunction) _wrap_FontList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
20991 { (char *)"FontList_swigregister", FontList_swigregister, METH_VARARGS, NULL},
20992 { (char *)"new_Effects", (PyCFunction) _wrap_new_Effects, METH_VARARGS | METH_KEYWORDS, NULL},
20993 { (char *)"Effects_GetHighlightColour", (PyCFunction) _wrap_Effects_GetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
20994 { (char *)"Effects_GetLightShadow", (PyCFunction) _wrap_Effects_GetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
20995 { (char *)"Effects_GetFaceColour", (PyCFunction) _wrap_Effects_GetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
20996 { (char *)"Effects_GetMediumShadow", (PyCFunction) _wrap_Effects_GetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
20997 { (char *)"Effects_GetDarkShadow", (PyCFunction) _wrap_Effects_GetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
20998 { (char *)"Effects_SetHighlightColour", (PyCFunction) _wrap_Effects_SetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
20999 { (char *)"Effects_SetLightShadow", (PyCFunction) _wrap_Effects_SetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21000 { (char *)"Effects_SetFaceColour", (PyCFunction) _wrap_Effects_SetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
21001 { (char *)"Effects_SetMediumShadow", (PyCFunction) _wrap_Effects_SetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21002 { (char *)"Effects_SetDarkShadow", (PyCFunction) _wrap_Effects_SetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21003 { (char *)"Effects_Set", (PyCFunction) _wrap_Effects_Set, METH_VARARGS | METH_KEYWORDS, NULL},
21004 { (char *)"Effects_DrawSunkenEdge", (PyCFunction) _wrap_Effects_DrawSunkenEdge, METH_VARARGS | METH_KEYWORDS, NULL},
21005 { (char *)"Effects_TileBitmap", (PyCFunction) _wrap_Effects_TileBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21006 { (char *)"Effects_swigregister", Effects_swigregister, METH_VARARGS, NULL},
21007 { NULL, NULL, 0, NULL }
21008 };
21009
21010
21011 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
21012
21013 static void *_p_wxBufferedDCTo_p_wxMemoryDC(void *x) {
21014 return (void *)((wxMemoryDC *) ((wxBufferedDC *) x));
21015 }
21016 static void *_p_wxBufferedPaintDCTo_p_wxMemoryDC(void *x) {
21017 return (void *)((wxMemoryDC *) (wxBufferedDC *) ((wxBufferedPaintDC *) x));
21018 }
21019 static void *_p_wxIconTo_p_wxGDIObject(void *x) {
21020 return (void *)((wxGDIObject *) ((wxIcon *) x));
21021 }
21022 static void *_p_wxPaletteTo_p_wxGDIObject(void *x) {
21023 return (void *)((wxGDIObject *) ((wxPalette *) x));
21024 }
21025 static void *_p_wxPenTo_p_wxGDIObject(void *x) {
21026 return (void *)((wxGDIObject *) ((wxPen *) x));
21027 }
21028 static void *_p_wxFontTo_p_wxGDIObject(void *x) {
21029 return (void *)((wxGDIObject *) ((wxFont *) x));
21030 }
21031 static void *_p_wxCursorTo_p_wxGDIObject(void *x) {
21032 return (void *)((wxGDIObject *) ((wxCursor *) x));
21033 }
21034 static void *_p_wxBitmapTo_p_wxGDIObject(void *x) {
21035 return (void *)((wxGDIObject *) ((wxBitmap *) x));
21036 }
21037 static void *_p_wxRegionTo_p_wxGDIObject(void *x) {
21038 return (void *)((wxGDIObject *) ((wxRegion *) x));
21039 }
21040 static void *_p_wxBrushTo_p_wxGDIObject(void *x) {
21041 return (void *)((wxGDIObject *) ((wxBrush *) x));
21042 }
21043 static void *_p_wxBufferedDCTo_p_wxDC(void *x) {
21044 return (void *)((wxDC *) (wxMemoryDC *) ((wxBufferedDC *) x));
21045 }
21046 static void *_p_wxScreenDCTo_p_wxDC(void *x) {
21047 return (void *)((wxDC *) ((wxScreenDC *) x));
21048 }
21049 static void *_p_wxMirrorDCTo_p_wxDC(void *x) {
21050 return (void *)((wxDC *) ((wxMirrorDC *) x));
21051 }
21052 static void *_p_wxMemoryDCTo_p_wxDC(void *x) {
21053 return (void *)((wxDC *) ((wxMemoryDC *) x));
21054 }
21055 static void *_p_wxWindowDCTo_p_wxDC(void *x) {
21056 return (void *)((wxDC *) ((wxWindowDC *) x));
21057 }
21058 static void *_p_wxMetaFileDCTo_p_wxDC(void *x) {
21059 return (void *)((wxDC *) ((wxMetaFileDC *) x));
21060 }
21061 static void *_p_wxBufferedPaintDCTo_p_wxDC(void *x) {
21062 return (void *)((wxDC *) (wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
21063 }
21064 static void *_p_wxClientDCTo_p_wxDC(void *x) {
21065 return (void *)((wxDC *) ((wxClientDC *) x));
21066 }
21067 static void *_p_wxPaintDCTo_p_wxDC(void *x) {
21068 return (void *)((wxDC *) ((wxPaintDC *) x));
21069 }
21070 static void *_p_wxPostScriptDCTo_p_wxDC(void *x) {
21071 return (void *)((wxDC *) ((wxPostScriptDC *) x));
21072 }
21073 static void *_p_wxPrinterDCTo_p_wxDC(void *x) {
21074 return (void *)((wxDC *) ((wxPrinterDC *) x));
21075 }
21076 static void *_p_wxBufferedPaintDCTo_p_wxBufferedDC(void *x) {
21077 return (void *)((wxBufferedDC *) ((wxBufferedPaintDC *) x));
21078 }
21079 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
21080 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
21081 }
21082 static void *_p_wxPenTo_p_wxObject(void *x) {
21083 return (void *)((wxObject *) (wxGDIObject *) ((wxPen *) x));
21084 }
21085 static void *_p_wxRegionIteratorTo_p_wxObject(void *x) {
21086 return (void *)((wxObject *) ((wxRegionIterator *) x));
21087 }
21088 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
21089 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
21090 }
21091 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
21092 return (void *)((wxObject *) ((wxSizerItem *) x));
21093 }
21094 static void *_p_wxColourDatabaseTo_p_wxObject(void *x) {
21095 return (void *)((wxObject *) ((wxColourDatabase *) x));
21096 }
21097 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
21098 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
21099 }
21100 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
21101 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
21102 }
21103 static void *_p_wxIconTo_p_wxObject(void *x) {
21104 return (void *)((wxObject *) (wxGDIObject *) ((wxIcon *) x));
21105 }
21106 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
21107 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
21108 }
21109 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
21110 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
21111 }
21112 static void *_p_wxSizerTo_p_wxObject(void *x) {
21113 return (void *)((wxObject *) ((wxSizer *) x));
21114 }
21115 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
21116 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
21117 }
21118 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
21119 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
21120 }
21121 static void *_p_wxPenListTo_p_wxObject(void *x) {
21122 return (void *)((wxObject *) ((wxPenList *) x));
21123 }
21124 static void *_p_wxEventTo_p_wxObject(void *x) {
21125 return (void *)((wxObject *) ((wxEvent *) x));
21126 }
21127 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
21128 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
21129 }
21130 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
21131 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
21132 }
21133 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
21134 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
21135 }
21136 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
21137 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
21138 }
21139 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
21140 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
21141 }
21142 static void *_p_wxDCTo_p_wxObject(void *x) {
21143 return (void *)((wxObject *) ((wxDC *) x));
21144 }
21145 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
21146 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
21147 }
21148 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
21149 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
21150 }
21151 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
21152 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
21153 }
21154 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
21155 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
21156 }
21157 static void *_p_wxControlTo_p_wxObject(void *x) {
21158 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
21159 }
21160 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
21161 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
21162 }
21163 static void *_p_wxClientDCTo_p_wxObject(void *x) {
21164 return (void *)((wxObject *) (wxDC *) ((wxClientDC *) x));
21165 }
21166 static void *_p_wxFSFileTo_p_wxObject(void *x) {
21167 return (void *)((wxObject *) ((wxFSFile *) x));
21168 }
21169 static void *_p_wxMemoryDCTo_p_wxObject(void *x) {
21170 return (void *)((wxObject *) (wxDC *) ((wxMemoryDC *) x));
21171 }
21172 static void *_p_wxRegionTo_p_wxObject(void *x) {
21173 return (void *)((wxObject *) (wxGDIObject *) ((wxRegion *) x));
21174 }
21175 static void *_p_wxPySizerTo_p_wxObject(void *x) {
21176 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
21177 }
21178 static void *_p_wxWindowDCTo_p_wxObject(void *x) {
21179 return (void *)((wxObject *) (wxDC *) ((wxWindowDC *) x));
21180 }
21181 static void *_p_wxGDIObjectTo_p_wxObject(void *x) {
21182 return (void *)((wxObject *) ((wxGDIObject *) x));
21183 }
21184 static void *_p_wxEffectsTo_p_wxObject(void *x) {
21185 return (void *)((wxObject *) ((wxEffects *) x));
21186 }
21187 static void *_p_wxPyEventTo_p_wxObject(void *x) {
21188 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
21189 }
21190 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
21191 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
21192 }
21193 static void *_p_wxPostScriptDCTo_p_wxObject(void *x) {
21194 return (void *)((wxObject *) (wxDC *) ((wxPostScriptDC *) x));
21195 }
21196 static void *_p_wxShowEventTo_p_wxObject(void *x) {
21197 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
21198 }
21199 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
21200 return (void *)((wxObject *) ((wxMenuItem *) x));
21201 }
21202 static void *_p_wxDateEventTo_p_wxObject(void *x) {
21203 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
21204 }
21205 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
21206 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
21207 }
21208 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
21209 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
21210 }
21211 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
21212 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
21213 }
21214 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
21215 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
21216 }
21217 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
21218 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
21219 }
21220 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
21221 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
21222 }
21223 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
21224 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
21225 }
21226 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
21227 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
21228 }
21229 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
21230 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
21231 }
21232 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
21233 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
21234 }
21235 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
21236 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
21237 }
21238 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
21239 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
21240 }
21241 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
21242 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
21243 }
21244 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
21245 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
21246 }
21247 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
21248 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
21249 }
21250 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
21251 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
21252 }
21253 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
21254 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
21255 }
21256 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
21257 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
21258 }
21259 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
21260 return (void *)((wxObject *) ((wxImageHandler *) x));
21261 }
21262 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
21263 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
21264 }
21265 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
21266 return (void *)((wxObject *) ((wxEvtHandler *) x));
21267 }
21268 static void *_p_wxBufferedPaintDCTo_p_wxObject(void *x) {
21269 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
21270 }
21271 static void *_p_wxPaintDCTo_p_wxObject(void *x) {
21272 return (void *)((wxObject *) (wxDC *) ((wxPaintDC *) x));
21273 }
21274 static void *_p_wxPrinterDCTo_p_wxObject(void *x) {
21275 return (void *)((wxObject *) (wxDC *) ((wxPrinterDC *) x));
21276 }
21277 static void *_p_wxScreenDCTo_p_wxObject(void *x) {
21278 return (void *)((wxObject *) (wxDC *) ((wxScreenDC *) x));
21279 }
21280 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
21281 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
21282 }
21283 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
21284 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
21285 }
21286 static void *_p_wxImageTo_p_wxObject(void *x) {
21287 return (void *)((wxObject *) ((wxImage *) x));
21288 }
21289 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
21290 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
21291 }
21292 static void *_p_wxPaletteTo_p_wxObject(void *x) {
21293 return (void *)((wxObject *) (wxGDIObject *) ((wxPalette *) x));
21294 }
21295 static void *_p_wxBufferedDCTo_p_wxObject(void *x) {
21296 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *) ((wxBufferedDC *) x));
21297 }
21298 static void *_p_wxImageListTo_p_wxObject(void *x) {
21299 return (void *)((wxObject *) ((wxImageList *) x));
21300 }
21301 static void *_p_wxCursorTo_p_wxObject(void *x) {
21302 return (void *)((wxObject *) (wxGDIObject *) ((wxCursor *) x));
21303 }
21304 static void *_p_wxEncodingConverterTo_p_wxObject(void *x) {
21305 return (void *)((wxObject *) ((wxEncodingConverter *) x));
21306 }
21307 static void *_p_wxMirrorDCTo_p_wxObject(void *x) {
21308 return (void *)((wxObject *) (wxDC *) ((wxMirrorDC *) x));
21309 }
21310 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
21311 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21312 }
21313 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
21314 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
21315 }
21316 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
21317 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
21318 }
21319 static void *_p_wxWindowTo_p_wxObject(void *x) {
21320 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
21321 }
21322 static void *_p_wxMenuTo_p_wxObject(void *x) {
21323 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
21324 }
21325 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
21326 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
21327 }
21328 static void *_p_wxMetaFileDCTo_p_wxObject(void *x) {
21329 return (void *)((wxObject *) (wxDC *) ((wxMetaFileDC *) x));
21330 }
21331 static void *_p_wxBrushListTo_p_wxObject(void *x) {
21332 return (void *)((wxObject *) ((wxBrushList *) x));
21333 }
21334 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
21335 return (void *)((wxObject *) ((wxFileSystem *) x));
21336 }
21337 static void *_p_wxBitmapTo_p_wxObject(void *x) {
21338 return (void *)((wxObject *) (wxGDIObject *) ((wxBitmap *) x));
21339 }
21340 static void *_p_wxMaskTo_p_wxObject(void *x) {
21341 return (void *)((wxObject *) ((wxMask *) x));
21342 }
21343 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
21344 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
21345 }
21346 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
21347 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
21348 }
21349 static void *_p_wxPyAppTo_p_wxObject(void *x) {
21350 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
21351 }
21352 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
21353 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
21354 }
21355 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
21356 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
21357 }
21358 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
21359 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
21360 }
21361 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
21362 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
21363 }
21364 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
21365 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
21366 }
21367 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
21368 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
21369 }
21370 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
21371 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
21372 }
21373 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
21374 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
21375 }
21376 static void *_p_wxFontTo_p_wxObject(void *x) {
21377 return (void *)((wxObject *) (wxGDIObject *) ((wxFont *) x));
21378 }
21379 static void *_p_wxBrushTo_p_wxObject(void *x) {
21380 return (void *)((wxObject *) (wxGDIObject *) ((wxBrush *) x));
21381 }
21382 static void *_p_wxMetaFileTo_p_wxObject(void *x) {
21383 return (void *)((wxObject *) ((wxMetaFile *) x));
21384 }
21385 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
21386 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
21387 }
21388 static void *_p_wxColourTo_p_wxObject(void *x) {
21389 return (void *)((wxObject *) ((wxColour *) x));
21390 }
21391 static void *_p_wxFontListTo_p_wxObject(void *x) {
21392 return (void *)((wxObject *) ((wxFontList *) x));
21393 }
21394 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
21395 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
21396 }
21397 static void *_p_wxValidatorTo_p_wxObject(void *x) {
21398 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
21399 }
21400 static void *_p_wxControlTo_p_wxWindow(void *x) {
21401 return (void *)((wxWindow *) ((wxControl *) x));
21402 }
21403 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
21404 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
21405 }
21406 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
21407 return (void *)((wxWindow *) ((wxMenuBar *) x));
21408 }
21409 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}};
21410 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}};
21411 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}};
21412 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}};
21413 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}};
21414 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}};
21415 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}};
21416 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}};
21417 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}};
21418 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}};
21419 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}};
21420 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}};
21421 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}};
21422 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}};
21423 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}};
21424 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}};
21425 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}};
21426 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}};
21427 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}};
21428 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}};
21429 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}};
21430 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}};
21431 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}};
21432 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}};
21433 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}};
21434 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}};
21435 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}};
21436 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}};
21437 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}};
21438 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}};
21439 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}};
21440 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}};
21441 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}};
21442 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}};
21443 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}};
21444 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}};
21445 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}};
21446 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}};
21447 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}};
21448 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}};
21449 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}};
21450 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}};
21451 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}};
21452 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}};
21453 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}};
21454 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}};
21455 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}};
21456 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}};
21457 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}};
21458 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}};
21459 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}};
21460 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}};
21461 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}};
21462 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}};
21463 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}};
21464 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}};
21465 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}};
21466 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}};
21467 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}};
21468 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}};
21469 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}};
21470 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}};
21471
21472 static swig_type_info *swig_types_initial[] = {
21473 _swigt__p_wxPostScriptDC,
21474 _swigt__p_wxBrush,
21475 _swigt__p_wxColour,
21476 _swigt__p_wxDC,
21477 _swigt__p_wxMirrorDC,
21478 _swigt__p_form_ops_t,
21479 _swigt__p_wxDuplexMode,
21480 _swigt__p_wxPyFontEnumerator,
21481 _swigt__p_char,
21482 _swigt__p_wxIconLocation,
21483 _swigt__p_wxImage,
21484 _swigt__p_wxMetaFileDC,
21485 _swigt__p_wxMask,
21486 _swigt__p_wxSize,
21487 _swigt__p_wxFont,
21488 _swigt__p_wxWindow,
21489 _swigt__p_double,
21490 _swigt__p_wxMemoryDC,
21491 _swigt__p_wxFontMapper,
21492 _swigt__p_wxEffects,
21493 _swigt__p_wxNativeEncodingInfo,
21494 _swigt__p_wxPalette,
21495 _swigt__p_wxBitmap,
21496 _swigt__p_wxObject,
21497 _swigt__p_wxRegionIterator,
21498 _swigt__p_wxRect,
21499 _swigt__p_wxPaperSize,
21500 _swigt__p_wxString,
21501 _swigt__unsigned_int,
21502 _swigt__p_unsigned_int,
21503 _swigt__p_wxPrinterDC,
21504 _swigt__p_wxIconBundle,
21505 _swigt__p_wxPoint,
21506 _swigt__p_wxDash,
21507 _swigt__p_wxScreenDC,
21508 _swigt__p_wxCursor,
21509 _swigt__p_wxClientDC,
21510 _swigt__p_wxBufferedDC,
21511 _swigt__p_wxImageList,
21512 _swigt__p_unsigned_char,
21513 _swigt__p_wxGDIObject,
21514 _swigt__p_wxIcon,
21515 _swigt__p_wxLocale,
21516 _swigt__ptrdiff_t,
21517 _swigt__std__ptrdiff_t,
21518 _swigt__p_wxRegion,
21519 _swigt__p_wxConfigBase,
21520 _swigt__p_wxLanguageInfo,
21521 _swigt__p_wxWindowDC,
21522 _swigt__p_wxPrintData,
21523 _swigt__p_wxBrushList,
21524 _swigt__p_wxFontList,
21525 _swigt__p_wxPen,
21526 _swigt__p_wxBufferedPaintDC,
21527 _swigt__p_wxPaintDC,
21528 _swigt__p_wxPenList,
21529 _swigt__p_int,
21530 _swigt__p_wxMetaFile,
21531 _swigt__p_unsigned_long,
21532 _swigt__p_wxNativeFontInfo,
21533 _swigt__p_wxEncodingConverter,
21534 _swigt__p_wxColourDatabase,
21535 0
21536 };
21537
21538
21539 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
21540
21541 static swig_const_info swig_const_table[] = {
21542 {0, 0, 0, 0.0, 0, 0}};
21543
21544 #ifdef __cplusplus
21545 }
21546 #endif
21547
21548
21549 #ifdef __cplusplus
21550 extern "C" {
21551 #endif
21552
21553 /* Python-specific SWIG API */
21554 #define SWIG_newvarlink() SWIG_Python_newvarlink()
21555 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
21556 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
21557
21558 /* -----------------------------------------------------------------------------
21559 * global variable support code.
21560 * ----------------------------------------------------------------------------- */
21561
21562 typedef struct swig_globalvar {
21563 char *name; /* Name of global variable */
21564 PyObject *(*get_attr)(); /* Return the current value */
21565 int (*set_attr)(PyObject *); /* Set the value */
21566 struct swig_globalvar *next;
21567 } swig_globalvar;
21568
21569 typedef struct swig_varlinkobject {
21570 PyObject_HEAD
21571 swig_globalvar *vars;
21572 } swig_varlinkobject;
21573
21574 static PyObject *
21575 swig_varlink_repr(swig_varlinkobject *v) {
21576 v = v;
21577 return PyString_FromString("<Swig global variables>");
21578 }
21579
21580 static int
21581 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
21582 swig_globalvar *var;
21583 flags = flags;
21584 fprintf(fp,"Swig global variables { ");
21585 for (var = v->vars; var; var=var->next) {
21586 fprintf(fp,"%s", var->name);
21587 if (var->next) fprintf(fp,", ");
21588 }
21589 fprintf(fp," }\n");
21590 return 0;
21591 }
21592
21593 static PyObject *
21594 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
21595 swig_globalvar *var = v->vars;
21596 while (var) {
21597 if (strcmp(var->name,n) == 0) {
21598 return (*var->get_attr)();
21599 }
21600 var = var->next;
21601 }
21602 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
21603 return NULL;
21604 }
21605
21606 static int
21607 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
21608 swig_globalvar *var = v->vars;
21609 while (var) {
21610 if (strcmp(var->name,n) == 0) {
21611 return (*var->set_attr)(p);
21612 }
21613 var = var->next;
21614 }
21615 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
21616 return 1;
21617 }
21618
21619 static PyTypeObject varlinktype = {
21620 PyObject_HEAD_INIT(0)
21621 0, /* Number of items in variable part (ob_size) */
21622 (char *)"swigvarlink", /* Type name (tp_name) */
21623 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
21624 0, /* Itemsize (tp_itemsize) */
21625 0, /* Deallocator (tp_dealloc) */
21626 (printfunc) swig_varlink_print, /* Print (tp_print) */
21627 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
21628 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
21629 0, /* tp_compare */
21630 (reprfunc) swig_varlink_repr, /* tp_repr */
21631 0, /* tp_as_number */
21632 0, /* tp_as_sequence */
21633 0, /* tp_as_mapping */
21634 0, /* tp_hash */
21635 0, /* tp_call */
21636 0, /* tp_str */
21637 0, /* tp_getattro */
21638 0, /* tp_setattro */
21639 0, /* tp_as_buffer */
21640 0, /* tp_flags */
21641 0, /* tp_doc */
21642 #if PY_VERSION_HEX >= 0x02000000
21643 0, /* tp_traverse */
21644 0, /* tp_clear */
21645 #endif
21646 #if PY_VERSION_HEX >= 0x02010000
21647 0, /* tp_richcompare */
21648 0, /* tp_weaklistoffset */
21649 #endif
21650 #if PY_VERSION_HEX >= 0x02020000
21651 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
21652 #endif
21653 #if PY_VERSION_HEX >= 0x02030000
21654 0, /* tp_del */
21655 #endif
21656 #ifdef COUNT_ALLOCS
21657 0,0,0,0 /* tp_alloc -> tp_next */
21658 #endif
21659 };
21660
21661 /* Create a variable linking object for use later */
21662 static PyObject *
21663 SWIG_Python_newvarlink(void) {
21664 swig_varlinkobject *result = 0;
21665 result = PyMem_NEW(swig_varlinkobject,1);
21666 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
21667 result->ob_type = &varlinktype;
21668 result->vars = 0;
21669 result->ob_refcnt = 0;
21670 Py_XINCREF((PyObject *) result);
21671 return ((PyObject*) result);
21672 }
21673
21674 static void
21675 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
21676 swig_varlinkobject *v;
21677 swig_globalvar *gv;
21678 v= (swig_varlinkobject *) p;
21679 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
21680 gv->name = (char *) malloc(strlen(name)+1);
21681 strcpy(gv->name,name);
21682 gv->get_attr = get_attr;
21683 gv->set_attr = set_attr;
21684 gv->next = v->vars;
21685 v->vars = gv;
21686 }
21687
21688 /* -----------------------------------------------------------------------------
21689 * constants/methods manipulation
21690 * ----------------------------------------------------------------------------- */
21691
21692 /* Install Constants */
21693 static void
21694 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
21695 PyObject *obj = 0;
21696 size_t i;
21697 for (i = 0; constants[i].type; i++) {
21698 switch(constants[i].type) {
21699 case SWIG_PY_INT:
21700 obj = PyInt_FromLong(constants[i].lvalue);
21701 break;
21702 case SWIG_PY_FLOAT:
21703 obj = PyFloat_FromDouble(constants[i].dvalue);
21704 break;
21705 case SWIG_PY_STRING:
21706 if (constants[i].pvalue) {
21707 obj = PyString_FromString((char *) constants[i].pvalue);
21708 } else {
21709 Py_INCREF(Py_None);
21710 obj = Py_None;
21711 }
21712 break;
21713 case SWIG_PY_POINTER:
21714 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
21715 break;
21716 case SWIG_PY_BINARY:
21717 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
21718 break;
21719 default:
21720 obj = 0;
21721 break;
21722 }
21723 if (obj) {
21724 PyDict_SetItemString(d,constants[i].name,obj);
21725 Py_DECREF(obj);
21726 }
21727 }
21728 }
21729
21730 /* -----------------------------------------------------------------------------*/
21731 /* Fix SwigMethods to carry the callback ptrs when needed */
21732 /* -----------------------------------------------------------------------------*/
21733
21734 static void
21735 SWIG_Python_FixMethods(PyMethodDef *methods,
21736 swig_const_info *const_table,
21737 swig_type_info **types,
21738 swig_type_info **types_initial) {
21739 size_t i;
21740 for (i = 0; methods[i].ml_name; ++i) {
21741 char *c = methods[i].ml_doc;
21742 if (c && (c = strstr(c, "swig_ptr: "))) {
21743 int j;
21744 swig_const_info *ci = 0;
21745 char *name = c + 10;
21746 for (j = 0; const_table[j].type; j++) {
21747 if (strncmp(const_table[j].name, name,
21748 strlen(const_table[j].name)) == 0) {
21749 ci = &(const_table[j]);
21750 break;
21751 }
21752 }
21753 if (ci) {
21754 size_t shift = (ci->ptype) - types;
21755 swig_type_info *ty = types_initial[shift];
21756 size_t ldoc = (c - methods[i].ml_doc);
21757 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
21758 char *ndoc = (char*)malloc(ldoc + lptr + 10);
21759 char *buff = ndoc;
21760 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
21761 strncpy(buff, methods[i].ml_doc, ldoc);
21762 buff += ldoc;
21763 strncpy(buff, "swig_ptr: ", 10);
21764 buff += 10;
21765 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
21766 methods[i].ml_doc = ndoc;
21767 }
21768 }
21769 }
21770 }
21771
21772 /* -----------------------------------------------------------------------------*
21773 * Initialize type list
21774 * -----------------------------------------------------------------------------*/
21775
21776 #if PY_MAJOR_VERSION < 2
21777 /* PyModule_AddObject function was introduced in Python 2.0. The following function
21778 is copied out of Python/modsupport.c in python version 2.3.4 */
21779 static int
21780 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
21781 {
21782 PyObject *dict;
21783 if (!PyModule_Check(m)) {
21784 PyErr_SetString(PyExc_TypeError,
21785 "PyModule_AddObject() needs module as first arg");
21786 return -1;
21787 }
21788 if (!o) {
21789 PyErr_SetString(PyExc_TypeError,
21790 "PyModule_AddObject() needs non-NULL value");
21791 return -1;
21792 }
21793
21794 dict = PyModule_GetDict(m);
21795 if (dict == NULL) {
21796 /* Internal error -- modules must have a dict! */
21797 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
21798 PyModule_GetName(m));
21799 return -1;
21800 }
21801 if (PyDict_SetItemString(dict, name, o))
21802 return -1;
21803 Py_DECREF(o);
21804 return 0;
21805 }
21806 #endif
21807
21808 static swig_type_info **
21809 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
21810 static PyMethodDef swig_empty_runtime_method_table[] = {
21811 {
21812 NULL, NULL, 0, NULL
21813 }
21814 };/* Sentinel */
21815
21816 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
21817 swig_empty_runtime_method_table);
21818 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
21819 if (pointer && module) {
21820 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
21821 }
21822 return type_list_handle;
21823 }
21824
21825 static swig_type_info **
21826 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
21827 swig_type_info **type_pointer;
21828
21829 /* first check if module already created */
21830 type_pointer = SWIG_Python_GetTypeListHandle();
21831 if (type_pointer) {
21832 return type_pointer;
21833 } else {
21834 /* create a new module and variable */
21835 return SWIG_Python_SetTypeListHandle(type_list_handle);
21836 }
21837 }
21838
21839 #ifdef __cplusplus
21840 }
21841 #endif
21842
21843 /* -----------------------------------------------------------------------------*
21844 * Partial Init method
21845 * -----------------------------------------------------------------------------*/
21846
21847 #ifdef SWIG_LINK_RUNTIME
21848 #ifdef __cplusplus
21849 extern "C"
21850 #endif
21851 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
21852 #endif
21853
21854 #ifdef __cplusplus
21855 extern "C"
21856 #endif
21857 SWIGEXPORT(void) SWIG_init(void) {
21858 static PyObject *SWIG_globals = 0;
21859 static int typeinit = 0;
21860 PyObject *m, *d;
21861 int i;
21862 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
21863
21864 /* Fix SwigMethods to carry the callback ptrs when needed */
21865 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
21866
21867 m = Py_InitModule((char *) SWIG_name, SwigMethods);
21868 d = PyModule_GetDict(m);
21869
21870 if (!typeinit) {
21871 #ifdef SWIG_LINK_RUNTIME
21872 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
21873 #else
21874 # ifndef SWIG_STATIC_RUNTIME
21875 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
21876 # endif
21877 #endif
21878 for (i = 0; swig_types_initial[i]; i++) {
21879 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
21880 }
21881 typeinit = 1;
21882 }
21883 SWIG_InstallConstants(d,swig_const_table);
21884
21885 {
21886 PyDict_SetItemString(d,"OutRegion", SWIG_From_int((int)(wxOutRegion)));
21887 }
21888 {
21889 PyDict_SetItemString(d,"PartRegion", SWIG_From_int((int)(wxPartRegion)));
21890 }
21891 {
21892 PyDict_SetItemString(d,"InRegion", SWIG_From_int((int)(wxInRegion)));
21893 }
21894 {
21895 PyDict_SetItemString(d,"FONTFAMILY_DEFAULT", SWIG_From_int((int)(wxFONTFAMILY_DEFAULT)));
21896 }
21897 {
21898 PyDict_SetItemString(d,"FONTFAMILY_DECORATIVE", SWIG_From_int((int)(wxFONTFAMILY_DECORATIVE)));
21899 }
21900 {
21901 PyDict_SetItemString(d,"FONTFAMILY_ROMAN", SWIG_From_int((int)(wxFONTFAMILY_ROMAN)));
21902 }
21903 {
21904 PyDict_SetItemString(d,"FONTFAMILY_SCRIPT", SWIG_From_int((int)(wxFONTFAMILY_SCRIPT)));
21905 }
21906 {
21907 PyDict_SetItemString(d,"FONTFAMILY_SWISS", SWIG_From_int((int)(wxFONTFAMILY_SWISS)));
21908 }
21909 {
21910 PyDict_SetItemString(d,"FONTFAMILY_MODERN", SWIG_From_int((int)(wxFONTFAMILY_MODERN)));
21911 }
21912 {
21913 PyDict_SetItemString(d,"FONTFAMILY_TELETYPE", SWIG_From_int((int)(wxFONTFAMILY_TELETYPE)));
21914 }
21915 {
21916 PyDict_SetItemString(d,"FONTFAMILY_MAX", SWIG_From_int((int)(wxFONTFAMILY_MAX)));
21917 }
21918 {
21919 PyDict_SetItemString(d,"FONTFAMILY_UNKNOWN", SWIG_From_int((int)(wxFONTFAMILY_UNKNOWN)));
21920 }
21921 {
21922 PyDict_SetItemString(d,"FONTSTYLE_NORMAL", SWIG_From_int((int)(wxFONTSTYLE_NORMAL)));
21923 }
21924 {
21925 PyDict_SetItemString(d,"FONTSTYLE_ITALIC", SWIG_From_int((int)(wxFONTSTYLE_ITALIC)));
21926 }
21927 {
21928 PyDict_SetItemString(d,"FONTSTYLE_SLANT", SWIG_From_int((int)(wxFONTSTYLE_SLANT)));
21929 }
21930 {
21931 PyDict_SetItemString(d,"FONTSTYLE_MAX", SWIG_From_int((int)(wxFONTSTYLE_MAX)));
21932 }
21933 {
21934 PyDict_SetItemString(d,"FONTWEIGHT_NORMAL", SWIG_From_int((int)(wxFONTWEIGHT_NORMAL)));
21935 }
21936 {
21937 PyDict_SetItemString(d,"FONTWEIGHT_LIGHT", SWIG_From_int((int)(wxFONTWEIGHT_LIGHT)));
21938 }
21939 {
21940 PyDict_SetItemString(d,"FONTWEIGHT_BOLD", SWIG_From_int((int)(wxFONTWEIGHT_BOLD)));
21941 }
21942 {
21943 PyDict_SetItemString(d,"FONTWEIGHT_MAX", SWIG_From_int((int)(wxFONTWEIGHT_MAX)));
21944 }
21945 {
21946 PyDict_SetItemString(d,"FONTFLAG_DEFAULT", SWIG_From_int((int)(wxFONTFLAG_DEFAULT)));
21947 }
21948 {
21949 PyDict_SetItemString(d,"FONTFLAG_ITALIC", SWIG_From_int((int)(wxFONTFLAG_ITALIC)));
21950 }
21951 {
21952 PyDict_SetItemString(d,"FONTFLAG_SLANT", SWIG_From_int((int)(wxFONTFLAG_SLANT)));
21953 }
21954 {
21955 PyDict_SetItemString(d,"FONTFLAG_LIGHT", SWIG_From_int((int)(wxFONTFLAG_LIGHT)));
21956 }
21957 {
21958 PyDict_SetItemString(d,"FONTFLAG_BOLD", SWIG_From_int((int)(wxFONTFLAG_BOLD)));
21959 }
21960 {
21961 PyDict_SetItemString(d,"FONTFLAG_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_ANTIALIASED)));
21962 }
21963 {
21964 PyDict_SetItemString(d,"FONTFLAG_NOT_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_NOT_ANTIALIASED)));
21965 }
21966 {
21967 PyDict_SetItemString(d,"FONTFLAG_UNDERLINED", SWIG_From_int((int)(wxFONTFLAG_UNDERLINED)));
21968 }
21969 {
21970 PyDict_SetItemString(d,"FONTFLAG_STRIKETHROUGH", SWIG_From_int((int)(wxFONTFLAG_STRIKETHROUGH)));
21971 }
21972 {
21973 PyDict_SetItemString(d,"FONTFLAG_MASK", SWIG_From_int((int)(wxFONTFLAG_MASK)));
21974 }
21975 {
21976 PyDict_SetItemString(d,"FONTENCODING_SYSTEM", SWIG_From_int((int)(wxFONTENCODING_SYSTEM)));
21977 }
21978 {
21979 PyDict_SetItemString(d,"FONTENCODING_DEFAULT", SWIG_From_int((int)(wxFONTENCODING_DEFAULT)));
21980 }
21981 {
21982 PyDict_SetItemString(d,"FONTENCODING_ISO8859_1", SWIG_From_int((int)(wxFONTENCODING_ISO8859_1)));
21983 }
21984 {
21985 PyDict_SetItemString(d,"FONTENCODING_ISO8859_2", SWIG_From_int((int)(wxFONTENCODING_ISO8859_2)));
21986 }
21987 {
21988 PyDict_SetItemString(d,"FONTENCODING_ISO8859_3", SWIG_From_int((int)(wxFONTENCODING_ISO8859_3)));
21989 }
21990 {
21991 PyDict_SetItemString(d,"FONTENCODING_ISO8859_4", SWIG_From_int((int)(wxFONTENCODING_ISO8859_4)));
21992 }
21993 {
21994 PyDict_SetItemString(d,"FONTENCODING_ISO8859_5", SWIG_From_int((int)(wxFONTENCODING_ISO8859_5)));
21995 }
21996 {
21997 PyDict_SetItemString(d,"FONTENCODING_ISO8859_6", SWIG_From_int((int)(wxFONTENCODING_ISO8859_6)));
21998 }
21999 {
22000 PyDict_SetItemString(d,"FONTENCODING_ISO8859_7", SWIG_From_int((int)(wxFONTENCODING_ISO8859_7)));
22001 }
22002 {
22003 PyDict_SetItemString(d,"FONTENCODING_ISO8859_8", SWIG_From_int((int)(wxFONTENCODING_ISO8859_8)));
22004 }
22005 {
22006 PyDict_SetItemString(d,"FONTENCODING_ISO8859_9", SWIG_From_int((int)(wxFONTENCODING_ISO8859_9)));
22007 }
22008 {
22009 PyDict_SetItemString(d,"FONTENCODING_ISO8859_10", SWIG_From_int((int)(wxFONTENCODING_ISO8859_10)));
22010 }
22011 {
22012 PyDict_SetItemString(d,"FONTENCODING_ISO8859_11", SWIG_From_int((int)(wxFONTENCODING_ISO8859_11)));
22013 }
22014 {
22015 PyDict_SetItemString(d,"FONTENCODING_ISO8859_12", SWIG_From_int((int)(wxFONTENCODING_ISO8859_12)));
22016 }
22017 {
22018 PyDict_SetItemString(d,"FONTENCODING_ISO8859_13", SWIG_From_int((int)(wxFONTENCODING_ISO8859_13)));
22019 }
22020 {
22021 PyDict_SetItemString(d,"FONTENCODING_ISO8859_14", SWIG_From_int((int)(wxFONTENCODING_ISO8859_14)));
22022 }
22023 {
22024 PyDict_SetItemString(d,"FONTENCODING_ISO8859_15", SWIG_From_int((int)(wxFONTENCODING_ISO8859_15)));
22025 }
22026 {
22027 PyDict_SetItemString(d,"FONTENCODING_ISO8859_MAX", SWIG_From_int((int)(wxFONTENCODING_ISO8859_MAX)));
22028 }
22029 {
22030 PyDict_SetItemString(d,"FONTENCODING_KOI8", SWIG_From_int((int)(wxFONTENCODING_KOI8)));
22031 }
22032 {
22033 PyDict_SetItemString(d,"FONTENCODING_KOI8_U", SWIG_From_int((int)(wxFONTENCODING_KOI8_U)));
22034 }
22035 {
22036 PyDict_SetItemString(d,"FONTENCODING_ALTERNATIVE", SWIG_From_int((int)(wxFONTENCODING_ALTERNATIVE)));
22037 }
22038 {
22039 PyDict_SetItemString(d,"FONTENCODING_BULGARIAN", SWIG_From_int((int)(wxFONTENCODING_BULGARIAN)));
22040 }
22041 {
22042 PyDict_SetItemString(d,"FONTENCODING_CP437", SWIG_From_int((int)(wxFONTENCODING_CP437)));
22043 }
22044 {
22045 PyDict_SetItemString(d,"FONTENCODING_CP850", SWIG_From_int((int)(wxFONTENCODING_CP850)));
22046 }
22047 {
22048 PyDict_SetItemString(d,"FONTENCODING_CP852", SWIG_From_int((int)(wxFONTENCODING_CP852)));
22049 }
22050 {
22051 PyDict_SetItemString(d,"FONTENCODING_CP855", SWIG_From_int((int)(wxFONTENCODING_CP855)));
22052 }
22053 {
22054 PyDict_SetItemString(d,"FONTENCODING_CP866", SWIG_From_int((int)(wxFONTENCODING_CP866)));
22055 }
22056 {
22057 PyDict_SetItemString(d,"FONTENCODING_CP874", SWIG_From_int((int)(wxFONTENCODING_CP874)));
22058 }
22059 {
22060 PyDict_SetItemString(d,"FONTENCODING_CP932", SWIG_From_int((int)(wxFONTENCODING_CP932)));
22061 }
22062 {
22063 PyDict_SetItemString(d,"FONTENCODING_CP936", SWIG_From_int((int)(wxFONTENCODING_CP936)));
22064 }
22065 {
22066 PyDict_SetItemString(d,"FONTENCODING_CP949", SWIG_From_int((int)(wxFONTENCODING_CP949)));
22067 }
22068 {
22069 PyDict_SetItemString(d,"FONTENCODING_CP950", SWIG_From_int((int)(wxFONTENCODING_CP950)));
22070 }
22071 {
22072 PyDict_SetItemString(d,"FONTENCODING_CP1250", SWIG_From_int((int)(wxFONTENCODING_CP1250)));
22073 }
22074 {
22075 PyDict_SetItemString(d,"FONTENCODING_CP1251", SWIG_From_int((int)(wxFONTENCODING_CP1251)));
22076 }
22077 {
22078 PyDict_SetItemString(d,"FONTENCODING_CP1252", SWIG_From_int((int)(wxFONTENCODING_CP1252)));
22079 }
22080 {
22081 PyDict_SetItemString(d,"FONTENCODING_CP1253", SWIG_From_int((int)(wxFONTENCODING_CP1253)));
22082 }
22083 {
22084 PyDict_SetItemString(d,"FONTENCODING_CP1254", SWIG_From_int((int)(wxFONTENCODING_CP1254)));
22085 }
22086 {
22087 PyDict_SetItemString(d,"FONTENCODING_CP1255", SWIG_From_int((int)(wxFONTENCODING_CP1255)));
22088 }
22089 {
22090 PyDict_SetItemString(d,"FONTENCODING_CP1256", SWIG_From_int((int)(wxFONTENCODING_CP1256)));
22091 }
22092 {
22093 PyDict_SetItemString(d,"FONTENCODING_CP1257", SWIG_From_int((int)(wxFONTENCODING_CP1257)));
22094 }
22095 {
22096 PyDict_SetItemString(d,"FONTENCODING_CP12_MAX", SWIG_From_int((int)(wxFONTENCODING_CP12_MAX)));
22097 }
22098 {
22099 PyDict_SetItemString(d,"FONTENCODING_UTF7", SWIG_From_int((int)(wxFONTENCODING_UTF7)));
22100 }
22101 {
22102 PyDict_SetItemString(d,"FONTENCODING_UTF8", SWIG_From_int((int)(wxFONTENCODING_UTF8)));
22103 }
22104 {
22105 PyDict_SetItemString(d,"FONTENCODING_EUC_JP", SWIG_From_int((int)(wxFONTENCODING_EUC_JP)));
22106 }
22107 {
22108 PyDict_SetItemString(d,"FONTENCODING_UTF16BE", SWIG_From_int((int)(wxFONTENCODING_UTF16BE)));
22109 }
22110 {
22111 PyDict_SetItemString(d,"FONTENCODING_UTF16LE", SWIG_From_int((int)(wxFONTENCODING_UTF16LE)));
22112 }
22113 {
22114 PyDict_SetItemString(d,"FONTENCODING_UTF32BE", SWIG_From_int((int)(wxFONTENCODING_UTF32BE)));
22115 }
22116 {
22117 PyDict_SetItemString(d,"FONTENCODING_UTF32LE", SWIG_From_int((int)(wxFONTENCODING_UTF32LE)));
22118 }
22119 {
22120 PyDict_SetItemString(d,"FONTENCODING_MACROMAN", SWIG_From_int((int)(wxFONTENCODING_MACROMAN)));
22121 }
22122 {
22123 PyDict_SetItemString(d,"FONTENCODING_MACJAPANESE", SWIG_From_int((int)(wxFONTENCODING_MACJAPANESE)));
22124 }
22125 {
22126 PyDict_SetItemString(d,"FONTENCODING_MACCHINESETRAD", SWIG_From_int((int)(wxFONTENCODING_MACCHINESETRAD)));
22127 }
22128 {
22129 PyDict_SetItemString(d,"FONTENCODING_MACKOREAN", SWIG_From_int((int)(wxFONTENCODING_MACKOREAN)));
22130 }
22131 {
22132 PyDict_SetItemString(d,"FONTENCODING_MACARABIC", SWIG_From_int((int)(wxFONTENCODING_MACARABIC)));
22133 }
22134 {
22135 PyDict_SetItemString(d,"FONTENCODING_MACHEBREW", SWIG_From_int((int)(wxFONTENCODING_MACHEBREW)));
22136 }
22137 {
22138 PyDict_SetItemString(d,"FONTENCODING_MACGREEK", SWIG_From_int((int)(wxFONTENCODING_MACGREEK)));
22139 }
22140 {
22141 PyDict_SetItemString(d,"FONTENCODING_MACCYRILLIC", SWIG_From_int((int)(wxFONTENCODING_MACCYRILLIC)));
22142 }
22143 {
22144 PyDict_SetItemString(d,"FONTENCODING_MACDEVANAGARI", SWIG_From_int((int)(wxFONTENCODING_MACDEVANAGARI)));
22145 }
22146 {
22147 PyDict_SetItemString(d,"FONTENCODING_MACGURMUKHI", SWIG_From_int((int)(wxFONTENCODING_MACGURMUKHI)));
22148 }
22149 {
22150 PyDict_SetItemString(d,"FONTENCODING_MACGUJARATI", SWIG_From_int((int)(wxFONTENCODING_MACGUJARATI)));
22151 }
22152 {
22153 PyDict_SetItemString(d,"FONTENCODING_MACORIYA", SWIG_From_int((int)(wxFONTENCODING_MACORIYA)));
22154 }
22155 {
22156 PyDict_SetItemString(d,"FONTENCODING_MACBENGALI", SWIG_From_int((int)(wxFONTENCODING_MACBENGALI)));
22157 }
22158 {
22159 PyDict_SetItemString(d,"FONTENCODING_MACTAMIL", SWIG_From_int((int)(wxFONTENCODING_MACTAMIL)));
22160 }
22161 {
22162 PyDict_SetItemString(d,"FONTENCODING_MACTELUGU", SWIG_From_int((int)(wxFONTENCODING_MACTELUGU)));
22163 }
22164 {
22165 PyDict_SetItemString(d,"FONTENCODING_MACKANNADA", SWIG_From_int((int)(wxFONTENCODING_MACKANNADA)));
22166 }
22167 {
22168 PyDict_SetItemString(d,"FONTENCODING_MACMALAJALAM", SWIG_From_int((int)(wxFONTENCODING_MACMALAJALAM)));
22169 }
22170 {
22171 PyDict_SetItemString(d,"FONTENCODING_MACSINHALESE", SWIG_From_int((int)(wxFONTENCODING_MACSINHALESE)));
22172 }
22173 {
22174 PyDict_SetItemString(d,"FONTENCODING_MACBURMESE", SWIG_From_int((int)(wxFONTENCODING_MACBURMESE)));
22175 }
22176 {
22177 PyDict_SetItemString(d,"FONTENCODING_MACKHMER", SWIG_From_int((int)(wxFONTENCODING_MACKHMER)));
22178 }
22179 {
22180 PyDict_SetItemString(d,"FONTENCODING_MACTHAI", SWIG_From_int((int)(wxFONTENCODING_MACTHAI)));
22181 }
22182 {
22183 PyDict_SetItemString(d,"FONTENCODING_MACLAOTIAN", SWIG_From_int((int)(wxFONTENCODING_MACLAOTIAN)));
22184 }
22185 {
22186 PyDict_SetItemString(d,"FONTENCODING_MACGEORGIAN", SWIG_From_int((int)(wxFONTENCODING_MACGEORGIAN)));
22187 }
22188 {
22189 PyDict_SetItemString(d,"FONTENCODING_MACARMENIAN", SWIG_From_int((int)(wxFONTENCODING_MACARMENIAN)));
22190 }
22191 {
22192 PyDict_SetItemString(d,"FONTENCODING_MACCHINESESIMP", SWIG_From_int((int)(wxFONTENCODING_MACCHINESESIMP)));
22193 }
22194 {
22195 PyDict_SetItemString(d,"FONTENCODING_MACTIBETAN", SWIG_From_int((int)(wxFONTENCODING_MACTIBETAN)));
22196 }
22197 {
22198 PyDict_SetItemString(d,"FONTENCODING_MACMONGOLIAN", SWIG_From_int((int)(wxFONTENCODING_MACMONGOLIAN)));
22199 }
22200 {
22201 PyDict_SetItemString(d,"FONTENCODING_MACETHIOPIC", SWIG_From_int((int)(wxFONTENCODING_MACETHIOPIC)));
22202 }
22203 {
22204 PyDict_SetItemString(d,"FONTENCODING_MACCENTRALEUR", SWIG_From_int((int)(wxFONTENCODING_MACCENTRALEUR)));
22205 }
22206 {
22207 PyDict_SetItemString(d,"FONTENCODING_MACVIATNAMESE", SWIG_From_int((int)(wxFONTENCODING_MACVIATNAMESE)));
22208 }
22209 {
22210 PyDict_SetItemString(d,"FONTENCODING_MACARABICEXT", SWIG_From_int((int)(wxFONTENCODING_MACARABICEXT)));
22211 }
22212 {
22213 PyDict_SetItemString(d,"FONTENCODING_MACSYMBOL", SWIG_From_int((int)(wxFONTENCODING_MACSYMBOL)));
22214 }
22215 {
22216 PyDict_SetItemString(d,"FONTENCODING_MACDINGBATS", SWIG_From_int((int)(wxFONTENCODING_MACDINGBATS)));
22217 }
22218 {
22219 PyDict_SetItemString(d,"FONTENCODING_MACTURKISH", SWIG_From_int((int)(wxFONTENCODING_MACTURKISH)));
22220 }
22221 {
22222 PyDict_SetItemString(d,"FONTENCODING_MACCROATIAN", SWIG_From_int((int)(wxFONTENCODING_MACCROATIAN)));
22223 }
22224 {
22225 PyDict_SetItemString(d,"FONTENCODING_MACICELANDIC", SWIG_From_int((int)(wxFONTENCODING_MACICELANDIC)));
22226 }
22227 {
22228 PyDict_SetItemString(d,"FONTENCODING_MACROMANIAN", SWIG_From_int((int)(wxFONTENCODING_MACROMANIAN)));
22229 }
22230 {
22231 PyDict_SetItemString(d,"FONTENCODING_MACCELTIC", SWIG_From_int((int)(wxFONTENCODING_MACCELTIC)));
22232 }
22233 {
22234 PyDict_SetItemString(d,"FONTENCODING_MACGAELIC", SWIG_From_int((int)(wxFONTENCODING_MACGAELIC)));
22235 }
22236 {
22237 PyDict_SetItemString(d,"FONTENCODING_MACKEYBOARD", SWIG_From_int((int)(wxFONTENCODING_MACKEYBOARD)));
22238 }
22239 {
22240 PyDict_SetItemString(d,"FONTENCODING_MACMIN", SWIG_From_int((int)(wxFONTENCODING_MACMIN)));
22241 }
22242 {
22243 PyDict_SetItemString(d,"FONTENCODING_MACMAX", SWIG_From_int((int)(wxFONTENCODING_MACMAX)));
22244 }
22245 {
22246 PyDict_SetItemString(d,"FONTENCODING_MAX", SWIG_From_int((int)(wxFONTENCODING_MAX)));
22247 }
22248 {
22249 PyDict_SetItemString(d,"FONTENCODING_UTF16", SWIG_From_int((int)(wxFONTENCODING_UTF16)));
22250 }
22251 {
22252 PyDict_SetItemString(d,"FONTENCODING_UTF32", SWIG_From_int((int)(wxFONTENCODING_UTF32)));
22253 }
22254 {
22255 PyDict_SetItemString(d,"FONTENCODING_UNICODE", SWIG_From_int((int)(wxFONTENCODING_UNICODE)));
22256 }
22257 {
22258 PyDict_SetItemString(d,"FONTENCODING_GB2312", SWIG_From_int((int)(wxFONTENCODING_GB2312)));
22259 }
22260 {
22261 PyDict_SetItemString(d,"FONTENCODING_BIG5", SWIG_From_int((int)(wxFONTENCODING_BIG5)));
22262 }
22263 {
22264 PyDict_SetItemString(d,"FONTENCODING_SHIFT_JIS", SWIG_From_int((int)(wxFONTENCODING_SHIFT_JIS)));
22265 }
22266
22267 wxPyPtrTypeMap_Add("wxFontEnumerator", "wxPyFontEnumerator");
22268
22269 {
22270 PyDict_SetItemString(d,"LANGUAGE_DEFAULT", SWIG_From_int((int)(wxLANGUAGE_DEFAULT)));
22271 }
22272 {
22273 PyDict_SetItemString(d,"LANGUAGE_UNKNOWN", SWIG_From_int((int)(wxLANGUAGE_UNKNOWN)));
22274 }
22275 {
22276 PyDict_SetItemString(d,"LANGUAGE_ABKHAZIAN", SWIG_From_int((int)(wxLANGUAGE_ABKHAZIAN)));
22277 }
22278 {
22279 PyDict_SetItemString(d,"LANGUAGE_AFAR", SWIG_From_int((int)(wxLANGUAGE_AFAR)));
22280 }
22281 {
22282 PyDict_SetItemString(d,"LANGUAGE_AFRIKAANS", SWIG_From_int((int)(wxLANGUAGE_AFRIKAANS)));
22283 }
22284 {
22285 PyDict_SetItemString(d,"LANGUAGE_ALBANIAN", SWIG_From_int((int)(wxLANGUAGE_ALBANIAN)));
22286 }
22287 {
22288 PyDict_SetItemString(d,"LANGUAGE_AMHARIC", SWIG_From_int((int)(wxLANGUAGE_AMHARIC)));
22289 }
22290 {
22291 PyDict_SetItemString(d,"LANGUAGE_ARABIC", SWIG_From_int((int)(wxLANGUAGE_ARABIC)));
22292 }
22293 {
22294 PyDict_SetItemString(d,"LANGUAGE_ARABIC_ALGERIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_ALGERIA)));
22295 }
22296 {
22297 PyDict_SetItemString(d,"LANGUAGE_ARABIC_BAHRAIN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_BAHRAIN)));
22298 }
22299 {
22300 PyDict_SetItemString(d,"LANGUAGE_ARABIC_EGYPT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_EGYPT)));
22301 }
22302 {
22303 PyDict_SetItemString(d,"LANGUAGE_ARABIC_IRAQ", SWIG_From_int((int)(wxLANGUAGE_ARABIC_IRAQ)));
22304 }
22305 {
22306 PyDict_SetItemString(d,"LANGUAGE_ARABIC_JORDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_JORDAN)));
22307 }
22308 {
22309 PyDict_SetItemString(d,"LANGUAGE_ARABIC_KUWAIT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_KUWAIT)));
22310 }
22311 {
22312 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LEBANON", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LEBANON)));
22313 }
22314 {
22315 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LIBYA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LIBYA)));
22316 }
22317 {
22318 PyDict_SetItemString(d,"LANGUAGE_ARABIC_MOROCCO", SWIG_From_int((int)(wxLANGUAGE_ARABIC_MOROCCO)));
22319 }
22320 {
22321 PyDict_SetItemString(d,"LANGUAGE_ARABIC_OMAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_OMAN)));
22322 }
22323 {
22324 PyDict_SetItemString(d,"LANGUAGE_ARABIC_QATAR", SWIG_From_int((int)(wxLANGUAGE_ARABIC_QATAR)));
22325 }
22326 {
22327 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SAUDI_ARABIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SAUDI_ARABIA)));
22328 }
22329 {
22330 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SUDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SUDAN)));
22331 }
22332 {
22333 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SYRIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SYRIA)));
22334 }
22335 {
22336 PyDict_SetItemString(d,"LANGUAGE_ARABIC_TUNISIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_TUNISIA)));
22337 }
22338 {
22339 PyDict_SetItemString(d,"LANGUAGE_ARABIC_UAE", SWIG_From_int((int)(wxLANGUAGE_ARABIC_UAE)));
22340 }
22341 {
22342 PyDict_SetItemString(d,"LANGUAGE_ARABIC_YEMEN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_YEMEN)));
22343 }
22344 {
22345 PyDict_SetItemString(d,"LANGUAGE_ARMENIAN", SWIG_From_int((int)(wxLANGUAGE_ARMENIAN)));
22346 }
22347 {
22348 PyDict_SetItemString(d,"LANGUAGE_ASSAMESE", SWIG_From_int((int)(wxLANGUAGE_ASSAMESE)));
22349 }
22350 {
22351 PyDict_SetItemString(d,"LANGUAGE_AYMARA", SWIG_From_int((int)(wxLANGUAGE_AYMARA)));
22352 }
22353 {
22354 PyDict_SetItemString(d,"LANGUAGE_AZERI", SWIG_From_int((int)(wxLANGUAGE_AZERI)));
22355 }
22356 {
22357 PyDict_SetItemString(d,"LANGUAGE_AZERI_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_AZERI_CYRILLIC)));
22358 }
22359 {
22360 PyDict_SetItemString(d,"LANGUAGE_AZERI_LATIN", SWIG_From_int((int)(wxLANGUAGE_AZERI_LATIN)));
22361 }
22362 {
22363 PyDict_SetItemString(d,"LANGUAGE_BASHKIR", SWIG_From_int((int)(wxLANGUAGE_BASHKIR)));
22364 }
22365 {
22366 PyDict_SetItemString(d,"LANGUAGE_BASQUE", SWIG_From_int((int)(wxLANGUAGE_BASQUE)));
22367 }
22368 {
22369 PyDict_SetItemString(d,"LANGUAGE_BELARUSIAN", SWIG_From_int((int)(wxLANGUAGE_BELARUSIAN)));
22370 }
22371 {
22372 PyDict_SetItemString(d,"LANGUAGE_BENGALI", SWIG_From_int((int)(wxLANGUAGE_BENGALI)));
22373 }
22374 {
22375 PyDict_SetItemString(d,"LANGUAGE_BHUTANI", SWIG_From_int((int)(wxLANGUAGE_BHUTANI)));
22376 }
22377 {
22378 PyDict_SetItemString(d,"LANGUAGE_BIHARI", SWIG_From_int((int)(wxLANGUAGE_BIHARI)));
22379 }
22380 {
22381 PyDict_SetItemString(d,"LANGUAGE_BISLAMA", SWIG_From_int((int)(wxLANGUAGE_BISLAMA)));
22382 }
22383 {
22384 PyDict_SetItemString(d,"LANGUAGE_BRETON", SWIG_From_int((int)(wxLANGUAGE_BRETON)));
22385 }
22386 {
22387 PyDict_SetItemString(d,"LANGUAGE_BULGARIAN", SWIG_From_int((int)(wxLANGUAGE_BULGARIAN)));
22388 }
22389 {
22390 PyDict_SetItemString(d,"LANGUAGE_BURMESE", SWIG_From_int((int)(wxLANGUAGE_BURMESE)));
22391 }
22392 {
22393 PyDict_SetItemString(d,"LANGUAGE_CAMBODIAN", SWIG_From_int((int)(wxLANGUAGE_CAMBODIAN)));
22394 }
22395 {
22396 PyDict_SetItemString(d,"LANGUAGE_CATALAN", SWIG_From_int((int)(wxLANGUAGE_CATALAN)));
22397 }
22398 {
22399 PyDict_SetItemString(d,"LANGUAGE_CHINESE", SWIG_From_int((int)(wxLANGUAGE_CHINESE)));
22400 }
22401 {
22402 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SIMPLIFIED", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SIMPLIFIED)));
22403 }
22404 {
22405 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TRADITIONAL", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TRADITIONAL)));
22406 }
22407 {
22408 PyDict_SetItemString(d,"LANGUAGE_CHINESE_HONGKONG", SWIG_From_int((int)(wxLANGUAGE_CHINESE_HONGKONG)));
22409 }
22410 {
22411 PyDict_SetItemString(d,"LANGUAGE_CHINESE_MACAU", SWIG_From_int((int)(wxLANGUAGE_CHINESE_MACAU)));
22412 }
22413 {
22414 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SINGAPORE", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SINGAPORE)));
22415 }
22416 {
22417 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TAIWAN", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TAIWAN)));
22418 }
22419 {
22420 PyDict_SetItemString(d,"LANGUAGE_CORSICAN", SWIG_From_int((int)(wxLANGUAGE_CORSICAN)));
22421 }
22422 {
22423 PyDict_SetItemString(d,"LANGUAGE_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_CROATIAN)));
22424 }
22425 {
22426 PyDict_SetItemString(d,"LANGUAGE_CZECH", SWIG_From_int((int)(wxLANGUAGE_CZECH)));
22427 }
22428 {
22429 PyDict_SetItemString(d,"LANGUAGE_DANISH", SWIG_From_int((int)(wxLANGUAGE_DANISH)));
22430 }
22431 {
22432 PyDict_SetItemString(d,"LANGUAGE_DUTCH", SWIG_From_int((int)(wxLANGUAGE_DUTCH)));
22433 }
22434 {
22435 PyDict_SetItemString(d,"LANGUAGE_DUTCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_DUTCH_BELGIAN)));
22436 }
22437 {
22438 PyDict_SetItemString(d,"LANGUAGE_ENGLISH", SWIG_From_int((int)(wxLANGUAGE_ENGLISH)));
22439 }
22440 {
22441 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_UK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_UK)));
22442 }
22443 {
22444 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_US", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_US)));
22445 }
22446 {
22447 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_AUSTRALIA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_AUSTRALIA)));
22448 }
22449 {
22450 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BELIZE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BELIZE)));
22451 }
22452 {
22453 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BOTSWANA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BOTSWANA)));
22454 }
22455 {
22456 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CANADA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CANADA)));
22457 }
22458 {
22459 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CARIBBEAN", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CARIBBEAN)));
22460 }
22461 {
22462 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_DENMARK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_DENMARK)));
22463 }
22464 {
22465 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_EIRE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_EIRE)));
22466 }
22467 {
22468 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_JAMAICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_JAMAICA)));
22469 }
22470 {
22471 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_NEW_ZEALAND", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_NEW_ZEALAND)));
22472 }
22473 {
22474 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_PHILIPPINES", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_PHILIPPINES)));
22475 }
22476 {
22477 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_SOUTH_AFRICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_SOUTH_AFRICA)));
22478 }
22479 {
22480 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_TRINIDAD", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_TRINIDAD)));
22481 }
22482 {
22483 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_ZIMBABWE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_ZIMBABWE)));
22484 }
22485 {
22486 PyDict_SetItemString(d,"LANGUAGE_ESPERANTO", SWIG_From_int((int)(wxLANGUAGE_ESPERANTO)));
22487 }
22488 {
22489 PyDict_SetItemString(d,"LANGUAGE_ESTONIAN", SWIG_From_int((int)(wxLANGUAGE_ESTONIAN)));
22490 }
22491 {
22492 PyDict_SetItemString(d,"LANGUAGE_FAEROESE", SWIG_From_int((int)(wxLANGUAGE_FAEROESE)));
22493 }
22494 {
22495 PyDict_SetItemString(d,"LANGUAGE_FARSI", SWIG_From_int((int)(wxLANGUAGE_FARSI)));
22496 }
22497 {
22498 PyDict_SetItemString(d,"LANGUAGE_FIJI", SWIG_From_int((int)(wxLANGUAGE_FIJI)));
22499 }
22500 {
22501 PyDict_SetItemString(d,"LANGUAGE_FINNISH", SWIG_From_int((int)(wxLANGUAGE_FINNISH)));
22502 }
22503 {
22504 PyDict_SetItemString(d,"LANGUAGE_FRENCH", SWIG_From_int((int)(wxLANGUAGE_FRENCH)));
22505 }
22506 {
22507 PyDict_SetItemString(d,"LANGUAGE_FRENCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_BELGIAN)));
22508 }
22509 {
22510 PyDict_SetItemString(d,"LANGUAGE_FRENCH_CANADIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_CANADIAN)));
22511 }
22512 {
22513 PyDict_SetItemString(d,"LANGUAGE_FRENCH_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_FRENCH_LUXEMBOURG)));
22514 }
22515 {
22516 PyDict_SetItemString(d,"LANGUAGE_FRENCH_MONACO", SWIG_From_int((int)(wxLANGUAGE_FRENCH_MONACO)));
22517 }
22518 {
22519 PyDict_SetItemString(d,"LANGUAGE_FRENCH_SWISS", SWIG_From_int((int)(wxLANGUAGE_FRENCH_SWISS)));
22520 }
22521 {
22522 PyDict_SetItemString(d,"LANGUAGE_FRISIAN", SWIG_From_int((int)(wxLANGUAGE_FRISIAN)));
22523 }
22524 {
22525 PyDict_SetItemString(d,"LANGUAGE_GALICIAN", SWIG_From_int((int)(wxLANGUAGE_GALICIAN)));
22526 }
22527 {
22528 PyDict_SetItemString(d,"LANGUAGE_GEORGIAN", SWIG_From_int((int)(wxLANGUAGE_GEORGIAN)));
22529 }
22530 {
22531 PyDict_SetItemString(d,"LANGUAGE_GERMAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN)));
22532 }
22533 {
22534 PyDict_SetItemString(d,"LANGUAGE_GERMAN_AUSTRIAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_AUSTRIAN)));
22535 }
22536 {
22537 PyDict_SetItemString(d,"LANGUAGE_GERMAN_BELGIUM", SWIG_From_int((int)(wxLANGUAGE_GERMAN_BELGIUM)));
22538 }
22539 {
22540 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LIECHTENSTEIN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LIECHTENSTEIN)));
22541 }
22542 {
22543 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LUXEMBOURG)));
22544 }
22545 {
22546 PyDict_SetItemString(d,"LANGUAGE_GERMAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_GERMAN_SWISS)));
22547 }
22548 {
22549 PyDict_SetItemString(d,"LANGUAGE_GREEK", SWIG_From_int((int)(wxLANGUAGE_GREEK)));
22550 }
22551 {
22552 PyDict_SetItemString(d,"LANGUAGE_GREENLANDIC", SWIG_From_int((int)(wxLANGUAGE_GREENLANDIC)));
22553 }
22554 {
22555 PyDict_SetItemString(d,"LANGUAGE_GUARANI", SWIG_From_int((int)(wxLANGUAGE_GUARANI)));
22556 }
22557 {
22558 PyDict_SetItemString(d,"LANGUAGE_GUJARATI", SWIG_From_int((int)(wxLANGUAGE_GUJARATI)));
22559 }
22560 {
22561 PyDict_SetItemString(d,"LANGUAGE_HAUSA", SWIG_From_int((int)(wxLANGUAGE_HAUSA)));
22562 }
22563 {
22564 PyDict_SetItemString(d,"LANGUAGE_HEBREW", SWIG_From_int((int)(wxLANGUAGE_HEBREW)));
22565 }
22566 {
22567 PyDict_SetItemString(d,"LANGUAGE_HINDI", SWIG_From_int((int)(wxLANGUAGE_HINDI)));
22568 }
22569 {
22570 PyDict_SetItemString(d,"LANGUAGE_HUNGARIAN", SWIG_From_int((int)(wxLANGUAGE_HUNGARIAN)));
22571 }
22572 {
22573 PyDict_SetItemString(d,"LANGUAGE_ICELANDIC", SWIG_From_int((int)(wxLANGUAGE_ICELANDIC)));
22574 }
22575 {
22576 PyDict_SetItemString(d,"LANGUAGE_INDONESIAN", SWIG_From_int((int)(wxLANGUAGE_INDONESIAN)));
22577 }
22578 {
22579 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUA", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUA)));
22580 }
22581 {
22582 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUE", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUE)));
22583 }
22584 {
22585 PyDict_SetItemString(d,"LANGUAGE_INUKTITUT", SWIG_From_int((int)(wxLANGUAGE_INUKTITUT)));
22586 }
22587 {
22588 PyDict_SetItemString(d,"LANGUAGE_INUPIAK", SWIG_From_int((int)(wxLANGUAGE_INUPIAK)));
22589 }
22590 {
22591 PyDict_SetItemString(d,"LANGUAGE_IRISH", SWIG_From_int((int)(wxLANGUAGE_IRISH)));
22592 }
22593 {
22594 PyDict_SetItemString(d,"LANGUAGE_ITALIAN", SWIG_From_int((int)(wxLANGUAGE_ITALIAN)));
22595 }
22596 {
22597 PyDict_SetItemString(d,"LANGUAGE_ITALIAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_ITALIAN_SWISS)));
22598 }
22599 {
22600 PyDict_SetItemString(d,"LANGUAGE_JAPANESE", SWIG_From_int((int)(wxLANGUAGE_JAPANESE)));
22601 }
22602 {
22603 PyDict_SetItemString(d,"LANGUAGE_JAVANESE", SWIG_From_int((int)(wxLANGUAGE_JAVANESE)));
22604 }
22605 {
22606 PyDict_SetItemString(d,"LANGUAGE_KANNADA", SWIG_From_int((int)(wxLANGUAGE_KANNADA)));
22607 }
22608 {
22609 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI)));
22610 }
22611 {
22612 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI_INDIA", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI_INDIA)));
22613 }
22614 {
22615 PyDict_SetItemString(d,"LANGUAGE_KAZAKH", SWIG_From_int((int)(wxLANGUAGE_KAZAKH)));
22616 }
22617 {
22618 PyDict_SetItemString(d,"LANGUAGE_KERNEWEK", SWIG_From_int((int)(wxLANGUAGE_KERNEWEK)));
22619 }
22620 {
22621 PyDict_SetItemString(d,"LANGUAGE_KINYARWANDA", SWIG_From_int((int)(wxLANGUAGE_KINYARWANDA)));
22622 }
22623 {
22624 PyDict_SetItemString(d,"LANGUAGE_KIRGHIZ", SWIG_From_int((int)(wxLANGUAGE_KIRGHIZ)));
22625 }
22626 {
22627 PyDict_SetItemString(d,"LANGUAGE_KIRUNDI", SWIG_From_int((int)(wxLANGUAGE_KIRUNDI)));
22628 }
22629 {
22630 PyDict_SetItemString(d,"LANGUAGE_KONKANI", SWIG_From_int((int)(wxLANGUAGE_KONKANI)));
22631 }
22632 {
22633 PyDict_SetItemString(d,"LANGUAGE_KOREAN", SWIG_From_int((int)(wxLANGUAGE_KOREAN)));
22634 }
22635 {
22636 PyDict_SetItemString(d,"LANGUAGE_KURDISH", SWIG_From_int((int)(wxLANGUAGE_KURDISH)));
22637 }
22638 {
22639 PyDict_SetItemString(d,"LANGUAGE_LAOTHIAN", SWIG_From_int((int)(wxLANGUAGE_LAOTHIAN)));
22640 }
22641 {
22642 PyDict_SetItemString(d,"LANGUAGE_LATIN", SWIG_From_int((int)(wxLANGUAGE_LATIN)));
22643 }
22644 {
22645 PyDict_SetItemString(d,"LANGUAGE_LATVIAN", SWIG_From_int((int)(wxLANGUAGE_LATVIAN)));
22646 }
22647 {
22648 PyDict_SetItemString(d,"LANGUAGE_LINGALA", SWIG_From_int((int)(wxLANGUAGE_LINGALA)));
22649 }
22650 {
22651 PyDict_SetItemString(d,"LANGUAGE_LITHUANIAN", SWIG_From_int((int)(wxLANGUAGE_LITHUANIAN)));
22652 }
22653 {
22654 PyDict_SetItemString(d,"LANGUAGE_MACEDONIAN", SWIG_From_int((int)(wxLANGUAGE_MACEDONIAN)));
22655 }
22656 {
22657 PyDict_SetItemString(d,"LANGUAGE_MALAGASY", SWIG_From_int((int)(wxLANGUAGE_MALAGASY)));
22658 }
22659 {
22660 PyDict_SetItemString(d,"LANGUAGE_MALAY", SWIG_From_int((int)(wxLANGUAGE_MALAY)));
22661 }
22662 {
22663 PyDict_SetItemString(d,"LANGUAGE_MALAYALAM", SWIG_From_int((int)(wxLANGUAGE_MALAYALAM)));
22664 }
22665 {
22666 PyDict_SetItemString(d,"LANGUAGE_MALAY_BRUNEI_DARUSSALAM", SWIG_From_int((int)(wxLANGUAGE_MALAY_BRUNEI_DARUSSALAM)));
22667 }
22668 {
22669 PyDict_SetItemString(d,"LANGUAGE_MALAY_MALAYSIA", SWIG_From_int((int)(wxLANGUAGE_MALAY_MALAYSIA)));
22670 }
22671 {
22672 PyDict_SetItemString(d,"LANGUAGE_MALTESE", SWIG_From_int((int)(wxLANGUAGE_MALTESE)));
22673 }
22674 {
22675 PyDict_SetItemString(d,"LANGUAGE_MANIPURI", SWIG_From_int((int)(wxLANGUAGE_MANIPURI)));
22676 }
22677 {
22678 PyDict_SetItemString(d,"LANGUAGE_MAORI", SWIG_From_int((int)(wxLANGUAGE_MAORI)));
22679 }
22680 {
22681 PyDict_SetItemString(d,"LANGUAGE_MARATHI", SWIG_From_int((int)(wxLANGUAGE_MARATHI)));
22682 }
22683 {
22684 PyDict_SetItemString(d,"LANGUAGE_MOLDAVIAN", SWIG_From_int((int)(wxLANGUAGE_MOLDAVIAN)));
22685 }
22686 {
22687 PyDict_SetItemString(d,"LANGUAGE_MONGOLIAN", SWIG_From_int((int)(wxLANGUAGE_MONGOLIAN)));
22688 }
22689 {
22690 PyDict_SetItemString(d,"LANGUAGE_NAURU", SWIG_From_int((int)(wxLANGUAGE_NAURU)));
22691 }
22692 {
22693 PyDict_SetItemString(d,"LANGUAGE_NEPALI", SWIG_From_int((int)(wxLANGUAGE_NEPALI)));
22694 }
22695 {
22696 PyDict_SetItemString(d,"LANGUAGE_NEPALI_INDIA", SWIG_From_int((int)(wxLANGUAGE_NEPALI_INDIA)));
22697 }
22698 {
22699 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_BOKMAL", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_BOKMAL)));
22700 }
22701 {
22702 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_NYNORSK", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_NYNORSK)));
22703 }
22704 {
22705 PyDict_SetItemString(d,"LANGUAGE_OCCITAN", SWIG_From_int((int)(wxLANGUAGE_OCCITAN)));
22706 }
22707 {
22708 PyDict_SetItemString(d,"LANGUAGE_ORIYA", SWIG_From_int((int)(wxLANGUAGE_ORIYA)));
22709 }
22710 {
22711 PyDict_SetItemString(d,"LANGUAGE_OROMO", SWIG_From_int((int)(wxLANGUAGE_OROMO)));
22712 }
22713 {
22714 PyDict_SetItemString(d,"LANGUAGE_PASHTO", SWIG_From_int((int)(wxLANGUAGE_PASHTO)));
22715 }
22716 {
22717 PyDict_SetItemString(d,"LANGUAGE_POLISH", SWIG_From_int((int)(wxLANGUAGE_POLISH)));
22718 }
22719 {
22720 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE)));
22721 }
22722 {
22723 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE_BRAZILIAN", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE_BRAZILIAN)));
22724 }
22725 {
22726 PyDict_SetItemString(d,"LANGUAGE_PUNJABI", SWIG_From_int((int)(wxLANGUAGE_PUNJABI)));
22727 }
22728 {
22729 PyDict_SetItemString(d,"LANGUAGE_QUECHUA", SWIG_From_int((int)(wxLANGUAGE_QUECHUA)));
22730 }
22731 {
22732 PyDict_SetItemString(d,"LANGUAGE_RHAETO_ROMANCE", SWIG_From_int((int)(wxLANGUAGE_RHAETO_ROMANCE)));
22733 }
22734 {
22735 PyDict_SetItemString(d,"LANGUAGE_ROMANIAN", SWIG_From_int((int)(wxLANGUAGE_ROMANIAN)));
22736 }
22737 {
22738 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN)));
22739 }
22740 {
22741 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN_UKRAINE", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN_UKRAINE)));
22742 }
22743 {
22744 PyDict_SetItemString(d,"LANGUAGE_SAMOAN", SWIG_From_int((int)(wxLANGUAGE_SAMOAN)));
22745 }
22746 {
22747 PyDict_SetItemString(d,"LANGUAGE_SANGHO", SWIG_From_int((int)(wxLANGUAGE_SANGHO)));
22748 }
22749 {
22750 PyDict_SetItemString(d,"LANGUAGE_SANSKRIT", SWIG_From_int((int)(wxLANGUAGE_SANSKRIT)));
22751 }
22752 {
22753 PyDict_SetItemString(d,"LANGUAGE_SCOTS_GAELIC", SWIG_From_int((int)(wxLANGUAGE_SCOTS_GAELIC)));
22754 }
22755 {
22756 PyDict_SetItemString(d,"LANGUAGE_SERBIAN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN)));
22757 }
22758 {
22759 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_CYRILLIC)));
22760 }
22761 {
22762 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_LATIN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_LATIN)));
22763 }
22764 {
22765 PyDict_SetItemString(d,"LANGUAGE_SERBO_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_SERBO_CROATIAN)));
22766 }
22767 {
22768 PyDict_SetItemString(d,"LANGUAGE_SESOTHO", SWIG_From_int((int)(wxLANGUAGE_SESOTHO)));
22769 }
22770 {
22771 PyDict_SetItemString(d,"LANGUAGE_SETSWANA", SWIG_From_int((int)(wxLANGUAGE_SETSWANA)));
22772 }
22773 {
22774 PyDict_SetItemString(d,"LANGUAGE_SHONA", SWIG_From_int((int)(wxLANGUAGE_SHONA)));
22775 }
22776 {
22777 PyDict_SetItemString(d,"LANGUAGE_SINDHI", SWIG_From_int((int)(wxLANGUAGE_SINDHI)));
22778 }
22779 {
22780 PyDict_SetItemString(d,"LANGUAGE_SINHALESE", SWIG_From_int((int)(wxLANGUAGE_SINHALESE)));
22781 }
22782 {
22783 PyDict_SetItemString(d,"LANGUAGE_SISWATI", SWIG_From_int((int)(wxLANGUAGE_SISWATI)));
22784 }
22785 {
22786 PyDict_SetItemString(d,"LANGUAGE_SLOVAK", SWIG_From_int((int)(wxLANGUAGE_SLOVAK)));
22787 }
22788 {
22789 PyDict_SetItemString(d,"LANGUAGE_SLOVENIAN", SWIG_From_int((int)(wxLANGUAGE_SLOVENIAN)));
22790 }
22791 {
22792 PyDict_SetItemString(d,"LANGUAGE_SOMALI", SWIG_From_int((int)(wxLANGUAGE_SOMALI)));
22793 }
22794 {
22795 PyDict_SetItemString(d,"LANGUAGE_SPANISH", SWIG_From_int((int)(wxLANGUAGE_SPANISH)));
22796 }
22797 {
22798 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ARGENTINA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ARGENTINA)));
22799 }
22800 {
22801 PyDict_SetItemString(d,"LANGUAGE_SPANISH_BOLIVIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_BOLIVIA)));
22802 }
22803 {
22804 PyDict_SetItemString(d,"LANGUAGE_SPANISH_CHILE", SWIG_From_int((int)(wxLANGUAGE_SPANISH_CHILE)));
22805 }
22806 {
22807 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COLOMBIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COLOMBIA)));
22808 }
22809 {
22810 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COSTA_RICA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COSTA_RICA)));
22811 }
22812 {
22813 PyDict_SetItemString(d,"LANGUAGE_SPANISH_DOMINICAN_REPUBLIC", SWIG_From_int((int)(wxLANGUAGE_SPANISH_DOMINICAN_REPUBLIC)));
22814 }
22815 {
22816 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ECUADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ECUADOR)));
22817 }
22818 {
22819 PyDict_SetItemString(d,"LANGUAGE_SPANISH_EL_SALVADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_EL_SALVADOR)));
22820 }
22821 {
22822 PyDict_SetItemString(d,"LANGUAGE_SPANISH_GUATEMALA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_GUATEMALA)));
22823 }
22824 {
22825 PyDict_SetItemString(d,"LANGUAGE_SPANISH_HONDURAS", SWIG_From_int((int)(wxLANGUAGE_SPANISH_HONDURAS)));
22826 }
22827 {
22828 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MEXICAN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MEXICAN)));
22829 }
22830 {
22831 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MODERN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MODERN)));
22832 }
22833 {
22834 PyDict_SetItemString(d,"LANGUAGE_SPANISH_NICARAGUA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_NICARAGUA)));
22835 }
22836 {
22837 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PANAMA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PANAMA)));
22838 }
22839 {
22840 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PARAGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PARAGUAY)));
22841 }
22842 {
22843 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PERU", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PERU)));
22844 }
22845 {
22846 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PUERTO_RICO", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PUERTO_RICO)));
22847 }
22848 {
22849 PyDict_SetItemString(d,"LANGUAGE_SPANISH_URUGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_URUGUAY)));
22850 }
22851 {
22852 PyDict_SetItemString(d,"LANGUAGE_SPANISH_US", SWIG_From_int((int)(wxLANGUAGE_SPANISH_US)));
22853 }
22854 {
22855 PyDict_SetItemString(d,"LANGUAGE_SPANISH_VENEZUELA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_VENEZUELA)));
22856 }
22857 {
22858 PyDict_SetItemString(d,"LANGUAGE_SUNDANESE", SWIG_From_int((int)(wxLANGUAGE_SUNDANESE)));
22859 }
22860 {
22861 PyDict_SetItemString(d,"LANGUAGE_SWAHILI", SWIG_From_int((int)(wxLANGUAGE_SWAHILI)));
22862 }
22863 {
22864 PyDict_SetItemString(d,"LANGUAGE_SWEDISH", SWIG_From_int((int)(wxLANGUAGE_SWEDISH)));
22865 }
22866 {
22867 PyDict_SetItemString(d,"LANGUAGE_SWEDISH_FINLAND", SWIG_From_int((int)(wxLANGUAGE_SWEDISH_FINLAND)));
22868 }
22869 {
22870 PyDict_SetItemString(d,"LANGUAGE_TAGALOG", SWIG_From_int((int)(wxLANGUAGE_TAGALOG)));
22871 }
22872 {
22873 PyDict_SetItemString(d,"LANGUAGE_TAJIK", SWIG_From_int((int)(wxLANGUAGE_TAJIK)));
22874 }
22875 {
22876 PyDict_SetItemString(d,"LANGUAGE_TAMIL", SWIG_From_int((int)(wxLANGUAGE_TAMIL)));
22877 }
22878 {
22879 PyDict_SetItemString(d,"LANGUAGE_TATAR", SWIG_From_int((int)(wxLANGUAGE_TATAR)));
22880 }
22881 {
22882 PyDict_SetItemString(d,"LANGUAGE_TELUGU", SWIG_From_int((int)(wxLANGUAGE_TELUGU)));
22883 }
22884 {
22885 PyDict_SetItemString(d,"LANGUAGE_THAI", SWIG_From_int((int)(wxLANGUAGE_THAI)));
22886 }
22887 {
22888 PyDict_SetItemString(d,"LANGUAGE_TIBETAN", SWIG_From_int((int)(wxLANGUAGE_TIBETAN)));
22889 }
22890 {
22891 PyDict_SetItemString(d,"LANGUAGE_TIGRINYA", SWIG_From_int((int)(wxLANGUAGE_TIGRINYA)));
22892 }
22893 {
22894 PyDict_SetItemString(d,"LANGUAGE_TONGA", SWIG_From_int((int)(wxLANGUAGE_TONGA)));
22895 }
22896 {
22897 PyDict_SetItemString(d,"LANGUAGE_TSONGA", SWIG_From_int((int)(wxLANGUAGE_TSONGA)));
22898 }
22899 {
22900 PyDict_SetItemString(d,"LANGUAGE_TURKISH", SWIG_From_int((int)(wxLANGUAGE_TURKISH)));
22901 }
22902 {
22903 PyDict_SetItemString(d,"LANGUAGE_TURKMEN", SWIG_From_int((int)(wxLANGUAGE_TURKMEN)));
22904 }
22905 {
22906 PyDict_SetItemString(d,"LANGUAGE_TWI", SWIG_From_int((int)(wxLANGUAGE_TWI)));
22907 }
22908 {
22909 PyDict_SetItemString(d,"LANGUAGE_UIGHUR", SWIG_From_int((int)(wxLANGUAGE_UIGHUR)));
22910 }
22911 {
22912 PyDict_SetItemString(d,"LANGUAGE_UKRAINIAN", SWIG_From_int((int)(wxLANGUAGE_UKRAINIAN)));
22913 }
22914 {
22915 PyDict_SetItemString(d,"LANGUAGE_URDU", SWIG_From_int((int)(wxLANGUAGE_URDU)));
22916 }
22917 {
22918 PyDict_SetItemString(d,"LANGUAGE_URDU_INDIA", SWIG_From_int((int)(wxLANGUAGE_URDU_INDIA)));
22919 }
22920 {
22921 PyDict_SetItemString(d,"LANGUAGE_URDU_PAKISTAN", SWIG_From_int((int)(wxLANGUAGE_URDU_PAKISTAN)));
22922 }
22923 {
22924 PyDict_SetItemString(d,"LANGUAGE_UZBEK", SWIG_From_int((int)(wxLANGUAGE_UZBEK)));
22925 }
22926 {
22927 PyDict_SetItemString(d,"LANGUAGE_UZBEK_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_UZBEK_CYRILLIC)));
22928 }
22929 {
22930 PyDict_SetItemString(d,"LANGUAGE_UZBEK_LATIN", SWIG_From_int((int)(wxLANGUAGE_UZBEK_LATIN)));
22931 }
22932 {
22933 PyDict_SetItemString(d,"LANGUAGE_VIETNAMESE", SWIG_From_int((int)(wxLANGUAGE_VIETNAMESE)));
22934 }
22935 {
22936 PyDict_SetItemString(d,"LANGUAGE_VOLAPUK", SWIG_From_int((int)(wxLANGUAGE_VOLAPUK)));
22937 }
22938 {
22939 PyDict_SetItemString(d,"LANGUAGE_WELSH", SWIG_From_int((int)(wxLANGUAGE_WELSH)));
22940 }
22941 {
22942 PyDict_SetItemString(d,"LANGUAGE_WOLOF", SWIG_From_int((int)(wxLANGUAGE_WOLOF)));
22943 }
22944 {
22945 PyDict_SetItemString(d,"LANGUAGE_XHOSA", SWIG_From_int((int)(wxLANGUAGE_XHOSA)));
22946 }
22947 {
22948 PyDict_SetItemString(d,"LANGUAGE_YIDDISH", SWIG_From_int((int)(wxLANGUAGE_YIDDISH)));
22949 }
22950 {
22951 PyDict_SetItemString(d,"LANGUAGE_YORUBA", SWIG_From_int((int)(wxLANGUAGE_YORUBA)));
22952 }
22953 {
22954 PyDict_SetItemString(d,"LANGUAGE_ZHUANG", SWIG_From_int((int)(wxLANGUAGE_ZHUANG)));
22955 }
22956 {
22957 PyDict_SetItemString(d,"LANGUAGE_ZULU", SWIG_From_int((int)(wxLANGUAGE_ZULU)));
22958 }
22959 {
22960 PyDict_SetItemString(d,"LANGUAGE_USER_DEFINED", SWIG_From_int((int)(wxLANGUAGE_USER_DEFINED)));
22961 }
22962 {
22963 PyDict_SetItemString(d,"LOCALE_CAT_NUMBER", SWIG_From_int((int)(wxLOCALE_CAT_NUMBER)));
22964 }
22965 {
22966 PyDict_SetItemString(d,"LOCALE_CAT_DATE", SWIG_From_int((int)(wxLOCALE_CAT_DATE)));
22967 }
22968 {
22969 PyDict_SetItemString(d,"LOCALE_CAT_MONEY", SWIG_From_int((int)(wxLOCALE_CAT_MONEY)));
22970 }
22971 {
22972 PyDict_SetItemString(d,"LOCALE_CAT_MAX", SWIG_From_int((int)(wxLOCALE_CAT_MAX)));
22973 }
22974 {
22975 PyDict_SetItemString(d,"LOCALE_THOUSANDS_SEP", SWIG_From_int((int)(wxLOCALE_THOUSANDS_SEP)));
22976 }
22977 {
22978 PyDict_SetItemString(d,"LOCALE_DECIMAL_POINT", SWIG_From_int((int)(wxLOCALE_DECIMAL_POINT)));
22979 }
22980 {
22981 PyDict_SetItemString(d,"LOCALE_LOAD_DEFAULT", SWIG_From_int((int)(wxLOCALE_LOAD_DEFAULT)));
22982 }
22983 {
22984 PyDict_SetItemString(d,"LOCALE_CONV_ENCODING", SWIG_From_int((int)(wxLOCALE_CONV_ENCODING)));
22985 }
22986 {
22987 PyDict_SetItemString(d,"CONVERT_STRICT", SWIG_From_int((int)(wxCONVERT_STRICT)));
22988 }
22989 {
22990 PyDict_SetItemString(d,"CONVERT_SUBSTITUTE", SWIG_From_int((int)(wxCONVERT_SUBSTITUTE)));
22991 }
22992 {
22993 PyDict_SetItemString(d,"PLATFORM_CURRENT", SWIG_From_int((int)(wxPLATFORM_CURRENT)));
22994 }
22995 {
22996 PyDict_SetItemString(d,"PLATFORM_UNIX", SWIG_From_int((int)(wxPLATFORM_UNIX)));
22997 }
22998 {
22999 PyDict_SetItemString(d,"PLATFORM_WINDOWS", SWIG_From_int((int)(wxPLATFORM_WINDOWS)));
23000 }
23001 {
23002 PyDict_SetItemString(d,"PLATFORM_OS2", SWIG_From_int((int)(wxPLATFORM_OS2)));
23003 }
23004 {
23005 PyDict_SetItemString(d,"PLATFORM_MAC", SWIG_From_int((int)(wxPLATFORM_MAC)));
23006 }
23007 {
23008 PyDict_SetItemString(d,"BUFFER_VIRTUAL_AREA", SWIG_From_int((int)(wxBUFFER_VIRTUAL_AREA)));
23009 }
23010 {
23011 PyDict_SetItemString(d,"BUFFER_CLIENT_AREA", SWIG_From_int((int)(wxBUFFER_CLIENT_AREA)));
23012 }
23013 {
23014 PyDict_SetItemString(d,"IMAGELIST_DRAW_NORMAL", SWIG_From_int((int)(wxIMAGELIST_DRAW_NORMAL)));
23015 }
23016 {
23017 PyDict_SetItemString(d,"IMAGELIST_DRAW_TRANSPARENT", SWIG_From_int((int)(wxIMAGELIST_DRAW_TRANSPARENT)));
23018 }
23019 {
23020 PyDict_SetItemString(d,"IMAGELIST_DRAW_SELECTED", SWIG_From_int((int)(wxIMAGELIST_DRAW_SELECTED)));
23021 }
23022 {
23023 PyDict_SetItemString(d,"IMAGELIST_DRAW_FOCUSED", SWIG_From_int((int)(wxIMAGELIST_DRAW_FOCUSED)));
23024 }
23025 {
23026 PyDict_SetItemString(d,"IMAGE_LIST_NORMAL", SWIG_From_int((int)(wxIMAGE_LIST_NORMAL)));
23027 }
23028 {
23029 PyDict_SetItemString(d,"IMAGE_LIST_SMALL", SWIG_From_int((int)(wxIMAGE_LIST_SMALL)));
23030 }
23031 {
23032 PyDict_SetItemString(d,"IMAGE_LIST_STATE", SWIG_From_int((int)(wxIMAGE_LIST_STATE)));
23033 }
23034 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
23035 SWIG_addvarlink(SWIG_globals,(char*)"NORMAL_FONT",_wrap_NORMAL_FONT_get, _wrap_NORMAL_FONT_set);
23036 SWIG_addvarlink(SWIG_globals,(char*)"SMALL_FONT",_wrap_SMALL_FONT_get, _wrap_SMALL_FONT_set);
23037 SWIG_addvarlink(SWIG_globals,(char*)"ITALIC_FONT",_wrap_ITALIC_FONT_get, _wrap_ITALIC_FONT_set);
23038 SWIG_addvarlink(SWIG_globals,(char*)"SWISS_FONT",_wrap_SWISS_FONT_get, _wrap_SWISS_FONT_set);
23039 SWIG_addvarlink(SWIG_globals,(char*)"RED_PEN",_wrap_RED_PEN_get, _wrap_RED_PEN_set);
23040 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_PEN",_wrap_CYAN_PEN_get, _wrap_CYAN_PEN_set);
23041 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_PEN",_wrap_GREEN_PEN_get, _wrap_GREEN_PEN_set);
23042 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_PEN",_wrap_BLACK_PEN_get, _wrap_BLACK_PEN_set);
23043 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_PEN",_wrap_WHITE_PEN_get, _wrap_WHITE_PEN_set);
23044 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_PEN",_wrap_TRANSPARENT_PEN_get, _wrap_TRANSPARENT_PEN_set);
23045 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_DASHED_PEN",_wrap_BLACK_DASHED_PEN_get, _wrap_BLACK_DASHED_PEN_set);
23046 SWIG_addvarlink(SWIG_globals,(char*)"GREY_PEN",_wrap_GREY_PEN_get, _wrap_GREY_PEN_set);
23047 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_PEN",_wrap_MEDIUM_GREY_PEN_get, _wrap_MEDIUM_GREY_PEN_set);
23048 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_PEN",_wrap_LIGHT_GREY_PEN_get, _wrap_LIGHT_GREY_PEN_set);
23049 SWIG_addvarlink(SWIG_globals,(char*)"BLUE_BRUSH",_wrap_BLUE_BRUSH_get, _wrap_BLUE_BRUSH_set);
23050 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_BRUSH",_wrap_GREEN_BRUSH_get, _wrap_GREEN_BRUSH_set);
23051 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_BRUSH",_wrap_WHITE_BRUSH_get, _wrap_WHITE_BRUSH_set);
23052 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_BRUSH",_wrap_BLACK_BRUSH_get, _wrap_BLACK_BRUSH_set);
23053 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_BRUSH",_wrap_TRANSPARENT_BRUSH_get, _wrap_TRANSPARENT_BRUSH_set);
23054 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_BRUSH",_wrap_CYAN_BRUSH_get, _wrap_CYAN_BRUSH_set);
23055 SWIG_addvarlink(SWIG_globals,(char*)"RED_BRUSH",_wrap_RED_BRUSH_get, _wrap_RED_BRUSH_set);
23056 SWIG_addvarlink(SWIG_globals,(char*)"GREY_BRUSH",_wrap_GREY_BRUSH_get, _wrap_GREY_BRUSH_set);
23057 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_BRUSH",_wrap_MEDIUM_GREY_BRUSH_get, _wrap_MEDIUM_GREY_BRUSH_set);
23058 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_BRUSH",_wrap_LIGHT_GREY_BRUSH_get, _wrap_LIGHT_GREY_BRUSH_set);
23059 SWIG_addvarlink(SWIG_globals,(char*)"BLACK",_wrap_BLACK_get, _wrap_BLACK_set);
23060 SWIG_addvarlink(SWIG_globals,(char*)"WHITE",_wrap_WHITE_get, _wrap_WHITE_set);
23061 SWIG_addvarlink(SWIG_globals,(char*)"RED",_wrap_RED_get, _wrap_RED_set);
23062 SWIG_addvarlink(SWIG_globals,(char*)"BLUE",_wrap_BLUE_get, _wrap_BLUE_set);
23063 SWIG_addvarlink(SWIG_globals,(char*)"GREEN",_wrap_GREEN_get, _wrap_GREEN_set);
23064 SWIG_addvarlink(SWIG_globals,(char*)"CYAN",_wrap_CYAN_get, _wrap_CYAN_set);
23065 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY",_wrap_LIGHT_GREY_get, _wrap_LIGHT_GREY_set);
23066 SWIG_addvarlink(SWIG_globals,(char*)"STANDARD_CURSOR",_wrap_STANDARD_CURSOR_get, _wrap_STANDARD_CURSOR_set);
23067 SWIG_addvarlink(SWIG_globals,(char*)"HOURGLASS_CURSOR",_wrap_HOURGLASS_CURSOR_get, _wrap_HOURGLASS_CURSOR_set);
23068 SWIG_addvarlink(SWIG_globals,(char*)"CROSS_CURSOR",_wrap_CROSS_CURSOR_get, _wrap_CROSS_CURSOR_set);
23069 SWIG_addvarlink(SWIG_globals,(char*)"NullBitmap",_wrap_NullBitmap_get, _wrap_NullBitmap_set);
23070 SWIG_addvarlink(SWIG_globals,(char*)"NullIcon",_wrap_NullIcon_get, _wrap_NullIcon_set);
23071 SWIG_addvarlink(SWIG_globals,(char*)"NullCursor",_wrap_NullCursor_get, _wrap_NullCursor_set);
23072 SWIG_addvarlink(SWIG_globals,(char*)"NullPen",_wrap_NullPen_get, _wrap_NullPen_set);
23073 SWIG_addvarlink(SWIG_globals,(char*)"NullBrush",_wrap_NullBrush_get, _wrap_NullBrush_set);
23074 SWIG_addvarlink(SWIG_globals,(char*)"NullPalette",_wrap_NullPalette_get, _wrap_NullPalette_set);
23075 SWIG_addvarlink(SWIG_globals,(char*)"NullFont",_wrap_NullFont_get, _wrap_NullFont_set);
23076 SWIG_addvarlink(SWIG_globals,(char*)"NullColour",_wrap_NullColour_get, _wrap_NullColour_set);
23077 SWIG_addvarlink(SWIG_globals,(char*)"TheFontList",_wrap_TheFontList_get, _wrap_TheFontList_set);
23078 SWIG_addvarlink(SWIG_globals,(char*)"ThePenList",_wrap_ThePenList_get, _wrap_ThePenList_set);
23079 SWIG_addvarlink(SWIG_globals,(char*)"TheBrushList",_wrap_TheBrushList_get, _wrap_TheBrushList_set);
23080 SWIG_addvarlink(SWIG_globals,(char*)"TheColourDatabase",_wrap_TheColourDatabase_get, _wrap_TheColourDatabase_set);
23081
23082 // Work around a chicken/egg problem in drawlist.cpp
23083 wxPyDrawList_SetAPIPtr();
23084
23085 }
23086
wxWidgets (Impactor)