]> 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
Make IsSelected be a bit more specific
[wxWidgets.git] / wxPython / src / gtk / _gdi_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxPostScriptDC swig_types[0]
1342 #define SWIGTYPE_p_wxBrush swig_types[1]
1343 #define SWIGTYPE_p_wxColour swig_types[2]
1344 #define SWIGTYPE_p_wxDC swig_types[3]
1345 #define SWIGTYPE_p_wxMirrorDC swig_types[4]
1346 #define SWIGTYPE_p_form_ops_t swig_types[5]
1347 #define SWIGTYPE_p_wxDuplexMode swig_types[6]
1348 #define SWIGTYPE_p_wxPyFontEnumerator swig_types[7]
1349 #define SWIGTYPE_p_char swig_types[8]
1350 #define SWIGTYPE_p_wxIconLocation swig_types[9]
1351 #define SWIGTYPE_p_wxImage swig_types[10]
1352 #define SWIGTYPE_p_wxMetaFileDC swig_types[11]
1353 #define SWIGTYPE_p_wxMask swig_types[12]
1354 #define SWIGTYPE_p_wxSize swig_types[13]
1355 #define SWIGTYPE_p_wxFont swig_types[14]
1356 #define SWIGTYPE_p_wxWindow swig_types[15]
1357 #define SWIGTYPE_p_double swig_types[16]
1358 #define SWIGTYPE_p_wxMemoryDC swig_types[17]
1359 #define SWIGTYPE_p_wxFontMapper swig_types[18]
1360 #define SWIGTYPE_p_wxEffects swig_types[19]
1361 #define SWIGTYPE_p_wxNativeEncodingInfo swig_types[20]
1362 #define SWIGTYPE_p_wxPalette swig_types[21]
1363 #define SWIGTYPE_p_wxBitmap swig_types[22]
1364 #define SWIGTYPE_p_wxObject swig_types[23]
1365 #define SWIGTYPE_p_wxRegionIterator swig_types[24]
1366 #define SWIGTYPE_p_wxRect swig_types[25]
1367 #define SWIGTYPE_p_wxPaperSize swig_types[26]
1368 #define SWIGTYPE_p_wxString swig_types[27]
1369 #define SWIGTYPE_unsigned_int swig_types[28]
1370 #define SWIGTYPE_p_unsigned_int swig_types[29]
1371 #define SWIGTYPE_p_wxPrinterDC swig_types[30]
1372 #define SWIGTYPE_p_wxIconBundle swig_types[31]
1373 #define SWIGTYPE_p_wxPoint swig_types[32]
1374 #define SWIGTYPE_p_wxDash swig_types[33]
1375 #define SWIGTYPE_p_wxScreenDC swig_types[34]
1376 #define SWIGTYPE_p_wxCursor swig_types[35]
1377 #define SWIGTYPE_p_wxClientDC swig_types[36]
1378 #define SWIGTYPE_p_wxBufferedDC swig_types[37]
1379 #define SWIGTYPE_p_wxImageList swig_types[38]
1380 #define SWIGTYPE_p_unsigned_char swig_types[39]
1381 #define SWIGTYPE_p_wxGDIObject swig_types[40]
1382 #define SWIGTYPE_p_wxIcon swig_types[41]
1383 #define SWIGTYPE_p_wxLocale swig_types[42]
1384 #define SWIGTYPE_ptrdiff_t swig_types[43]
1385 #define SWIGTYPE_std__ptrdiff_t swig_types[44]
1386 #define SWIGTYPE_p_wxRegion swig_types[45]
1387 #define SWIGTYPE_p_wxConfigBase swig_types[46]
1388 #define SWIGTYPE_p_wxLanguageInfo swig_types[47]
1389 #define SWIGTYPE_p_wxWindowDC swig_types[48]
1390 #define SWIGTYPE_p_wxPrintData swig_types[49]
1391 #define SWIGTYPE_p_wxBrushList swig_types[50]
1392 #define SWIGTYPE_p_wxFontList swig_types[51]
1393 #define SWIGTYPE_p_wxPen swig_types[52]
1394 #define SWIGTYPE_p_wxBufferedPaintDC swig_types[53]
1395 #define SWIGTYPE_p_wxPaintDC swig_types[54]
1396 #define SWIGTYPE_p_wxPenList swig_types[55]
1397 #define SWIGTYPE_p_int swig_types[56]
1398 #define SWIGTYPE_p_wxMetaFile swig_types[57]
1399 #define SWIGTYPE_p_unsigned_long swig_types[58]
1400 #define SWIGTYPE_p_wxNativeFontInfo swig_types[59]
1401 #define SWIGTYPE_p_wxEncodingConverter swig_types[60]
1402 #define SWIGTYPE_p_wxColourDatabase swig_types[61]
1403 static swig_type_info *swig_types[63];
1404
1405 /* -------- TYPES TABLE (END) -------- */
1406
1407
1408 /*-----------------------------------------------
1409 @(target):= _gdi_.so
1410 ------------------------------------------------*/
1411 #define SWIG_init init_gdi_
1412
1413 #define SWIG_name "_gdi_"
1414
1415 #include "wx/wxPython/wxPython.h"
1416 #include "wx/wxPython/pyclasses.h"
1417
1418
1419 static const wxString wxPyEmptyString(wxEmptyString);
1420
1421 #include <limits.h>
1422
1423
1424 SWIGINTERN int
1425 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1426 const char *errmsg)
1427 {
1428 if (value < min_value) {
1429 if (errmsg) {
1430 PyErr_Format(PyExc_OverflowError,
1431 "value %ld is less than '%s' minimum %ld",
1432 value, errmsg, min_value);
1433 }
1434 return 0;
1435 } else if (value > max_value) {
1436 if (errmsg) {
1437 PyErr_Format(PyExc_OverflowError,
1438 "value %ld is greater than '%s' maximum %ld",
1439 value, errmsg, max_value);
1440 }
1441 return 0;
1442 }
1443 return 1;
1444 }
1445
1446
1447 SWIGINTERN int
1448 SWIG_AsVal_long(PyObject* obj, long* val)
1449 {
1450 if (PyNumber_Check(obj)) {
1451 if (val) *val = PyInt_AsLong(obj);
1452 return 1;
1453 }
1454 else {
1455 SWIG_type_error("number", obj);
1456 }
1457 return 0;
1458 }
1459
1460
1461 #if INT_MAX != LONG_MAX
1462 SWIGINTERN int
1463 SWIG_AsVal_int(PyObject *obj, int *val)
1464 {
1465 const char* errmsg = val ? "int" : (char*)0;
1466 long v;
1467 if (SWIG_AsVal_long(obj, &v)) {
1468 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1469 if (val) *val = (int)(v);
1470 return 1;
1471 } else {
1472 return 0;
1473 }
1474 } else {
1475 PyErr_Clear();
1476 }
1477 if (val) {
1478 SWIG_type_error(errmsg, obj);
1479 }
1480 return 0;
1481 }
1482 #else
1483 SWIGINTERNSHORT int
1484 SWIG_AsVal_int(PyObject *obj, int *val)
1485 {
1486 return SWIG_AsVal_long(obj,(long*)val);
1487 }
1488 #endif
1489
1490
1491 SWIGINTERN int
1492 SWIG_AsVal_bool(PyObject *obj, bool *val)
1493 {
1494 if (obj == Py_True) {
1495 if (val) *val = true;
1496 return 1;
1497 }
1498 if (obj == Py_False) {
1499 if (val) *val = false;
1500 return 1;
1501 }
1502 int res = 0;
1503 if (SWIG_AsVal_int(obj, &res)) {
1504 if (val) *val = res ? true : false;
1505 return 1;
1506 } else {
1507 PyErr_Clear();
1508 }
1509 if (val) {
1510 SWIG_type_error("bool", obj);
1511 }
1512 return 0;
1513 }
1514
1515
1516 SWIGINTERNSHORT bool
1517 SWIG_As_bool(PyObject* obj)
1518 {
1519 bool v;
1520 if (!SWIG_AsVal_bool(obj, &v)) {
1521 /*
1522 this is needed to make valgrind/purify happier.
1523 */
1524 memset((void*)&v, 0, sizeof(bool));
1525 }
1526 return v;
1527 }
1528
1529
1530 SWIGINTERNSHORT int
1531 SWIG_Check_bool(PyObject* obj)
1532 {
1533 return SWIG_AsVal_bool(obj, (bool*)0);
1534 }
1535
1536
1537 SWIGINTERN int
1538 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1539 {
1540 long v = 0;
1541 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1542 SWIG_type_error("unsigned number", obj);
1543 }
1544 else if (val)
1545 *val = (unsigned long)v;
1546 return 1;
1547 }
1548
1549
1550 SWIGINTERNSHORT int
1551 SWIG_CheckUnsignedLongInRange(unsigned long value,
1552 unsigned long max_value,
1553 const char *errmsg)
1554 {
1555 if (value > max_value) {
1556 if (errmsg) {
1557 PyErr_Format(PyExc_OverflowError,
1558 "value %lu is greater than '%s' minimum %lu",
1559 value, errmsg, max_value);
1560 }
1561 return 0;
1562 }
1563 return 1;
1564 }
1565
1566
1567 SWIGINTERN int
1568 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
1569 {
1570 const char* errmsg = val ? "unsigned char" : (char*)0;
1571 unsigned long v;
1572 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1573 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
1574 if (val) *val = (unsigned char)(v);
1575 return 1;
1576 } else {
1577 return 0;
1578 }
1579 } else {
1580 PyErr_Clear();
1581 }
1582 if (val) {
1583 SWIG_type_error(errmsg, obj);
1584 }
1585 return 0;
1586 }
1587
1588
1589 SWIGINTERNSHORT unsigned char
1590 SWIG_As_unsigned_SS_char(PyObject* obj)
1591 {
1592 unsigned char v;
1593 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
1594 /*
1595 this is needed to make valgrind/purify happier.
1596 */
1597 memset((void*)&v, 0, sizeof(unsigned char));
1598 }
1599 return v;
1600 }
1601
1602
1603 SWIGINTERNSHORT int
1604 SWIG_Check_unsigned_SS_char(PyObject* obj)
1605 {
1606 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
1607 }
1608
1609
1610 SWIGINTERNSHORT unsigned long
1611 SWIG_As_unsigned_SS_long(PyObject* obj)
1612 {
1613 unsigned long v;
1614 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1615 /*
1616 this is needed to make valgrind/purify happier.
1617 */
1618 memset((void*)&v, 0, sizeof(unsigned long));
1619 }
1620 return v;
1621 }
1622
1623
1624 SWIGINTERNSHORT int
1625 SWIG_Check_unsigned_SS_long(PyObject* obj)
1626 {
1627 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1628 }
1629
1630
1631 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1632 #define SWIG_From_unsigned_SS_char PyInt_FromLong
1633 /*@@*/
1634
1635
1636 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1637 #define SWIG_From_long PyInt_FromLong
1638 /*@@*/
1639
1640 static PyObject *wxColour_Get(wxColour *self){
1641 PyObject* rv = PyTuple_New(3);
1642 int red = -1;
1643 int green = -1;
1644 int blue = -1;
1645 if (self->Ok()) {
1646 red = self->Red();
1647 green = self->Green();
1648 blue = self->Blue();
1649 }
1650 PyTuple_SetItem(rv, 0, PyInt_FromLong(red));
1651 PyTuple_SetItem(rv, 1, PyInt_FromLong(green));
1652 PyTuple_SetItem(rv, 2, PyInt_FromLong(blue));
1653 return rv;
1654 }
1655 static unsigned long wxColour_GetRGB(wxColour *self){
1656 return self->Red() | (self->Green() << 8) | (self->Blue() << 16);
1657 }
1658
1659 SWIGINTERNSHORT PyObject*
1660 SWIG_From_unsigned_SS_long(unsigned long value)
1661 {
1662 return (value > LONG_MAX) ?
1663 PyLong_FromUnsignedLong(value)
1664 : PyInt_FromLong((long)(value));
1665 }
1666
1667
1668 SWIGINTERNSHORT int
1669 SWIG_As_int(PyObject* obj)
1670 {
1671 int v;
1672 if (!SWIG_AsVal_int(obj, &v)) {
1673 /*
1674 this is needed to make valgrind/purify happier.
1675 */
1676 memset((void*)&v, 0, sizeof(int));
1677 }
1678 return v;
1679 }
1680
1681
1682 SWIGINTERNSHORT int
1683 SWIG_Check_int(PyObject* obj)
1684 {
1685 return SWIG_AsVal_int(obj, (int*)0);
1686 }
1687
1688
1689 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1690 #define SWIG_From_int PyInt_FromLong
1691 /*@@*/
1692
1693
1694 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1695 PyObject* o2;
1696 PyObject* o3;
1697
1698 if (!target) {
1699 target = o;
1700 } else if (target == Py_None) {
1701 Py_DECREF(Py_None);
1702 target = o;
1703 } else {
1704 if (!PyTuple_Check(target)) {
1705 o2 = target;
1706 target = PyTuple_New(1);
1707 PyTuple_SetItem(target, 0, o2);
1708 }
1709 o3 = PyTuple_New(1);
1710 PyTuple_SetItem(o3, 0, o);
1711
1712 o2 = target;
1713 target = PySequence_Concat(o2, o3);
1714 Py_DECREF(o2);
1715 Py_DECREF(o3);
1716 }
1717 return target;
1718 }
1719
1720
1721 static PyObject *wxPen_GetDashes(wxPen *self){
1722 wxDash* dashes;
1723 int count = self->GetDashes(&dashes);
1724 bool blocked = wxPyBeginBlockThreads();
1725 PyObject* retval = PyList_New(0);
1726 for (int x=0; x<count; x++) {
1727 PyObject* pyint = PyInt_FromLong(dashes[x]);
1728 PyList_Append(retval, pyint);
1729 Py_DECREF(pyint);
1730 }
1731 wxPyEndBlockThreads(blocked);
1732 return retval;
1733 }
1734 static void wxPen__SetDashes(wxPen *self,PyObject *_self,PyObject *pyDashes){
1735 bool blocked = wxPyBeginBlockThreads();
1736 int size = PyList_Size(pyDashes);
1737 wxDash* dashes = (wxDash*)byte_LIST_helper(pyDashes);
1738
1739 // black magic warning! The array of wxDashes needs to exist as
1740 // long as the pen does because wxPen does not copy the array. So
1741 // stick a copy in a Python string object and attach it to _self,
1742 // and then call SetDashes with a pointer to that array. Then
1743 // when the Python pen object is destroyed the array will be
1744 // cleaned up too.
1745 PyObject* strDashes = PyString_FromStringAndSize((char*)dashes, size*sizeof(wxDash));
1746 PyObject_SetAttrString(_self, "_dashes", strDashes);
1747
1748 self->SetDashes(size, (wxDash*)PyString_AS_STRING(strDashes));
1749 delete [] dashes;
1750 Py_DECREF(strDashes);
1751 wxPyEndBlockThreads(blocked);
1752 }
1753 static bool wxPen___eq__(wxPen *self,wxPen const *other){ return other ? (*self == *other) : false; }
1754 static bool wxPen___ne__(wxPen *self,wxPen const *other){ return other ? (*self != *other) : true; }
1755
1756 #include <wx/image.h>
1757
1758 static char** ConvertListOfStrings(PyObject* listOfStrings) {
1759 char** cArray = NULL;
1760 int count;
1761
1762 if (!PyList_Check(listOfStrings)) {
1763 PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
1764 return NULL;
1765 }
1766 count = PyList_Size(listOfStrings);
1767 cArray = new char*[count];
1768
1769 for(int x=0; x<count; x++) {
1770 // TODO: Need some validation and error checking here
1771 cArray[x] = PyString_AsString(PyList_GET_ITEM(listOfStrings, x));
1772 }
1773 return cArray;
1774 }
1775
1776
1777 static wxBitmap *new_wxBitmap(PyObject *listOfStrings){
1778 char** cArray = NULL;
1779 wxBitmap* bmp;
1780
1781 cArray = ConvertListOfStrings(listOfStrings);
1782 if (! cArray)
1783 return NULL;
1784 bmp = new wxBitmap(cArray);
1785 delete [] cArray;
1786 return bmp;
1787 }
1788 static wxBitmap *new_wxBitmap(PyObject *bits,int width,int height,int depth=1){
1789 char* buf;
1790 int length;
1791 PyString_AsStringAndSize(bits, &buf, &length);
1792 return new wxBitmap(buf, width, height, depth);
1793 }
1794 static wxSize wxBitmap_GetSize(wxBitmap *self){
1795 wxSize size(self->GetWidth(), self->GetHeight());
1796 return size;
1797 }
1798 static void wxBitmap_SetMaskColour(wxBitmap *self,wxColour const &colour){
1799 wxMask *mask = new wxMask(*self, colour);
1800 self->SetMask(mask);
1801 }
1802 static void wxBitmap_SetSize(wxBitmap *self,wxSize const &size){
1803 self->SetWidth(size.x);
1804 self->SetHeight(size.y);
1805 }
1806 static bool wxBitmap___eq__(wxBitmap *self,wxBitmap const *other){ return other ? (*self == *other) : false; }
1807 static bool wxBitmap___ne__(wxBitmap *self,wxBitmap const *other){ return other ? (*self != *other) : true; }
1808 static wxMask *new_wxMask(wxBitmap const &bitmap,wxColour const &colour=wxNullColour){
1809 if ( !colour.Ok() )
1810 return new wxMask(bitmap, *wxBLACK);
1811 else
1812 return new wxMask(bitmap, colour);
1813 }
1814
1815 #include <wx/iconbndl.h>
1816
1817 static wxIcon *new_wxIcon(wxBitmap const &bmp){
1818 wxIcon* icon = new wxIcon();
1819 icon->CopyFromBitmap(bmp);
1820 return icon;
1821 }
1822 static wxIcon *new_wxIcon(PyObject *listOfStrings){
1823 char** cArray = NULL;
1824 wxIcon* icon;
1825
1826 cArray = ConvertListOfStrings(listOfStrings);
1827 if (! cArray)
1828 return NULL;
1829 icon = new wxIcon(cArray);
1830 delete [] cArray;
1831 return icon;
1832 }
1833 static wxIconLocation *new_wxIconLocation(wxString const *filename=&wxPyEmptyString,int num=0){
1834
1835
1836
1837 return new wxIconLocation(*filename);
1838
1839 }
1840 static void wxIconLocation_SetIndex(wxIconLocation *self,int num){
1841
1842
1843
1844 // do nothing
1845
1846 }
1847 static int wxIconLocation_GetIndex(wxIconLocation *self){
1848
1849
1850
1851 return -1;
1852
1853 }
1854
1855 SWIGINTERNSHORT long
1856 SWIG_As_long(PyObject* obj)
1857 {
1858 long v;
1859 if (!SWIG_AsVal_long(obj, &v)) {
1860 /*
1861 this is needed to make valgrind/purify happier.
1862 */
1863 memset((void*)&v, 0, sizeof(long));
1864 }
1865 return v;
1866 }
1867
1868
1869 SWIGINTERNSHORT int
1870 SWIG_Check_long(PyObject* obj)
1871 {
1872 return SWIG_AsVal_long(obj, (long*)0);
1873 }
1874
1875 static wxCursor *new_wxCursor(wxString const &cursorName,long type,int hotSpotX=0,int hotSpotY=0){
1876 #ifdef __WXGTK__
1877 wxImage img(cursorName, type);
1878 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X, hotSpotX);
1879 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y, hotSpotY);
1880 return new wxCursor(img);
1881 #else
1882 return new wxCursor(cursorName, type, hotSpotX, hotSpotY);
1883 #endif
1884 }
1885
1886
1887 static void wxRegionIterator_Next(wxRegionIterator *self){
1888 (*self) ++;
1889 }
1890 static bool wxRegionIterator___nonzero__(wxRegionIterator *self){
1891 return self->operator bool();
1892 }
1893
1894 #include <wx/fontutil.h>
1895 #include <wx/fontmap.h>
1896 #include <wx/fontenum.h>
1897
1898 static wxString wxNativeFontInfo___str__(wxNativeFontInfo *self){
1899 return self->ToString();
1900 }
1901
1902 wxNativeEncodingInfo* wxGetNativeFontEncoding(wxFontEncoding encoding) {
1903 static wxNativeEncodingInfo info;
1904 if ( wxGetNativeFontEncoding(encoding, &info) )
1905 return &info;
1906 else
1907 return NULL;
1908 }
1909
1910 static PyObject *wxFontMapper_GetAltForEncoding(wxFontMapper *self,wxFontEncoding encoding,wxString const &facename=wxPyEmptyString,bool interactive=true){
1911 wxFontEncoding alt_enc;
1912 if (self->GetAltForEncoding(encoding, &alt_enc, facename, interactive))
1913 return PyInt_FromLong(alt_enc);
1914 else {
1915 Py_INCREF(Py_None);
1916 return Py_None;
1917 }
1918 }
1919 static wxFont *new_wxFont(wxString const &info){
1920 wxNativeFontInfo nfi;
1921 nfi.FromString(info);
1922 return new wxFont(nfi);
1923 }
1924 static wxFont *new_wxFont(int pointSize,wxFontFamily family,int flags=wxFONTFLAG_DEFAULT,wxString const &face=wxPyEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1925 return wxFont::New(pointSize, family, flags, face, encoding);
1926 }
1927 static wxFont *new_wxFont(wxSize const &pixelSize,int family,int style,int weight,bool underlined=false,wxString const &face=wxEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1928 return wxFontBase::New(pixelSize, family,
1929 style, weight, underlined,
1930 face, encoding);
1931 }
1932 static bool wxFont___eq__(wxFont *self,wxFont const *other){ return other ? (*self == *other) : false; }
1933 static bool wxFont___ne__(wxFont *self,wxFont const *other){ return other ? (*self != *other) : true; }
1934
1935 class wxPyFontEnumerator : public wxFontEnumerator {
1936 public:
1937 wxPyFontEnumerator() {}
1938 ~wxPyFontEnumerator() {}
1939
1940 DEC_PYCALLBACK_BOOL_STRING(OnFacename);
1941 DEC_PYCALLBACK_BOOL_STRINGSTRING(OnFontEncoding);
1942
1943 PYPRIVATE;
1944 };
1945
1946 IMP_PYCALLBACK_BOOL_STRING(wxPyFontEnumerator, wxFontEnumerator, OnFacename);
1947 IMP_PYCALLBACK_BOOL_STRINGSTRING(wxPyFontEnumerator, wxFontEnumerator, OnFontEncoding);
1948
1949
1950 static PyObject *wxPyFontEnumerator_GetEncodings(wxPyFontEnumerator *self){
1951 wxArrayString* arr = self->GetEncodings();
1952 if (arr)
1953 return wxArrayString2PyList_helper(*arr);
1954 else
1955 return PyList_New(0);
1956 }
1957 static PyObject *wxPyFontEnumerator_GetFacenames(wxPyFontEnumerator *self){
1958 wxArrayString* arr = self->GetFacenames();
1959 if (arr)
1960 return wxArrayString2PyList_helper(*arr);
1961 else
1962 return PyList_New(0);
1963 }
1964
1965 #include <locale.h>
1966
1967 static wxLocale *new_wxLocale(int language=-1,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
1968 wxLocale* loc;
1969 if (language == -1)
1970 loc = new wxLocale();
1971 else
1972 loc = new wxLocale(language, flags);
1973 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1974 // for the floating point conversions and such to work right.
1975 #if PY_VERSION_HEX < 0x02040000
1976 setlocale(LC_NUMERIC, "C");
1977 #endif
1978 return loc;
1979 }
1980 static bool wxLocale_Init1(wxLocale *self,wxString const &szName,wxString const &szShort=wxPyEmptyString,wxString const &szLocale=wxPyEmptyString,bool bLoadDefault=true,bool bConvertEncoding=false){
1981 bool rc = self->Init(szName, szShort, szLocale, bLoadDefault, bConvertEncoding);
1982 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1983 // for the floating point conversions and such to work right.
1984 #if PY_VERSION_HEX < 0x02040000
1985 setlocale(LC_NUMERIC, "C");
1986 #endif
1987 return rc;
1988 }
1989 static bool wxLocale_Init2(wxLocale *self,int language=wxLANGUAGE_DEFAULT,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
1990 bool rc = self->Init(language, flags);
1991 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1992 // for the floating point conversions and such to work right.
1993 #if PY_VERSION_HEX < 0x02040000
1994 setlocale(LC_NUMERIC, "C");
1995 #endif
1996 return rc;
1997 }
1998
1999 #include "wx/wxPython/pydrawxxx.h"
2000
2001 static wxColour wxDC_GetPixel(wxDC *self,int x,int y){
2002 wxColour col;
2003 self->GetPixel(x, y, &col);
2004 return col;
2005 }
2006 static wxColour wxDC_GetPixelPoint(wxDC *self,wxPoint const &pt){
2007 wxColour col;
2008 self->GetPixel(pt, &col);
2009 return col;
2010 }
2011
2012 SWIGINTERN int
2013 SWIG_AsVal_double(PyObject *obj, double* val)
2014 {
2015 if (PyNumber_Check(obj)) {
2016 if (val) *val = PyFloat_AsDouble(obj);
2017 return 1;
2018 }
2019 else {
2020 SWIG_type_error("number", obj);
2021 }
2022 return 0;
2023 }
2024
2025
2026 SWIGINTERNSHORT double
2027 SWIG_As_double(PyObject* obj)
2028 {
2029 double v;
2030 if (!SWIG_AsVal_double(obj, &v)) {
2031 /*
2032 this is needed to make valgrind/purify happier.
2033 */
2034 memset((void*)&v, 0, sizeof(double));
2035 }
2036 return v;
2037 }
2038
2039
2040 SWIGINTERNSHORT int
2041 SWIG_Check_double(PyObject* obj)
2042 {
2043 return SWIG_AsVal_double(obj, (double*)0);
2044 }
2045
2046 static wxRect wxDC_DrawImageLabel(wxDC *self,wxString const &text,wxBitmap const &image,wxRect const &rect,int alignment=wxALIGN_LEFT|wxALIGN_TOP,int indexAccel=-1){
2047 wxRect rv;
2048 self->DrawLabel(text, image, rect, alignment, indexAccel, &rv);
2049 return rv;
2050 }
2051
2052 static wxRect wxDC_GetClippingRect(wxDC *self){
2053 wxRect rect;
2054 self->GetClippingBox(rect);
2055 return rect;
2056 }
2057 static wxArrayInt wxDC_GetPartialTextExtents(wxDC *self,wxString const &text){
2058 wxArrayInt widths;
2059 self->GetPartialTextExtents(text, widths);
2060 return widths;
2061 }
2062
2063 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2064 #define SWIG_From_double PyFloat_FromDouble
2065 /*@@*/
2066
2067
2068 static void wxDC_SetLogicalOriginPoint(wxDC *self,wxPoint const &point){
2069 self->SetLogicalOrigin(point.x, point.y);
2070 }
2071 static void wxDC_SetDeviceOriginPoint(wxDC *self,wxPoint const &point){
2072 self->SetDeviceOrigin(point.x, point.y);
2073 }
2074 static void wxDC_CalcBoundingBoxPoint(wxDC *self,wxPoint const &point){
2075 self->CalcBoundingBox(point.x, point.y);
2076 }
2077 static PyObject *wxDC__DrawPointList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2078 return wxPyDrawXXXList(*self, wxPyDrawXXXPoint, pyCoords, pyPens, pyBrushes);
2079 }
2080 static PyObject *wxDC__DrawLineList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2081 return wxPyDrawXXXList(*self, wxPyDrawXXXLine, pyCoords, pyPens, pyBrushes);
2082 }
2083 static PyObject *wxDC__DrawRectangleList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2084 return wxPyDrawXXXList(*self, wxPyDrawXXXRectangle, pyCoords, pyPens, pyBrushes);
2085 }
2086 static PyObject *wxDC__DrawEllipseList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2087 return wxPyDrawXXXList(*self, wxPyDrawXXXEllipse, pyCoords, pyPens, pyBrushes);
2088 }
2089 static PyObject *wxDC__DrawPolygonList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2090 return wxPyDrawXXXList(*self, wxPyDrawXXXPolygon, pyCoords, pyPens, pyBrushes);
2091 }
2092 static PyObject *wxDC__DrawTextList(wxDC *self,PyObject *textList,PyObject *pyPoints,PyObject *foregroundList,PyObject *backgroundList){
2093 return wxPyDrawTextList(*self, textList, pyPoints, foregroundList, backgroundList);
2094 }
2095
2096 static void wxDC_GetBoundingBox(wxDC* dc, int* x1, int* y1, int* x2, int* y2) {
2097 *x1 = dc->MinX();
2098 *y1 = dc->MinY();
2099 *x2 = dc->MaxX();
2100 *y2 = dc->MaxY();
2101 }
2102
2103
2104 #include <wx/dcbuffer.h>
2105
2106
2107 #include <wx/dcps.h>
2108
2109
2110 class wxMetaFile : public wxObject {
2111 public:
2112 wxMetaFile(const wxString&)
2113 { wxPyRaiseNotImplemented(); }
2114 };
2115
2116 class wxMetaFileDC : public wxClientDC {
2117 public:
2118 wxMetaFileDC(const wxString&, int, int, const wxString&)
2119 { wxPyRaiseNotImplemented(); }
2120 };
2121
2122
2123
2124 class wxPrinterDC : public wxClientDC {
2125 public:
2126 wxPrinterDC(const wxPrintData&)
2127 { wxPyRaiseNotImplemented(); }
2128
2129 };
2130
2131
2132
2133 static void wxColourDatabase_Append(wxColourDatabase *self,wxString const &name,int red,int green,int blue){
2134 self->AddColour(name, wxColour(red, green, blue));
2135 }
2136
2137 #include <wx/effects.h>
2138
2139 #ifdef __cplusplus
2140 extern "C" {
2141 #endif
2142 static PyObject *_wrap_new_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2143 PyObject *resultobj;
2144 wxGDIObject *result;
2145 char *kwnames[] = {
2146 NULL
2147 };
2148
2149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GDIObject",kwnames)) goto fail;
2150 {
2151 if (!wxPyCheckForApp()) SWIG_fail;
2152 PyThreadState* __tstate = wxPyBeginAllowThreads();
2153 result = (wxGDIObject *)new wxGDIObject();
2154
2155 wxPyEndAllowThreads(__tstate);
2156 if (PyErr_Occurred()) SWIG_fail;
2157 }
2158 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGDIObject, 1);
2159 return resultobj;
2160 fail:
2161 return NULL;
2162 }
2163
2164
2165 static PyObject *_wrap_delete_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2166 PyObject *resultobj;
2167 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2168 PyObject * obj0 = 0 ;
2169 char *kwnames[] = {
2170 (char *) "self", NULL
2171 };
2172
2173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GDIObject",kwnames,&obj0)) goto fail;
2174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2175 if (SWIG_arg_fail(1)) SWIG_fail;
2176 {
2177 PyThreadState* __tstate = wxPyBeginAllowThreads();
2178 delete arg1;
2179
2180 wxPyEndAllowThreads(__tstate);
2181 if (PyErr_Occurred()) SWIG_fail;
2182 }
2183 Py_INCREF(Py_None); resultobj = Py_None;
2184 return resultobj;
2185 fail:
2186 return NULL;
2187 }
2188
2189
2190 static PyObject *_wrap_GDIObject_GetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2191 PyObject *resultobj;
2192 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2193 bool result;
2194 PyObject * obj0 = 0 ;
2195 char *kwnames[] = {
2196 (char *) "self", NULL
2197 };
2198
2199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_GetVisible",kwnames,&obj0)) goto fail;
2200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2201 if (SWIG_arg_fail(1)) SWIG_fail;
2202 {
2203 PyThreadState* __tstate = wxPyBeginAllowThreads();
2204 result = (bool)(arg1)->GetVisible();
2205
2206 wxPyEndAllowThreads(__tstate);
2207 if (PyErr_Occurred()) SWIG_fail;
2208 }
2209 {
2210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2211 }
2212 return resultobj;
2213 fail:
2214 return NULL;
2215 }
2216
2217
2218 static PyObject *_wrap_GDIObject_SetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2219 PyObject *resultobj;
2220 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2221 bool arg2 ;
2222 PyObject * obj0 = 0 ;
2223 PyObject * obj1 = 0 ;
2224 char *kwnames[] = {
2225 (char *) "self",(char *) "visible", NULL
2226 };
2227
2228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GDIObject_SetVisible",kwnames,&obj0,&obj1)) goto fail;
2229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2230 if (SWIG_arg_fail(1)) SWIG_fail;
2231 {
2232 arg2 = (bool)(SWIG_As_bool(obj1));
2233 if (SWIG_arg_fail(2)) SWIG_fail;
2234 }
2235 {
2236 PyThreadState* __tstate = wxPyBeginAllowThreads();
2237 (arg1)->SetVisible(arg2);
2238
2239 wxPyEndAllowThreads(__tstate);
2240 if (PyErr_Occurred()) SWIG_fail;
2241 }
2242 Py_INCREF(Py_None); resultobj = Py_None;
2243 return resultobj;
2244 fail:
2245 return NULL;
2246 }
2247
2248
2249 static PyObject *_wrap_GDIObject_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
2250 PyObject *resultobj;
2251 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2252 bool result;
2253 PyObject * obj0 = 0 ;
2254 char *kwnames[] = {
2255 (char *) "self", NULL
2256 };
2257
2258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_IsNull",kwnames,&obj0)) goto fail;
2259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2260 if (SWIG_arg_fail(1)) SWIG_fail;
2261 {
2262 PyThreadState* __tstate = wxPyBeginAllowThreads();
2263 result = (bool)(arg1)->IsNull();
2264
2265 wxPyEndAllowThreads(__tstate);
2266 if (PyErr_Occurred()) SWIG_fail;
2267 }
2268 {
2269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2270 }
2271 return resultobj;
2272 fail:
2273 return NULL;
2274 }
2275
2276
2277 static PyObject * GDIObject_swigregister(PyObject *, PyObject *args) {
2278 PyObject *obj;
2279 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2280 SWIG_TypeClientData(SWIGTYPE_p_wxGDIObject, obj);
2281 Py_INCREF(obj);
2282 return Py_BuildValue((char *)"");
2283 }
2284 static PyObject *_wrap_new_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2285 PyObject *resultobj;
2286 byte arg1 = (byte) 0 ;
2287 byte arg2 = (byte) 0 ;
2288 byte arg3 = (byte) 0 ;
2289 wxColour *result;
2290 PyObject * obj0 = 0 ;
2291 PyObject * obj1 = 0 ;
2292 PyObject * obj2 = 0 ;
2293 char *kwnames[] = {
2294 (char *) "red",(char *) "green",(char *) "blue", NULL
2295 };
2296
2297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Colour",kwnames,&obj0,&obj1,&obj2)) goto fail;
2298 if (obj0) {
2299 {
2300 arg1 = (byte)(SWIG_As_unsigned_SS_char(obj0));
2301 if (SWIG_arg_fail(1)) SWIG_fail;
2302 }
2303 }
2304 if (obj1) {
2305 {
2306 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2307 if (SWIG_arg_fail(2)) SWIG_fail;
2308 }
2309 }
2310 if (obj2) {
2311 {
2312 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2313 if (SWIG_arg_fail(3)) SWIG_fail;
2314 }
2315 }
2316 {
2317 PyThreadState* __tstate = wxPyBeginAllowThreads();
2318 result = (wxColour *)new wxColour(arg1,arg2,arg3);
2319
2320 wxPyEndAllowThreads(__tstate);
2321 if (PyErr_Occurred()) SWIG_fail;
2322 }
2323 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2324 return resultobj;
2325 fail:
2326 return NULL;
2327 }
2328
2329
2330 static PyObject *_wrap_new_NamedColour(PyObject *, PyObject *args, PyObject *kwargs) {
2331 PyObject *resultobj;
2332 wxString *arg1 = 0 ;
2333 wxColour *result;
2334 bool temp1 = false ;
2335 PyObject * obj0 = 0 ;
2336 char *kwnames[] = {
2337 (char *) "colorName", NULL
2338 };
2339
2340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_NamedColour",kwnames,&obj0)) goto fail;
2341 {
2342 arg1 = wxString_in_helper(obj0);
2343 if (arg1 == NULL) SWIG_fail;
2344 temp1 = true;
2345 }
2346 {
2347 if (!wxPyCheckForApp()) SWIG_fail;
2348 PyThreadState* __tstate = wxPyBeginAllowThreads();
2349 result = (wxColour *)new wxColour((wxString const &)*arg1);
2350
2351 wxPyEndAllowThreads(__tstate);
2352 if (PyErr_Occurred()) SWIG_fail;
2353 }
2354 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2355 {
2356 if (temp1)
2357 delete arg1;
2358 }
2359 return resultobj;
2360 fail:
2361 {
2362 if (temp1)
2363 delete arg1;
2364 }
2365 return NULL;
2366 }
2367
2368
2369 static PyObject *_wrap_new_ColourRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2370 PyObject *resultobj;
2371 unsigned long arg1 ;
2372 wxColour *result;
2373 PyObject * obj0 = 0 ;
2374 char *kwnames[] = {
2375 (char *) "colRGB", NULL
2376 };
2377
2378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ColourRGB",kwnames,&obj0)) goto fail;
2379 {
2380 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
2381 if (SWIG_arg_fail(1)) SWIG_fail;
2382 }
2383 {
2384 PyThreadState* __tstate = wxPyBeginAllowThreads();
2385 result = (wxColour *)new wxColour(arg1);
2386
2387 wxPyEndAllowThreads(__tstate);
2388 if (PyErr_Occurred()) SWIG_fail;
2389 }
2390 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2391 return resultobj;
2392 fail:
2393 return NULL;
2394 }
2395
2396
2397 static PyObject *_wrap_delete_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2398 PyObject *resultobj;
2399 wxColour *arg1 = (wxColour *) 0 ;
2400 PyObject * obj0 = 0 ;
2401 char *kwnames[] = {
2402 (char *) "self", NULL
2403 };
2404
2405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Colour",kwnames,&obj0)) goto fail;
2406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2407 if (SWIG_arg_fail(1)) SWIG_fail;
2408 {
2409 PyThreadState* __tstate = wxPyBeginAllowThreads();
2410 delete arg1;
2411
2412 wxPyEndAllowThreads(__tstate);
2413 if (PyErr_Occurred()) SWIG_fail;
2414 }
2415 Py_INCREF(Py_None); resultobj = Py_None;
2416 return resultobj;
2417 fail:
2418 return NULL;
2419 }
2420
2421
2422 static PyObject *_wrap_Colour_Red(PyObject *, PyObject *args, PyObject *kwargs) {
2423 PyObject *resultobj;
2424 wxColour *arg1 = (wxColour *) 0 ;
2425 byte result;
2426 PyObject * obj0 = 0 ;
2427 char *kwnames[] = {
2428 (char *) "self", NULL
2429 };
2430
2431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Red",kwnames,&obj0)) goto fail;
2432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2433 if (SWIG_arg_fail(1)) SWIG_fail;
2434 {
2435 PyThreadState* __tstate = wxPyBeginAllowThreads();
2436 result = (byte)(arg1)->Red();
2437
2438 wxPyEndAllowThreads(__tstate);
2439 if (PyErr_Occurred()) SWIG_fail;
2440 }
2441 {
2442 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2443 }
2444 return resultobj;
2445 fail:
2446 return NULL;
2447 }
2448
2449
2450 static PyObject *_wrap_Colour_Green(PyObject *, PyObject *args, PyObject *kwargs) {
2451 PyObject *resultobj;
2452 wxColour *arg1 = (wxColour *) 0 ;
2453 byte result;
2454 PyObject * obj0 = 0 ;
2455 char *kwnames[] = {
2456 (char *) "self", NULL
2457 };
2458
2459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Green",kwnames,&obj0)) goto fail;
2460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2461 if (SWIG_arg_fail(1)) SWIG_fail;
2462 {
2463 PyThreadState* __tstate = wxPyBeginAllowThreads();
2464 result = (byte)(arg1)->Green();
2465
2466 wxPyEndAllowThreads(__tstate);
2467 if (PyErr_Occurred()) SWIG_fail;
2468 }
2469 {
2470 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2471 }
2472 return resultobj;
2473 fail:
2474 return NULL;
2475 }
2476
2477
2478 static PyObject *_wrap_Colour_Blue(PyObject *, PyObject *args, PyObject *kwargs) {
2479 PyObject *resultobj;
2480 wxColour *arg1 = (wxColour *) 0 ;
2481 byte result;
2482 PyObject * obj0 = 0 ;
2483 char *kwnames[] = {
2484 (char *) "self", NULL
2485 };
2486
2487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Blue",kwnames,&obj0)) goto fail;
2488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2489 if (SWIG_arg_fail(1)) SWIG_fail;
2490 {
2491 PyThreadState* __tstate = wxPyBeginAllowThreads();
2492 result = (byte)(arg1)->Blue();
2493
2494 wxPyEndAllowThreads(__tstate);
2495 if (PyErr_Occurred()) SWIG_fail;
2496 }
2497 {
2498 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2499 }
2500 return resultobj;
2501 fail:
2502 return NULL;
2503 }
2504
2505
2506 static PyObject *_wrap_Colour_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
2507 PyObject *resultobj;
2508 wxColour *arg1 = (wxColour *) 0 ;
2509 bool result;
2510 PyObject * obj0 = 0 ;
2511 char *kwnames[] = {
2512 (char *) "self", NULL
2513 };
2514
2515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Ok",kwnames,&obj0)) goto fail;
2516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2517 if (SWIG_arg_fail(1)) SWIG_fail;
2518 {
2519 PyThreadState* __tstate = wxPyBeginAllowThreads();
2520 result = (bool)(arg1)->Ok();
2521
2522 wxPyEndAllowThreads(__tstate);
2523 if (PyErr_Occurred()) SWIG_fail;
2524 }
2525 {
2526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2527 }
2528 return resultobj;
2529 fail:
2530 return NULL;
2531 }
2532
2533
2534 static PyObject *_wrap_Colour_Set(PyObject *, PyObject *args, PyObject *kwargs) {
2535 PyObject *resultobj;
2536 wxColour *arg1 = (wxColour *) 0 ;
2537 byte arg2 ;
2538 byte arg3 ;
2539 byte arg4 ;
2540 PyObject * obj0 = 0 ;
2541 PyObject * obj1 = 0 ;
2542 PyObject * obj2 = 0 ;
2543 PyObject * obj3 = 0 ;
2544 char *kwnames[] = {
2545 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2546 };
2547
2548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Colour_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2550 if (SWIG_arg_fail(1)) SWIG_fail;
2551 {
2552 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2553 if (SWIG_arg_fail(2)) SWIG_fail;
2554 }
2555 {
2556 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2557 if (SWIG_arg_fail(3)) SWIG_fail;
2558 }
2559 {
2560 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2561 if (SWIG_arg_fail(4)) SWIG_fail;
2562 }
2563 {
2564 PyThreadState* __tstate = wxPyBeginAllowThreads();
2565 (arg1)->Set(arg2,arg3,arg4);
2566
2567 wxPyEndAllowThreads(__tstate);
2568 if (PyErr_Occurred()) SWIG_fail;
2569 }
2570 Py_INCREF(Py_None); resultobj = Py_None;
2571 return resultobj;
2572 fail:
2573 return NULL;
2574 }
2575
2576
2577 static PyObject *_wrap_Colour_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2578 PyObject *resultobj;
2579 wxColour *arg1 = (wxColour *) 0 ;
2580 unsigned long arg2 ;
2581 PyObject * obj0 = 0 ;
2582 PyObject * obj1 = 0 ;
2583 char *kwnames[] = {
2584 (char *) "self",(char *) "colRGB", NULL
2585 };
2586
2587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetRGB",kwnames,&obj0,&obj1)) goto fail;
2588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2589 if (SWIG_arg_fail(1)) SWIG_fail;
2590 {
2591 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
2592 if (SWIG_arg_fail(2)) SWIG_fail;
2593 }
2594 {
2595 PyThreadState* __tstate = wxPyBeginAllowThreads();
2596 (arg1)->Set(arg2);
2597
2598 wxPyEndAllowThreads(__tstate);
2599 if (PyErr_Occurred()) SWIG_fail;
2600 }
2601 Py_INCREF(Py_None); resultobj = Py_None;
2602 return resultobj;
2603 fail:
2604 return NULL;
2605 }
2606
2607
2608 static PyObject *_wrap_Colour_SetFromName(PyObject *, PyObject *args, PyObject *kwargs) {
2609 PyObject *resultobj;
2610 wxColour *arg1 = (wxColour *) 0 ;
2611 wxString *arg2 = 0 ;
2612 bool temp2 = false ;
2613 PyObject * obj0 = 0 ;
2614 PyObject * obj1 = 0 ;
2615 char *kwnames[] = {
2616 (char *) "self",(char *) "colourName", NULL
2617 };
2618
2619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetFromName",kwnames,&obj0,&obj1)) goto fail;
2620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2621 if (SWIG_arg_fail(1)) SWIG_fail;
2622 {
2623 arg2 = wxString_in_helper(obj1);
2624 if (arg2 == NULL) SWIG_fail;
2625 temp2 = true;
2626 }
2627 {
2628 PyThreadState* __tstate = wxPyBeginAllowThreads();
2629 (arg1)->InitFromName((wxString const &)*arg2);
2630
2631 wxPyEndAllowThreads(__tstate);
2632 if (PyErr_Occurred()) SWIG_fail;
2633 }
2634 Py_INCREF(Py_None); resultobj = Py_None;
2635 {
2636 if (temp2)
2637 delete arg2;
2638 }
2639 return resultobj;
2640 fail:
2641 {
2642 if (temp2)
2643 delete arg2;
2644 }
2645 return NULL;
2646 }
2647
2648
2649 static PyObject *_wrap_Colour_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2650 PyObject *resultobj;
2651 wxColour *arg1 = (wxColour *) 0 ;
2652 long result;
2653 PyObject * obj0 = 0 ;
2654 char *kwnames[] = {
2655 (char *) "self", NULL
2656 };
2657
2658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetPixel",kwnames,&obj0)) goto fail;
2659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2660 if (SWIG_arg_fail(1)) SWIG_fail;
2661 {
2662 PyThreadState* __tstate = wxPyBeginAllowThreads();
2663 result = (long)((wxColour const *)arg1)->GetPixel();
2664
2665 wxPyEndAllowThreads(__tstate);
2666 if (PyErr_Occurred()) SWIG_fail;
2667 }
2668 {
2669 resultobj = SWIG_From_long((long)(result));
2670 }
2671 return resultobj;
2672 fail:
2673 return NULL;
2674 }
2675
2676
2677 static PyObject *_wrap_Colour___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
2678 PyObject *resultobj;
2679 wxColour *arg1 = (wxColour *) 0 ;
2680 wxColour *arg2 = 0 ;
2681 bool result;
2682 wxColour temp2 ;
2683 PyObject * obj0 = 0 ;
2684 PyObject * obj1 = 0 ;
2685 char *kwnames[] = {
2686 (char *) "self",(char *) "colour", NULL
2687 };
2688
2689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___eq__",kwnames,&obj0,&obj1)) goto fail;
2690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2691 if (SWIG_arg_fail(1)) SWIG_fail;
2692 {
2693 arg2 = &temp2;
2694 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2695 }
2696 {
2697 PyThreadState* __tstate = wxPyBeginAllowThreads();
2698 result = (bool)((wxColour const *)arg1)->operator ==((wxColour const &)*arg2);
2699
2700 wxPyEndAllowThreads(__tstate);
2701 if (PyErr_Occurred()) SWIG_fail;
2702 }
2703 {
2704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2705 }
2706 return resultobj;
2707 fail:
2708 return NULL;
2709 }
2710
2711
2712 static PyObject *_wrap_Colour___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
2713 PyObject *resultobj;
2714 wxColour *arg1 = (wxColour *) 0 ;
2715 wxColour *arg2 = 0 ;
2716 bool result;
2717 wxColour temp2 ;
2718 PyObject * obj0 = 0 ;
2719 PyObject * obj1 = 0 ;
2720 char *kwnames[] = {
2721 (char *) "self",(char *) "colour", NULL
2722 };
2723
2724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___ne__",kwnames,&obj0,&obj1)) goto fail;
2725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2726 if (SWIG_arg_fail(1)) SWIG_fail;
2727 {
2728 arg2 = &temp2;
2729 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2730 }
2731 {
2732 PyThreadState* __tstate = wxPyBeginAllowThreads();
2733 result = (bool)((wxColour const *)arg1)->operator !=((wxColour const &)*arg2);
2734
2735 wxPyEndAllowThreads(__tstate);
2736 if (PyErr_Occurred()) SWIG_fail;
2737 }
2738 {
2739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2740 }
2741 return resultobj;
2742 fail:
2743 return NULL;
2744 }
2745
2746
2747 static PyObject *_wrap_Colour_Get(PyObject *, PyObject *args, PyObject *kwargs) {
2748 PyObject *resultobj;
2749 wxColour *arg1 = (wxColour *) 0 ;
2750 PyObject *result;
2751 PyObject * obj0 = 0 ;
2752 char *kwnames[] = {
2753 (char *) "self", NULL
2754 };
2755
2756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Get",kwnames,&obj0)) goto fail;
2757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2758 if (SWIG_arg_fail(1)) SWIG_fail;
2759 {
2760 PyThreadState* __tstate = wxPyBeginAllowThreads();
2761 result = (PyObject *)wxColour_Get(arg1);
2762
2763 wxPyEndAllowThreads(__tstate);
2764 if (PyErr_Occurred()) SWIG_fail;
2765 }
2766 resultobj = result;
2767 return resultobj;
2768 fail:
2769 return NULL;
2770 }
2771
2772
2773 static PyObject *_wrap_Colour_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2774 PyObject *resultobj;
2775 wxColour *arg1 = (wxColour *) 0 ;
2776 unsigned long result;
2777 PyObject * obj0 = 0 ;
2778 char *kwnames[] = {
2779 (char *) "self", NULL
2780 };
2781
2782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetRGB",kwnames,&obj0)) goto fail;
2783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2784 if (SWIG_arg_fail(1)) SWIG_fail;
2785 {
2786 PyThreadState* __tstate = wxPyBeginAllowThreads();
2787 result = (unsigned long)wxColour_GetRGB(arg1);
2788
2789 wxPyEndAllowThreads(__tstate);
2790 if (PyErr_Occurred()) SWIG_fail;
2791 }
2792 {
2793 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
2794 }
2795 return resultobj;
2796 fail:
2797 return NULL;
2798 }
2799
2800
2801 static PyObject * Colour_swigregister(PyObject *, PyObject *args) {
2802 PyObject *obj;
2803 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2804 SWIG_TypeClientData(SWIGTYPE_p_wxColour, obj);
2805 Py_INCREF(obj);
2806 return Py_BuildValue((char *)"");
2807 }
2808 static PyObject *_wrap_new_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2809 PyObject *resultobj;
2810 int arg1 ;
2811 unsigned char *arg2 = (unsigned char *) 0 ;
2812 unsigned char *arg3 = (unsigned char *) 0 ;
2813 unsigned char *arg4 = (unsigned char *) 0 ;
2814 wxPalette *result;
2815 PyObject * obj0 = 0 ;
2816 PyObject * obj1 = 0 ;
2817 PyObject * obj2 = 0 ;
2818 PyObject * obj3 = 0 ;
2819 char *kwnames[] = {
2820 (char *) "n",(char *) "red",(char *) "green",(char *) "blue", NULL
2821 };
2822
2823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_Palette",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2824 {
2825 arg1 = (int)(SWIG_As_int(obj0));
2826 if (SWIG_arg_fail(1)) SWIG_fail;
2827 }
2828 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2829 if (SWIG_arg_fail(2)) SWIG_fail;
2830 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2831 if (SWIG_arg_fail(3)) SWIG_fail;
2832 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2833 if (SWIG_arg_fail(4)) SWIG_fail;
2834 {
2835 if (!wxPyCheckForApp()) SWIG_fail;
2836 PyThreadState* __tstate = wxPyBeginAllowThreads();
2837 result = (wxPalette *)new wxPalette(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
2838
2839 wxPyEndAllowThreads(__tstate);
2840 if (PyErr_Occurred()) SWIG_fail;
2841 }
2842 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 1);
2843 return resultobj;
2844 fail:
2845 return NULL;
2846 }
2847
2848
2849 static PyObject *_wrap_delete_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2850 PyObject *resultobj;
2851 wxPalette *arg1 = (wxPalette *) 0 ;
2852 PyObject * obj0 = 0 ;
2853 char *kwnames[] = {
2854 (char *) "self", NULL
2855 };
2856
2857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Palette",kwnames,&obj0)) goto fail;
2858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2859 if (SWIG_arg_fail(1)) SWIG_fail;
2860 {
2861 PyThreadState* __tstate = wxPyBeginAllowThreads();
2862 delete arg1;
2863
2864 wxPyEndAllowThreads(__tstate);
2865 if (PyErr_Occurred()) SWIG_fail;
2866 }
2867 Py_INCREF(Py_None); resultobj = Py_None;
2868 return resultobj;
2869 fail:
2870 return NULL;
2871 }
2872
2873
2874 static PyObject *_wrap_Palette_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2875 PyObject *resultobj;
2876 wxPalette *arg1 = (wxPalette *) 0 ;
2877 byte arg2 ;
2878 byte arg3 ;
2879 byte arg4 ;
2880 int result;
2881 PyObject * obj0 = 0 ;
2882 PyObject * obj1 = 0 ;
2883 PyObject * obj2 = 0 ;
2884 PyObject * obj3 = 0 ;
2885 char *kwnames[] = {
2886 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2887 };
2888
2889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Palette_GetPixel",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2891 if (SWIG_arg_fail(1)) SWIG_fail;
2892 {
2893 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2894 if (SWIG_arg_fail(2)) SWIG_fail;
2895 }
2896 {
2897 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2898 if (SWIG_arg_fail(3)) SWIG_fail;
2899 }
2900 {
2901 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2902 if (SWIG_arg_fail(4)) SWIG_fail;
2903 }
2904 {
2905 PyThreadState* __tstate = wxPyBeginAllowThreads();
2906 result = (int)(arg1)->GetPixel(arg2,arg3,arg4);
2907
2908 wxPyEndAllowThreads(__tstate);
2909 if (PyErr_Occurred()) SWIG_fail;
2910 }
2911 {
2912 resultobj = SWIG_From_int((int)(result));
2913 }
2914 return resultobj;
2915 fail:
2916 return NULL;
2917 }
2918
2919
2920 static PyObject *_wrap_Palette_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2921 PyObject *resultobj;
2922 wxPalette *arg1 = (wxPalette *) 0 ;
2923 int arg2 ;
2924 byte *arg3 = (byte *) 0 ;
2925 byte *arg4 = (byte *) 0 ;
2926 byte *arg5 = (byte *) 0 ;
2927 bool result;
2928 byte temp3 ;
2929 int res3 = 0 ;
2930 byte temp4 ;
2931 int res4 = 0 ;
2932 byte temp5 ;
2933 int res5 = 0 ;
2934 PyObject * obj0 = 0 ;
2935 PyObject * obj1 = 0 ;
2936 char *kwnames[] = {
2937 (char *) "self",(char *) "pixel", NULL
2938 };
2939
2940 arg3 = &temp3; res3 = SWIG_NEWOBJ;
2941 arg4 = &temp4; res4 = SWIG_NEWOBJ;
2942 arg5 = &temp5; res5 = SWIG_NEWOBJ;
2943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Palette_GetRGB",kwnames,&obj0,&obj1)) goto fail;
2944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2945 if (SWIG_arg_fail(1)) SWIG_fail;
2946 {
2947 arg2 = (int)(SWIG_As_int(obj1));
2948 if (SWIG_arg_fail(2)) SWIG_fail;
2949 }
2950 {
2951 PyThreadState* __tstate = wxPyBeginAllowThreads();
2952 result = (bool)(arg1)->GetRGB(arg2,arg3,arg4,arg5);
2953
2954 wxPyEndAllowThreads(__tstate);
2955 if (PyErr_Occurred()) SWIG_fail;
2956 }
2957 {
2958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2959 }
2960 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
2961 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
2962 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
2963 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
2964 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
2965 SWIG_From_unsigned_SS_char((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_unsigned_char, 0)));
2966 return resultobj;
2967 fail:
2968 return NULL;
2969 }
2970
2971
2972 static PyObject *_wrap_Palette_GetColoursCount(PyObject *, PyObject *args, PyObject *kwargs) {
2973 PyObject *resultobj;
2974 wxPalette *arg1 = (wxPalette *) 0 ;
2975 int result;
2976 PyObject * obj0 = 0 ;
2977 char *kwnames[] = {
2978 (char *) "self", NULL
2979 };
2980
2981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_GetColoursCount",kwnames,&obj0)) goto fail;
2982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2983 if (SWIG_arg_fail(1)) SWIG_fail;
2984 {
2985 PyThreadState* __tstate = wxPyBeginAllowThreads();
2986 result = (int)((wxPalette const *)arg1)->GetColoursCount();
2987
2988 wxPyEndAllowThreads(__tstate);
2989 if (PyErr_Occurred()) SWIG_fail;
2990 }
2991 {
2992 resultobj = SWIG_From_int((int)(result));
2993 }
2994 return resultobj;
2995 fail:
2996 return NULL;
2997 }
2998
2999
3000 static PyObject *_wrap_Palette_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3001 PyObject *resultobj;
3002 wxPalette *arg1 = (wxPalette *) 0 ;
3003 bool result;
3004 PyObject * obj0 = 0 ;
3005 char *kwnames[] = {
3006 (char *) "self", NULL
3007 };
3008
3009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_Ok",kwnames,&obj0)) goto fail;
3010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
3011 if (SWIG_arg_fail(1)) SWIG_fail;
3012 {
3013 PyThreadState* __tstate = wxPyBeginAllowThreads();
3014 result = (bool)(arg1)->Ok();
3015
3016 wxPyEndAllowThreads(__tstate);
3017 if (PyErr_Occurred()) SWIG_fail;
3018 }
3019 {
3020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3021 }
3022 return resultobj;
3023 fail:
3024 return NULL;
3025 }
3026
3027
3028 static PyObject * Palette_swigregister(PyObject *, PyObject *args) {
3029 PyObject *obj;
3030 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3031 SWIG_TypeClientData(SWIGTYPE_p_wxPalette, obj);
3032 Py_INCREF(obj);
3033 return Py_BuildValue((char *)"");
3034 }
3035 static PyObject *_wrap_new_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3036 PyObject *resultobj;
3037 wxColour *arg1 = 0 ;
3038 int arg2 = (int) 1 ;
3039 int arg3 = (int) wxSOLID ;
3040 wxPen *result;
3041 wxColour temp1 ;
3042 PyObject * obj0 = 0 ;
3043 PyObject * obj1 = 0 ;
3044 PyObject * obj2 = 0 ;
3045 char *kwnames[] = {
3046 (char *) "colour",(char *) "width",(char *) "style", NULL
3047 };
3048
3049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Pen",kwnames,&obj0,&obj1,&obj2)) goto fail;
3050 {
3051 arg1 = &temp1;
3052 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3053 }
3054 if (obj1) {
3055 {
3056 arg2 = (int)(SWIG_As_int(obj1));
3057 if (SWIG_arg_fail(2)) SWIG_fail;
3058 }
3059 }
3060 if (obj2) {
3061 {
3062 arg3 = (int)(SWIG_As_int(obj2));
3063 if (SWIG_arg_fail(3)) SWIG_fail;
3064 }
3065 }
3066 {
3067 if (!wxPyCheckForApp()) SWIG_fail;
3068 PyThreadState* __tstate = wxPyBeginAllowThreads();
3069 result = (wxPen *)new wxPen(*arg1,arg2,arg3);
3070
3071 wxPyEndAllowThreads(__tstate);
3072 if (PyErr_Occurred()) SWIG_fail;
3073 }
3074 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 1);
3075 return resultobj;
3076 fail:
3077 return NULL;
3078 }
3079
3080
3081 static PyObject *_wrap_delete_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3082 PyObject *resultobj;
3083 wxPen *arg1 = (wxPen *) 0 ;
3084 PyObject * obj0 = 0 ;
3085 char *kwnames[] = {
3086 (char *) "self", NULL
3087 };
3088
3089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Pen",kwnames,&obj0)) goto fail;
3090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3091 if (SWIG_arg_fail(1)) SWIG_fail;
3092 {
3093 PyThreadState* __tstate = wxPyBeginAllowThreads();
3094 delete arg1;
3095
3096 wxPyEndAllowThreads(__tstate);
3097 if (PyErr_Occurred()) SWIG_fail;
3098 }
3099 Py_INCREF(Py_None); resultobj = Py_None;
3100 return resultobj;
3101 fail:
3102 return NULL;
3103 }
3104
3105
3106 static PyObject *_wrap_Pen_GetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3107 PyObject *resultobj;
3108 wxPen *arg1 = (wxPen *) 0 ;
3109 int result;
3110 PyObject * obj0 = 0 ;
3111 char *kwnames[] = {
3112 (char *) "self", NULL
3113 };
3114
3115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetCap",kwnames,&obj0)) goto fail;
3116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3117 if (SWIG_arg_fail(1)) SWIG_fail;
3118 {
3119 PyThreadState* __tstate = wxPyBeginAllowThreads();
3120 result = (int)(arg1)->GetCap();
3121
3122 wxPyEndAllowThreads(__tstate);
3123 if (PyErr_Occurred()) SWIG_fail;
3124 }
3125 {
3126 resultobj = SWIG_From_int((int)(result));
3127 }
3128 return resultobj;
3129 fail:
3130 return NULL;
3131 }
3132
3133
3134 static PyObject *_wrap_Pen_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3135 PyObject *resultobj;
3136 wxPen *arg1 = (wxPen *) 0 ;
3137 wxColour result;
3138 PyObject * obj0 = 0 ;
3139 char *kwnames[] = {
3140 (char *) "self", NULL
3141 };
3142
3143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetColour",kwnames,&obj0)) goto fail;
3144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3145 if (SWIG_arg_fail(1)) SWIG_fail;
3146 {
3147 PyThreadState* __tstate = wxPyBeginAllowThreads();
3148 result = (arg1)->GetColour();
3149
3150 wxPyEndAllowThreads(__tstate);
3151 if (PyErr_Occurred()) SWIG_fail;
3152 }
3153 {
3154 wxColour * resultptr;
3155 resultptr = new wxColour((wxColour &)(result));
3156 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3157 }
3158 return resultobj;
3159 fail:
3160 return NULL;
3161 }
3162
3163
3164 static PyObject *_wrap_Pen_GetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3165 PyObject *resultobj;
3166 wxPen *arg1 = (wxPen *) 0 ;
3167 int result;
3168 PyObject * obj0 = 0 ;
3169 char *kwnames[] = {
3170 (char *) "self", NULL
3171 };
3172
3173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetJoin",kwnames,&obj0)) goto fail;
3174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3175 if (SWIG_arg_fail(1)) SWIG_fail;
3176 {
3177 PyThreadState* __tstate = wxPyBeginAllowThreads();
3178 result = (int)(arg1)->GetJoin();
3179
3180 wxPyEndAllowThreads(__tstate);
3181 if (PyErr_Occurred()) SWIG_fail;
3182 }
3183 {
3184 resultobj = SWIG_From_int((int)(result));
3185 }
3186 return resultobj;
3187 fail:
3188 return NULL;
3189 }
3190
3191
3192 static PyObject *_wrap_Pen_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3193 PyObject *resultobj;
3194 wxPen *arg1 = (wxPen *) 0 ;
3195 int result;
3196 PyObject * obj0 = 0 ;
3197 char *kwnames[] = {
3198 (char *) "self", NULL
3199 };
3200
3201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetStyle",kwnames,&obj0)) goto fail;
3202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3203 if (SWIG_arg_fail(1)) SWIG_fail;
3204 {
3205 PyThreadState* __tstate = wxPyBeginAllowThreads();
3206 result = (int)(arg1)->GetStyle();
3207
3208 wxPyEndAllowThreads(__tstate);
3209 if (PyErr_Occurred()) SWIG_fail;
3210 }
3211 {
3212 resultobj = SWIG_From_int((int)(result));
3213 }
3214 return resultobj;
3215 fail:
3216 return NULL;
3217 }
3218
3219
3220 static PyObject *_wrap_Pen_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3221 PyObject *resultobj;
3222 wxPen *arg1 = (wxPen *) 0 ;
3223 int result;
3224 PyObject * obj0 = 0 ;
3225 char *kwnames[] = {
3226 (char *) "self", NULL
3227 };
3228
3229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetWidth",kwnames,&obj0)) goto fail;
3230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3231 if (SWIG_arg_fail(1)) SWIG_fail;
3232 {
3233 PyThreadState* __tstate = wxPyBeginAllowThreads();
3234 result = (int)(arg1)->GetWidth();
3235
3236 wxPyEndAllowThreads(__tstate);
3237 if (PyErr_Occurred()) SWIG_fail;
3238 }
3239 {
3240 resultobj = SWIG_From_int((int)(result));
3241 }
3242 return resultobj;
3243 fail:
3244 return NULL;
3245 }
3246
3247
3248 static PyObject *_wrap_Pen_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3249 PyObject *resultobj;
3250 wxPen *arg1 = (wxPen *) 0 ;
3251 bool result;
3252 PyObject * obj0 = 0 ;
3253 char *kwnames[] = {
3254 (char *) "self", NULL
3255 };
3256
3257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_Ok",kwnames,&obj0)) goto fail;
3258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3259 if (SWIG_arg_fail(1)) SWIG_fail;
3260 {
3261 PyThreadState* __tstate = wxPyBeginAllowThreads();
3262 result = (bool)(arg1)->Ok();
3263
3264 wxPyEndAllowThreads(__tstate);
3265 if (PyErr_Occurred()) SWIG_fail;
3266 }
3267 {
3268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3269 }
3270 return resultobj;
3271 fail:
3272 return NULL;
3273 }
3274
3275
3276 static PyObject *_wrap_Pen_SetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3277 PyObject *resultobj;
3278 wxPen *arg1 = (wxPen *) 0 ;
3279 int arg2 ;
3280 PyObject * obj0 = 0 ;
3281 PyObject * obj1 = 0 ;
3282 char *kwnames[] = {
3283 (char *) "self",(char *) "cap_style", NULL
3284 };
3285
3286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetCap",kwnames,&obj0,&obj1)) goto fail;
3287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3288 if (SWIG_arg_fail(1)) SWIG_fail;
3289 {
3290 arg2 = (int)(SWIG_As_int(obj1));
3291 if (SWIG_arg_fail(2)) SWIG_fail;
3292 }
3293 {
3294 PyThreadState* __tstate = wxPyBeginAllowThreads();
3295 (arg1)->SetCap(arg2);
3296
3297 wxPyEndAllowThreads(__tstate);
3298 if (PyErr_Occurred()) SWIG_fail;
3299 }
3300 Py_INCREF(Py_None); resultobj = Py_None;
3301 return resultobj;
3302 fail:
3303 return NULL;
3304 }
3305
3306
3307 static PyObject *_wrap_Pen_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3308 PyObject *resultobj;
3309 wxPen *arg1 = (wxPen *) 0 ;
3310 wxColour *arg2 = 0 ;
3311 wxColour temp2 ;
3312 PyObject * obj0 = 0 ;
3313 PyObject * obj1 = 0 ;
3314 char *kwnames[] = {
3315 (char *) "self",(char *) "colour", NULL
3316 };
3317
3318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetColour",kwnames,&obj0,&obj1)) goto fail;
3319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3320 if (SWIG_arg_fail(1)) SWIG_fail;
3321 {
3322 arg2 = &temp2;
3323 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3324 }
3325 {
3326 PyThreadState* __tstate = wxPyBeginAllowThreads();
3327 (arg1)->SetColour(*arg2);
3328
3329 wxPyEndAllowThreads(__tstate);
3330 if (PyErr_Occurred()) SWIG_fail;
3331 }
3332 Py_INCREF(Py_None); resultobj = Py_None;
3333 return resultobj;
3334 fail:
3335 return NULL;
3336 }
3337
3338
3339 static PyObject *_wrap_Pen_SetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3340 PyObject *resultobj;
3341 wxPen *arg1 = (wxPen *) 0 ;
3342 int arg2 ;
3343 PyObject * obj0 = 0 ;
3344 PyObject * obj1 = 0 ;
3345 char *kwnames[] = {
3346 (char *) "self",(char *) "join_style", NULL
3347 };
3348
3349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetJoin",kwnames,&obj0,&obj1)) goto fail;
3350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3351 if (SWIG_arg_fail(1)) SWIG_fail;
3352 {
3353 arg2 = (int)(SWIG_As_int(obj1));
3354 if (SWIG_arg_fail(2)) SWIG_fail;
3355 }
3356 {
3357 PyThreadState* __tstate = wxPyBeginAllowThreads();
3358 (arg1)->SetJoin(arg2);
3359
3360 wxPyEndAllowThreads(__tstate);
3361 if (PyErr_Occurred()) SWIG_fail;
3362 }
3363 Py_INCREF(Py_None); resultobj = Py_None;
3364 return resultobj;
3365 fail:
3366 return NULL;
3367 }
3368
3369
3370 static PyObject *_wrap_Pen_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3371 PyObject *resultobj;
3372 wxPen *arg1 = (wxPen *) 0 ;
3373 int arg2 ;
3374 PyObject * obj0 = 0 ;
3375 PyObject * obj1 = 0 ;
3376 char *kwnames[] = {
3377 (char *) "self",(char *) "style", NULL
3378 };
3379
3380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3382 if (SWIG_arg_fail(1)) SWIG_fail;
3383 {
3384 arg2 = (int)(SWIG_As_int(obj1));
3385 if (SWIG_arg_fail(2)) SWIG_fail;
3386 }
3387 {
3388 PyThreadState* __tstate = wxPyBeginAllowThreads();
3389 (arg1)->SetStyle(arg2);
3390
3391 wxPyEndAllowThreads(__tstate);
3392 if (PyErr_Occurred()) SWIG_fail;
3393 }
3394 Py_INCREF(Py_None); resultobj = Py_None;
3395 return resultobj;
3396 fail:
3397 return NULL;
3398 }
3399
3400
3401 static PyObject *_wrap_Pen_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3402 PyObject *resultobj;
3403 wxPen *arg1 = (wxPen *) 0 ;
3404 int arg2 ;
3405 PyObject * obj0 = 0 ;
3406 PyObject * obj1 = 0 ;
3407 char *kwnames[] = {
3408 (char *) "self",(char *) "width", NULL
3409 };
3410
3411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3413 if (SWIG_arg_fail(1)) SWIG_fail;
3414 {
3415 arg2 = (int)(SWIG_As_int(obj1));
3416 if (SWIG_arg_fail(2)) SWIG_fail;
3417 }
3418 {
3419 PyThreadState* __tstate = wxPyBeginAllowThreads();
3420 (arg1)->SetWidth(arg2);
3421
3422 wxPyEndAllowThreads(__tstate);
3423 if (PyErr_Occurred()) SWIG_fail;
3424 }
3425 Py_INCREF(Py_None); resultobj = Py_None;
3426 return resultobj;
3427 fail:
3428 return NULL;
3429 }
3430
3431
3432 static PyObject *_wrap_Pen_SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3433 PyObject *resultobj;
3434 wxPen *arg1 = (wxPen *) 0 ;
3435 int arg2 ;
3436 wxDash *arg3 = (wxDash *) 0 ;
3437 PyObject * obj0 = 0 ;
3438 PyObject * obj1 = 0 ;
3439 char *kwnames[] = {
3440 (char *) "self",(char *) "dashes", NULL
3441 };
3442
3443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetDashes",kwnames,&obj0,&obj1)) goto fail;
3444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3445 if (SWIG_arg_fail(1)) SWIG_fail;
3446 {
3447 arg2 = PyList_Size(obj1);
3448 arg3 = (wxDash*)byte_LIST_helper(obj1);
3449 if (arg3 == NULL) SWIG_fail;
3450 }
3451 {
3452 PyThreadState* __tstate = wxPyBeginAllowThreads();
3453 (arg1)->SetDashes(arg2,arg3);
3454
3455 wxPyEndAllowThreads(__tstate);
3456 if (PyErr_Occurred()) SWIG_fail;
3457 }
3458 Py_INCREF(Py_None); resultobj = Py_None;
3459 {
3460 if (arg3) delete [] arg3;
3461 }
3462 return resultobj;
3463 fail:
3464 {
3465 if (arg3) delete [] arg3;
3466 }
3467 return NULL;
3468 }
3469
3470
3471 static PyObject *_wrap_Pen_GetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3472 PyObject *resultobj;
3473 wxPen *arg1 = (wxPen *) 0 ;
3474 PyObject *result;
3475 PyObject * obj0 = 0 ;
3476 char *kwnames[] = {
3477 (char *) "self", NULL
3478 };
3479
3480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetDashes",kwnames,&obj0)) goto fail;
3481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3482 if (SWIG_arg_fail(1)) SWIG_fail;
3483 {
3484 PyThreadState* __tstate = wxPyBeginAllowThreads();
3485 result = (PyObject *)wxPen_GetDashes(arg1);
3486
3487 wxPyEndAllowThreads(__tstate);
3488 if (PyErr_Occurred()) SWIG_fail;
3489 }
3490 resultobj = result;
3491 return resultobj;
3492 fail:
3493 return NULL;
3494 }
3495
3496
3497 static PyObject *_wrap_Pen__SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3498 PyObject *resultobj;
3499 wxPen *arg1 = (wxPen *) 0 ;
3500 PyObject *arg2 = (PyObject *) 0 ;
3501 PyObject *arg3 = (PyObject *) 0 ;
3502 PyObject * obj0 = 0 ;
3503 PyObject * obj1 = 0 ;
3504 PyObject * obj2 = 0 ;
3505 char *kwnames[] = {
3506 (char *) "self",(char *) "_self",(char *) "pyDashes", NULL
3507 };
3508
3509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Pen__SetDashes",kwnames,&obj0,&obj1,&obj2)) goto fail;
3510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3511 if (SWIG_arg_fail(1)) SWIG_fail;
3512 arg2 = obj1;
3513 arg3 = obj2;
3514 {
3515 PyThreadState* __tstate = wxPyBeginAllowThreads();
3516 wxPen__SetDashes(arg1,arg2,arg3);
3517
3518 wxPyEndAllowThreads(__tstate);
3519 if (PyErr_Occurred()) SWIG_fail;
3520 }
3521 Py_INCREF(Py_None); resultobj = Py_None;
3522 return resultobj;
3523 fail:
3524 return NULL;
3525 }
3526
3527
3528 static PyObject *_wrap_Pen_GetDashCount(PyObject *, PyObject *args, PyObject *kwargs) {
3529 PyObject *resultobj;
3530 wxPen *arg1 = (wxPen *) 0 ;
3531 int result;
3532 PyObject * obj0 = 0 ;
3533 char *kwnames[] = {
3534 (char *) "self", NULL
3535 };
3536
3537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetDashCount",kwnames,&obj0)) goto fail;
3538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3539 if (SWIG_arg_fail(1)) SWIG_fail;
3540 {
3541 PyThreadState* __tstate = wxPyBeginAllowThreads();
3542 result = (int)((wxPen const *)arg1)->GetDashCount();
3543
3544 wxPyEndAllowThreads(__tstate);
3545 if (PyErr_Occurred()) SWIG_fail;
3546 }
3547 {
3548 resultobj = SWIG_From_int((int)(result));
3549 }
3550 return resultobj;
3551 fail:
3552 return NULL;
3553 }
3554
3555
3556 static PyObject *_wrap_Pen___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3557 PyObject *resultobj;
3558 wxPen *arg1 = (wxPen *) 0 ;
3559 wxPen *arg2 = (wxPen *) 0 ;
3560 bool result;
3561 PyObject * obj0 = 0 ;
3562 PyObject * obj1 = 0 ;
3563 char *kwnames[] = {
3564 (char *) "self",(char *) "other", NULL
3565 };
3566
3567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___eq__",kwnames,&obj0,&obj1)) goto fail;
3568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3569 if (SWIG_arg_fail(1)) SWIG_fail;
3570 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3571 if (SWIG_arg_fail(2)) SWIG_fail;
3572 {
3573 PyThreadState* __tstate = wxPyBeginAllowThreads();
3574 result = (bool)wxPen___eq__(arg1,(wxPen const *)arg2);
3575
3576 wxPyEndAllowThreads(__tstate);
3577 if (PyErr_Occurred()) SWIG_fail;
3578 }
3579 {
3580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3581 }
3582 return resultobj;
3583 fail:
3584 return NULL;
3585 }
3586
3587
3588 static PyObject *_wrap_Pen___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3589 PyObject *resultobj;
3590 wxPen *arg1 = (wxPen *) 0 ;
3591 wxPen *arg2 = (wxPen *) 0 ;
3592 bool result;
3593 PyObject * obj0 = 0 ;
3594 PyObject * obj1 = 0 ;
3595 char *kwnames[] = {
3596 (char *) "self",(char *) "other", NULL
3597 };
3598
3599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___ne__",kwnames,&obj0,&obj1)) goto fail;
3600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3601 if (SWIG_arg_fail(1)) SWIG_fail;
3602 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3603 if (SWIG_arg_fail(2)) SWIG_fail;
3604 {
3605 PyThreadState* __tstate = wxPyBeginAllowThreads();
3606 result = (bool)wxPen___ne__(arg1,(wxPen const *)arg2);
3607
3608 wxPyEndAllowThreads(__tstate);
3609 if (PyErr_Occurred()) SWIG_fail;
3610 }
3611 {
3612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3613 }
3614 return resultobj;
3615 fail:
3616 return NULL;
3617 }
3618
3619
3620 static PyObject * Pen_swigregister(PyObject *, PyObject *args) {
3621 PyObject *obj;
3622 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3623 SWIG_TypeClientData(SWIGTYPE_p_wxPen, obj);
3624 Py_INCREF(obj);
3625 return Py_BuildValue((char *)"");
3626 }
3627 static PyObject *_wrap_new_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3628 PyObject *resultobj;
3629 wxColour *arg1 = 0 ;
3630 int arg2 = (int) wxSOLID ;
3631 wxBrush *result;
3632 wxColour temp1 ;
3633 PyObject * obj0 = 0 ;
3634 PyObject * obj1 = 0 ;
3635 char *kwnames[] = {
3636 (char *) "colour",(char *) "style", NULL
3637 };
3638
3639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Brush",kwnames,&obj0,&obj1)) goto fail;
3640 {
3641 arg1 = &temp1;
3642 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3643 }
3644 if (obj1) {
3645 {
3646 arg2 = (int)(SWIG_As_int(obj1));
3647 if (SWIG_arg_fail(2)) SWIG_fail;
3648 }
3649 }
3650 {
3651 if (!wxPyCheckForApp()) SWIG_fail;
3652 PyThreadState* __tstate = wxPyBeginAllowThreads();
3653 result = (wxBrush *)new wxBrush((wxColour const &)*arg1,arg2);
3654
3655 wxPyEndAllowThreads(__tstate);
3656 if (PyErr_Occurred()) SWIG_fail;
3657 }
3658 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 1);
3659 return resultobj;
3660 fail:
3661 return NULL;
3662 }
3663
3664
3665 static PyObject *_wrap_delete_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3666 PyObject *resultobj;
3667 wxBrush *arg1 = (wxBrush *) 0 ;
3668 PyObject * obj0 = 0 ;
3669 char *kwnames[] = {
3670 (char *) "self", NULL
3671 };
3672
3673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Brush",kwnames,&obj0)) goto fail;
3674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3675 if (SWIG_arg_fail(1)) SWIG_fail;
3676 {
3677 PyThreadState* __tstate = wxPyBeginAllowThreads();
3678 delete arg1;
3679
3680 wxPyEndAllowThreads(__tstate);
3681 if (PyErr_Occurred()) SWIG_fail;
3682 }
3683 Py_INCREF(Py_None); resultobj = Py_None;
3684 return resultobj;
3685 fail:
3686 return NULL;
3687 }
3688
3689
3690 static PyObject *_wrap_Brush_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3691 PyObject *resultobj;
3692 wxBrush *arg1 = (wxBrush *) 0 ;
3693 wxColour *arg2 = 0 ;
3694 wxColour temp2 ;
3695 PyObject * obj0 = 0 ;
3696 PyObject * obj1 = 0 ;
3697 char *kwnames[] = {
3698 (char *) "self",(char *) "col", NULL
3699 };
3700
3701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetColour",kwnames,&obj0,&obj1)) goto fail;
3702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3703 if (SWIG_arg_fail(1)) SWIG_fail;
3704 {
3705 arg2 = &temp2;
3706 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3707 }
3708 {
3709 PyThreadState* __tstate = wxPyBeginAllowThreads();
3710 (arg1)->SetColour((wxColour const &)*arg2);
3711
3712 wxPyEndAllowThreads(__tstate);
3713 if (PyErr_Occurred()) SWIG_fail;
3714 }
3715 Py_INCREF(Py_None); resultobj = Py_None;
3716 return resultobj;
3717 fail:
3718 return NULL;
3719 }
3720
3721
3722 static PyObject *_wrap_Brush_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3723 PyObject *resultobj;
3724 wxBrush *arg1 = (wxBrush *) 0 ;
3725 int arg2 ;
3726 PyObject * obj0 = 0 ;
3727 PyObject * obj1 = 0 ;
3728 char *kwnames[] = {
3729 (char *) "self",(char *) "style", NULL
3730 };
3731
3732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3734 if (SWIG_arg_fail(1)) SWIG_fail;
3735 {
3736 arg2 = (int)(SWIG_As_int(obj1));
3737 if (SWIG_arg_fail(2)) SWIG_fail;
3738 }
3739 {
3740 PyThreadState* __tstate = wxPyBeginAllowThreads();
3741 (arg1)->SetStyle(arg2);
3742
3743 wxPyEndAllowThreads(__tstate);
3744 if (PyErr_Occurred()) SWIG_fail;
3745 }
3746 Py_INCREF(Py_None); resultobj = Py_None;
3747 return resultobj;
3748 fail:
3749 return NULL;
3750 }
3751
3752
3753 static PyObject *_wrap_Brush_SetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3754 PyObject *resultobj;
3755 wxBrush *arg1 = (wxBrush *) 0 ;
3756 wxBitmap *arg2 = 0 ;
3757 PyObject * obj0 = 0 ;
3758 PyObject * obj1 = 0 ;
3759 char *kwnames[] = {
3760 (char *) "self",(char *) "stipple", NULL
3761 };
3762
3763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStipple",kwnames,&obj0,&obj1)) goto fail;
3764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3765 if (SWIG_arg_fail(1)) SWIG_fail;
3766 {
3767 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3768 if (SWIG_arg_fail(2)) SWIG_fail;
3769 if (arg2 == NULL) {
3770 SWIG_null_ref("wxBitmap");
3771 }
3772 if (SWIG_arg_fail(2)) SWIG_fail;
3773 }
3774 {
3775 PyThreadState* __tstate = wxPyBeginAllowThreads();
3776 (arg1)->SetStipple((wxBitmap const &)*arg2);
3777
3778 wxPyEndAllowThreads(__tstate);
3779 if (PyErr_Occurred()) SWIG_fail;
3780 }
3781 Py_INCREF(Py_None); resultobj = Py_None;
3782 return resultobj;
3783 fail:
3784 return NULL;
3785 }
3786
3787
3788 static PyObject *_wrap_Brush_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3789 PyObject *resultobj;
3790 wxBrush *arg1 = (wxBrush *) 0 ;
3791 wxColour result;
3792 PyObject * obj0 = 0 ;
3793 char *kwnames[] = {
3794 (char *) "self", NULL
3795 };
3796
3797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetColour",kwnames,&obj0)) goto fail;
3798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3799 if (SWIG_arg_fail(1)) SWIG_fail;
3800 {
3801 PyThreadState* __tstate = wxPyBeginAllowThreads();
3802 result = ((wxBrush const *)arg1)->GetColour();
3803
3804 wxPyEndAllowThreads(__tstate);
3805 if (PyErr_Occurred()) SWIG_fail;
3806 }
3807 {
3808 wxColour * resultptr;
3809 resultptr = new wxColour((wxColour &)(result));
3810 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3811 }
3812 return resultobj;
3813 fail:
3814 return NULL;
3815 }
3816
3817
3818 static PyObject *_wrap_Brush_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3819 PyObject *resultobj;
3820 wxBrush *arg1 = (wxBrush *) 0 ;
3821 int result;
3822 PyObject * obj0 = 0 ;
3823 char *kwnames[] = {
3824 (char *) "self", NULL
3825 };
3826
3827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStyle",kwnames,&obj0)) goto fail;
3828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3829 if (SWIG_arg_fail(1)) SWIG_fail;
3830 {
3831 PyThreadState* __tstate = wxPyBeginAllowThreads();
3832 result = (int)((wxBrush const *)arg1)->GetStyle();
3833
3834 wxPyEndAllowThreads(__tstate);
3835 if (PyErr_Occurred()) SWIG_fail;
3836 }
3837 {
3838 resultobj = SWIG_From_int((int)(result));
3839 }
3840 return resultobj;
3841 fail:
3842 return NULL;
3843 }
3844
3845
3846 static PyObject *_wrap_Brush_GetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3847 PyObject *resultobj;
3848 wxBrush *arg1 = (wxBrush *) 0 ;
3849 wxBitmap *result;
3850 PyObject * obj0 = 0 ;
3851 char *kwnames[] = {
3852 (char *) "self", NULL
3853 };
3854
3855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStipple",kwnames,&obj0)) goto fail;
3856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3857 if (SWIG_arg_fail(1)) SWIG_fail;
3858 {
3859 PyThreadState* __tstate = wxPyBeginAllowThreads();
3860 result = (wxBitmap *)((wxBrush const *)arg1)->GetStipple();
3861
3862 wxPyEndAllowThreads(__tstate);
3863 if (PyErr_Occurred()) SWIG_fail;
3864 }
3865 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 0);
3866 return resultobj;
3867 fail:
3868 return NULL;
3869 }
3870
3871
3872 static PyObject *_wrap_Brush_IsHatch(PyObject *, PyObject *args, PyObject *kwargs) {
3873 PyObject *resultobj;
3874 wxBrush *arg1 = (wxBrush *) 0 ;
3875 bool result;
3876 PyObject * obj0 = 0 ;
3877 char *kwnames[] = {
3878 (char *) "self", NULL
3879 };
3880
3881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_IsHatch",kwnames,&obj0)) goto fail;
3882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3883 if (SWIG_arg_fail(1)) SWIG_fail;
3884 {
3885 PyThreadState* __tstate = wxPyBeginAllowThreads();
3886 result = (bool)((wxBrush const *)arg1)->IsHatch();
3887
3888 wxPyEndAllowThreads(__tstate);
3889 if (PyErr_Occurred()) SWIG_fail;
3890 }
3891 {
3892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3893 }
3894 return resultobj;
3895 fail:
3896 return NULL;
3897 }
3898
3899
3900 static PyObject *_wrap_Brush_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3901 PyObject *resultobj;
3902 wxBrush *arg1 = (wxBrush *) 0 ;
3903 bool result;
3904 PyObject * obj0 = 0 ;
3905 char *kwnames[] = {
3906 (char *) "self", NULL
3907 };
3908
3909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_Ok",kwnames,&obj0)) goto fail;
3910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3911 if (SWIG_arg_fail(1)) SWIG_fail;
3912 {
3913 PyThreadState* __tstate = wxPyBeginAllowThreads();
3914 result = (bool)(arg1)->Ok();
3915
3916 wxPyEndAllowThreads(__tstate);
3917 if (PyErr_Occurred()) SWIG_fail;
3918 }
3919 {
3920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3921 }
3922 return resultobj;
3923 fail:
3924 return NULL;
3925 }
3926
3927
3928 static PyObject * Brush_swigregister(PyObject *, PyObject *args) {
3929 PyObject *obj;
3930 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3931 SWIG_TypeClientData(SWIGTYPE_p_wxBrush, obj);
3932 Py_INCREF(obj);
3933 return Py_BuildValue((char *)"");
3934 }
3935 static PyObject *_wrap_new_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
3936 PyObject *resultobj;
3937 wxString *arg1 = 0 ;
3938 wxBitmapType arg2 = (wxBitmapType) wxBITMAP_TYPE_ANY ;
3939 wxBitmap *result;
3940 bool temp1 = false ;
3941 PyObject * obj0 = 0 ;
3942 PyObject * obj1 = 0 ;
3943 char *kwnames[] = {
3944 (char *) "name",(char *) "type", NULL
3945 };
3946
3947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Bitmap",kwnames,&obj0,&obj1)) goto fail;
3948 {
3949 arg1 = wxString_in_helper(obj0);
3950 if (arg1 == NULL) SWIG_fail;
3951 temp1 = true;
3952 }
3953 if (obj1) {
3954 {
3955 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
3956 if (SWIG_arg_fail(2)) SWIG_fail;
3957 }
3958 }
3959 {
3960 if (!wxPyCheckForApp()) SWIG_fail;
3961 PyThreadState* __tstate = wxPyBeginAllowThreads();
3962 result = (wxBitmap *)new wxBitmap((wxString const &)*arg1,(wxBitmapType )arg2);
3963
3964 wxPyEndAllowThreads(__tstate);
3965 if (PyErr_Occurred()) SWIG_fail;
3966 }
3967 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
3968 {
3969 if (temp1)
3970 delete arg1;
3971 }
3972 return resultobj;
3973 fail:
3974 {
3975 if (temp1)
3976 delete arg1;
3977 }
3978 return NULL;
3979 }
3980
3981
3982 static PyObject *_wrap_delete_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
3983 PyObject *resultobj;
3984 wxBitmap *arg1 = (wxBitmap *) 0 ;
3985 PyObject * obj0 = 0 ;
3986 char *kwnames[] = {
3987 (char *) "self", NULL
3988 };
3989
3990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Bitmap",kwnames,&obj0)) goto fail;
3991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3992 if (SWIG_arg_fail(1)) SWIG_fail;
3993 {
3994 PyThreadState* __tstate = wxPyBeginAllowThreads();
3995 delete arg1;
3996
3997 wxPyEndAllowThreads(__tstate);
3998 if (PyErr_Occurred()) SWIG_fail;
3999 }
4000 Py_INCREF(Py_None); resultobj = Py_None;
4001 return resultobj;
4002 fail:
4003 return NULL;
4004 }
4005
4006
4007 static PyObject *_wrap_new_EmptyBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4008 PyObject *resultobj;
4009 int arg1 ;
4010 int arg2 ;
4011 int arg3 = (int) -1 ;
4012 wxBitmap *result;
4013 PyObject * obj0 = 0 ;
4014 PyObject * obj1 = 0 ;
4015 PyObject * obj2 = 0 ;
4016 char *kwnames[] = {
4017 (char *) "width",(char *) "height",(char *) "depth", NULL
4018 };
4019
4020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_EmptyBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
4021 {
4022 arg1 = (int)(SWIG_As_int(obj0));
4023 if (SWIG_arg_fail(1)) SWIG_fail;
4024 }
4025 {
4026 arg2 = (int)(SWIG_As_int(obj1));
4027 if (SWIG_arg_fail(2)) SWIG_fail;
4028 }
4029 if (obj2) {
4030 {
4031 arg3 = (int)(SWIG_As_int(obj2));
4032 if (SWIG_arg_fail(3)) SWIG_fail;
4033 }
4034 }
4035 {
4036 if (!wxPyCheckForApp()) SWIG_fail;
4037 PyThreadState* __tstate = wxPyBeginAllowThreads();
4038 result = (wxBitmap *)new wxBitmap(arg1,arg2,arg3);
4039
4040 wxPyEndAllowThreads(__tstate);
4041 if (PyErr_Occurred()) SWIG_fail;
4042 }
4043 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4044 return resultobj;
4045 fail:
4046 return NULL;
4047 }
4048
4049
4050 static PyObject *_wrap_new_BitmapFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4051 PyObject *resultobj;
4052 wxIcon *arg1 = 0 ;
4053 wxBitmap *result;
4054 PyObject * obj0 = 0 ;
4055 char *kwnames[] = {
4056 (char *) "icon", NULL
4057 };
4058
4059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromIcon",kwnames,&obj0)) goto fail;
4060 {
4061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4062 if (SWIG_arg_fail(1)) SWIG_fail;
4063 if (arg1 == NULL) {
4064 SWIG_null_ref("wxIcon");
4065 }
4066 if (SWIG_arg_fail(1)) SWIG_fail;
4067 }
4068 {
4069 if (!wxPyCheckForApp()) SWIG_fail;
4070 PyThreadState* __tstate = wxPyBeginAllowThreads();
4071 result = (wxBitmap *)new wxBitmap((wxIcon const &)*arg1);
4072
4073 wxPyEndAllowThreads(__tstate);
4074 if (PyErr_Occurred()) SWIG_fail;
4075 }
4076 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4077 return resultobj;
4078 fail:
4079 return NULL;
4080 }
4081
4082
4083 static PyObject *_wrap_new_BitmapFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
4084 PyObject *resultobj;
4085 wxImage *arg1 = 0 ;
4086 int arg2 = (int) -1 ;
4087 wxBitmap *result;
4088 PyObject * obj0 = 0 ;
4089 PyObject * obj1 = 0 ;
4090 char *kwnames[] = {
4091 (char *) "image",(char *) "depth", NULL
4092 };
4093
4094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BitmapFromImage",kwnames,&obj0,&obj1)) goto fail;
4095 {
4096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
4097 if (SWIG_arg_fail(1)) SWIG_fail;
4098 if (arg1 == NULL) {
4099 SWIG_null_ref("wxImage");
4100 }
4101 if (SWIG_arg_fail(1)) SWIG_fail;
4102 }
4103 if (obj1) {
4104 {
4105 arg2 = (int)(SWIG_As_int(obj1));
4106 if (SWIG_arg_fail(2)) SWIG_fail;
4107 }
4108 }
4109 {
4110 if (!wxPyCheckForApp()) SWIG_fail;
4111 PyThreadState* __tstate = wxPyBeginAllowThreads();
4112 result = (wxBitmap *)new wxBitmap((wxImage const &)*arg1,arg2);
4113
4114 wxPyEndAllowThreads(__tstate);
4115 if (PyErr_Occurred()) SWIG_fail;
4116 }
4117 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4118 return resultobj;
4119 fail:
4120 return NULL;
4121 }
4122
4123
4124 static PyObject *_wrap_new_BitmapFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
4125 PyObject *resultobj;
4126 PyObject *arg1 = (PyObject *) 0 ;
4127 wxBitmap *result;
4128 PyObject * obj0 = 0 ;
4129 char *kwnames[] = {
4130 (char *) "listOfStrings", NULL
4131 };
4132
4133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromXPMData",kwnames,&obj0)) goto fail;
4134 arg1 = obj0;
4135 {
4136 if (!wxPyCheckForApp()) SWIG_fail;
4137 PyThreadState* __tstate = wxPyBeginAllowThreads();
4138 result = (wxBitmap *)new_wxBitmap(arg1);
4139
4140 wxPyEndAllowThreads(__tstate);
4141 if (PyErr_Occurred()) SWIG_fail;
4142 }
4143 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4144 return resultobj;
4145 fail:
4146 return NULL;
4147 }
4148
4149
4150 static PyObject *_wrap_new_BitmapFromBits(PyObject *, PyObject *args, PyObject *kwargs) {
4151 PyObject *resultobj;
4152 PyObject *arg1 = (PyObject *) 0 ;
4153 int arg2 ;
4154 int arg3 ;
4155 int arg4 = (int) 1 ;
4156 wxBitmap *result;
4157 PyObject * obj0 = 0 ;
4158 PyObject * obj1 = 0 ;
4159 PyObject * obj2 = 0 ;
4160 PyObject * obj3 = 0 ;
4161 char *kwnames[] = {
4162 (char *) "bits",(char *) "width",(char *) "height",(char *) "depth", NULL
4163 };
4164
4165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:new_BitmapFromBits",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4166 arg1 = obj0;
4167 {
4168 arg2 = (int)(SWIG_As_int(obj1));
4169 if (SWIG_arg_fail(2)) SWIG_fail;
4170 }
4171 {
4172 arg3 = (int)(SWIG_As_int(obj2));
4173 if (SWIG_arg_fail(3)) SWIG_fail;
4174 }
4175 if (obj3) {
4176 {
4177 arg4 = (int)(SWIG_As_int(obj3));
4178 if (SWIG_arg_fail(4)) SWIG_fail;
4179 }
4180 }
4181 {
4182 if (!wxPyCheckForApp()) SWIG_fail;
4183 PyThreadState* __tstate = wxPyBeginAllowThreads();
4184 result = (wxBitmap *)new_wxBitmap(arg1,arg2,arg3,arg4);
4185
4186 wxPyEndAllowThreads(__tstate);
4187 if (PyErr_Occurred()) SWIG_fail;
4188 }
4189 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4190 return resultobj;
4191 fail:
4192 return NULL;
4193 }
4194
4195
4196 static PyObject *_wrap_Bitmap_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
4197 PyObject *resultobj;
4198 wxBitmap *arg1 = (wxBitmap *) 0 ;
4199 bool result;
4200 PyObject * obj0 = 0 ;
4201 char *kwnames[] = {
4202 (char *) "self", NULL
4203 };
4204
4205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_Ok",kwnames,&obj0)) goto fail;
4206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4207 if (SWIG_arg_fail(1)) SWIG_fail;
4208 {
4209 PyThreadState* __tstate = wxPyBeginAllowThreads();
4210 result = (bool)(arg1)->Ok();
4211
4212 wxPyEndAllowThreads(__tstate);
4213 if (PyErr_Occurred()) SWIG_fail;
4214 }
4215 {
4216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4217 }
4218 return resultobj;
4219 fail:
4220 return NULL;
4221 }
4222
4223
4224 static PyObject *_wrap_Bitmap_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4225 PyObject *resultobj;
4226 wxBitmap *arg1 = (wxBitmap *) 0 ;
4227 int result;
4228 PyObject * obj0 = 0 ;
4229 char *kwnames[] = {
4230 (char *) "self", NULL
4231 };
4232
4233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetWidth",kwnames,&obj0)) goto fail;
4234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4235 if (SWIG_arg_fail(1)) SWIG_fail;
4236 {
4237 PyThreadState* __tstate = wxPyBeginAllowThreads();
4238 result = (int)(arg1)->GetWidth();
4239
4240 wxPyEndAllowThreads(__tstate);
4241 if (PyErr_Occurred()) SWIG_fail;
4242 }
4243 {
4244 resultobj = SWIG_From_int((int)(result));
4245 }
4246 return resultobj;
4247 fail:
4248 return NULL;
4249 }
4250
4251
4252 static PyObject *_wrap_Bitmap_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4253 PyObject *resultobj;
4254 wxBitmap *arg1 = (wxBitmap *) 0 ;
4255 int result;
4256 PyObject * obj0 = 0 ;
4257 char *kwnames[] = {
4258 (char *) "self", NULL
4259 };
4260
4261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetHeight",kwnames,&obj0)) goto fail;
4262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4263 if (SWIG_arg_fail(1)) SWIG_fail;
4264 {
4265 PyThreadState* __tstate = wxPyBeginAllowThreads();
4266 result = (int)(arg1)->GetHeight();
4267
4268 wxPyEndAllowThreads(__tstate);
4269 if (PyErr_Occurred()) SWIG_fail;
4270 }
4271 {
4272 resultobj = SWIG_From_int((int)(result));
4273 }
4274 return resultobj;
4275 fail:
4276 return NULL;
4277 }
4278
4279
4280 static PyObject *_wrap_Bitmap_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4281 PyObject *resultobj;
4282 wxBitmap *arg1 = (wxBitmap *) 0 ;
4283 int result;
4284 PyObject * obj0 = 0 ;
4285 char *kwnames[] = {
4286 (char *) "self", NULL
4287 };
4288
4289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetDepth",kwnames,&obj0)) goto fail;
4290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4291 if (SWIG_arg_fail(1)) SWIG_fail;
4292 {
4293 PyThreadState* __tstate = wxPyBeginAllowThreads();
4294 result = (int)(arg1)->GetDepth();
4295
4296 wxPyEndAllowThreads(__tstate);
4297 if (PyErr_Occurred()) SWIG_fail;
4298 }
4299 {
4300 resultobj = SWIG_From_int((int)(result));
4301 }
4302 return resultobj;
4303 fail:
4304 return NULL;
4305 }
4306
4307
4308 static PyObject *_wrap_Bitmap_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4309 PyObject *resultobj;
4310 wxBitmap *arg1 = (wxBitmap *) 0 ;
4311 wxSize result;
4312 PyObject * obj0 = 0 ;
4313 char *kwnames[] = {
4314 (char *) "self", NULL
4315 };
4316
4317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetSize",kwnames,&obj0)) goto fail;
4318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4319 if (SWIG_arg_fail(1)) SWIG_fail;
4320 {
4321 PyThreadState* __tstate = wxPyBeginAllowThreads();
4322 result = wxBitmap_GetSize(arg1);
4323
4324 wxPyEndAllowThreads(__tstate);
4325 if (PyErr_Occurred()) SWIG_fail;
4326 }
4327 {
4328 wxSize * resultptr;
4329 resultptr = new wxSize((wxSize &)(result));
4330 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
4331 }
4332 return resultobj;
4333 fail:
4334 return NULL;
4335 }
4336
4337
4338 static PyObject *_wrap_Bitmap_ConvertToImage(PyObject *, PyObject *args, PyObject *kwargs) {
4339 PyObject *resultobj;
4340 wxBitmap *arg1 = (wxBitmap *) 0 ;
4341 SwigValueWrapper<wxImage > result;
4342 PyObject * obj0 = 0 ;
4343 char *kwnames[] = {
4344 (char *) "self", NULL
4345 };
4346
4347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_ConvertToImage",kwnames,&obj0)) goto fail;
4348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4349 if (SWIG_arg_fail(1)) SWIG_fail;
4350 {
4351 PyThreadState* __tstate = wxPyBeginAllowThreads();
4352 result = ((wxBitmap const *)arg1)->ConvertToImage();
4353
4354 wxPyEndAllowThreads(__tstate);
4355 if (PyErr_Occurred()) SWIG_fail;
4356 }
4357 {
4358 wxImage * resultptr;
4359 resultptr = new wxImage((wxImage &)(result));
4360 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
4361 }
4362 return resultobj;
4363 fail:
4364 return NULL;
4365 }
4366
4367
4368 static PyObject *_wrap_Bitmap_GetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4369 PyObject *resultobj;
4370 wxBitmap *arg1 = (wxBitmap *) 0 ;
4371 wxMask *result;
4372 PyObject * obj0 = 0 ;
4373 char *kwnames[] = {
4374 (char *) "self", NULL
4375 };
4376
4377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetMask",kwnames,&obj0)) goto fail;
4378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4379 if (SWIG_arg_fail(1)) SWIG_fail;
4380 {
4381 PyThreadState* __tstate = wxPyBeginAllowThreads();
4382 result = (wxMask *)((wxBitmap const *)arg1)->GetMask();
4383
4384 wxPyEndAllowThreads(__tstate);
4385 if (PyErr_Occurred()) SWIG_fail;
4386 }
4387 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 0);
4388 return resultobj;
4389 fail:
4390 return NULL;
4391 }
4392
4393
4394 static PyObject *_wrap_Bitmap_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4395 PyObject *resultobj;
4396 wxBitmap *arg1 = (wxBitmap *) 0 ;
4397 wxMask *arg2 = (wxMask *) 0 ;
4398 PyObject * obj0 = 0 ;
4399 PyObject * obj1 = 0 ;
4400 char *kwnames[] = {
4401 (char *) "self",(char *) "mask", NULL
4402 };
4403
4404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMask",kwnames,&obj0,&obj1)) goto fail;
4405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4406 if (SWIG_arg_fail(1)) SWIG_fail;
4407 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMask, SWIG_POINTER_EXCEPTION | 0);
4408 if (SWIG_arg_fail(2)) SWIG_fail;
4409 {
4410 PyThreadState* __tstate = wxPyBeginAllowThreads();
4411 (arg1)->SetMask(arg2);
4412
4413 wxPyEndAllowThreads(__tstate);
4414 if (PyErr_Occurred()) SWIG_fail;
4415 }
4416 Py_INCREF(Py_None); resultobj = Py_None;
4417 return resultobj;
4418 fail:
4419 return NULL;
4420 }
4421
4422
4423 static PyObject *_wrap_Bitmap_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
4424 PyObject *resultobj;
4425 wxBitmap *arg1 = (wxBitmap *) 0 ;
4426 wxColour *arg2 = 0 ;
4427 wxColour temp2 ;
4428 PyObject * obj0 = 0 ;
4429 PyObject * obj1 = 0 ;
4430 char *kwnames[] = {
4431 (char *) "self",(char *) "colour", NULL
4432 };
4433
4434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMaskColour",kwnames,&obj0,&obj1)) goto fail;
4435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4436 if (SWIG_arg_fail(1)) SWIG_fail;
4437 {
4438 arg2 = &temp2;
4439 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4440 }
4441 {
4442 PyThreadState* __tstate = wxPyBeginAllowThreads();
4443 wxBitmap_SetMaskColour(arg1,(wxColour const &)*arg2);
4444
4445 wxPyEndAllowThreads(__tstate);
4446 if (PyErr_Occurred()) SWIG_fail;
4447 }
4448 Py_INCREF(Py_None); resultobj = Py_None;
4449 return resultobj;
4450 fail:
4451 return NULL;
4452 }
4453
4454
4455 static PyObject *_wrap_Bitmap_GetSubBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4456 PyObject *resultobj;
4457 wxBitmap *arg1 = (wxBitmap *) 0 ;
4458 wxRect *arg2 = 0 ;
4459 SwigValueWrapper<wxBitmap > result;
4460 wxRect temp2 ;
4461 PyObject * obj0 = 0 ;
4462 PyObject * obj1 = 0 ;
4463 char *kwnames[] = {
4464 (char *) "self",(char *) "rect", NULL
4465 };
4466
4467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_GetSubBitmap",kwnames,&obj0,&obj1)) goto fail;
4468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4469 if (SWIG_arg_fail(1)) SWIG_fail;
4470 {
4471 arg2 = &temp2;
4472 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4473 }
4474 {
4475 PyThreadState* __tstate = wxPyBeginAllowThreads();
4476 result = ((wxBitmap const *)arg1)->GetSubBitmap((wxRect const &)*arg2);
4477
4478 wxPyEndAllowThreads(__tstate);
4479 if (PyErr_Occurred()) SWIG_fail;
4480 }
4481 {
4482 wxBitmap * resultptr;
4483 resultptr = new wxBitmap((wxBitmap &)(result));
4484 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
4485 }
4486 return resultobj;
4487 fail:
4488 return NULL;
4489 }
4490
4491
4492 static PyObject *_wrap_Bitmap_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
4493 PyObject *resultobj;
4494 wxBitmap *arg1 = (wxBitmap *) 0 ;
4495 wxString *arg2 = 0 ;
4496 wxBitmapType arg3 ;
4497 wxPalette *arg4 = (wxPalette *) NULL ;
4498 bool result;
4499 bool temp2 = false ;
4500 PyObject * obj0 = 0 ;
4501 PyObject * obj1 = 0 ;
4502 PyObject * obj2 = 0 ;
4503 PyObject * obj3 = 0 ;
4504 char *kwnames[] = {
4505 (char *) "self",(char *) "name",(char *) "type",(char *) "palette", NULL
4506 };
4507
4508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Bitmap_SaveFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4510 if (SWIG_arg_fail(1)) SWIG_fail;
4511 {
4512 arg2 = wxString_in_helper(obj1);
4513 if (arg2 == NULL) SWIG_fail;
4514 temp2 = true;
4515 }
4516 {
4517 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4518 if (SWIG_arg_fail(3)) SWIG_fail;
4519 }
4520 if (obj3) {
4521 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
4522 if (SWIG_arg_fail(4)) SWIG_fail;
4523 }
4524 {
4525 PyThreadState* __tstate = wxPyBeginAllowThreads();
4526 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxBitmapType )arg3,arg4);
4527
4528 wxPyEndAllowThreads(__tstate);
4529 if (PyErr_Occurred()) SWIG_fail;
4530 }
4531 {
4532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4533 }
4534 {
4535 if (temp2)
4536 delete arg2;
4537 }
4538 return resultobj;
4539 fail:
4540 {
4541 if (temp2)
4542 delete arg2;
4543 }
4544 return NULL;
4545 }
4546
4547
4548 static PyObject *_wrap_Bitmap_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
4549 PyObject *resultobj;
4550 wxBitmap *arg1 = (wxBitmap *) 0 ;
4551 wxString *arg2 = 0 ;
4552 wxBitmapType arg3 ;
4553 bool result;
4554 bool temp2 = false ;
4555 PyObject * obj0 = 0 ;
4556 PyObject * obj1 = 0 ;
4557 PyObject * obj2 = 0 ;
4558 char *kwnames[] = {
4559 (char *) "self",(char *) "name",(char *) "type", NULL
4560 };
4561
4562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Bitmap_LoadFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
4563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4564 if (SWIG_arg_fail(1)) SWIG_fail;
4565 {
4566 arg2 = wxString_in_helper(obj1);
4567 if (arg2 == NULL) SWIG_fail;
4568 temp2 = true;
4569 }
4570 {
4571 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4572 if (SWIG_arg_fail(3)) SWIG_fail;
4573 }
4574 {
4575 PyThreadState* __tstate = wxPyBeginAllowThreads();
4576 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxBitmapType )arg3);
4577
4578 wxPyEndAllowThreads(__tstate);
4579 if (PyErr_Occurred()) SWIG_fail;
4580 }
4581 {
4582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4583 }
4584 {
4585 if (temp2)
4586 delete arg2;
4587 }
4588 return resultobj;
4589 fail:
4590 {
4591 if (temp2)
4592 delete arg2;
4593 }
4594 return NULL;
4595 }
4596
4597
4598 static PyObject *_wrap_Bitmap_GetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
4599 PyObject *resultobj;
4600 wxBitmap *arg1 = (wxBitmap *) 0 ;
4601 wxPalette *result;
4602 PyObject * obj0 = 0 ;
4603 char *kwnames[] = {
4604 (char *) "self", NULL
4605 };
4606
4607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetPalette",kwnames,&obj0)) goto fail;
4608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4609 if (SWIG_arg_fail(1)) SWIG_fail;
4610 {
4611 PyThreadState* __tstate = wxPyBeginAllowThreads();
4612 result = (wxPalette *)((wxBitmap const *)arg1)->GetPalette();
4613
4614 wxPyEndAllowThreads(__tstate);
4615 if (PyErr_Occurred()) SWIG_fail;
4616 }
4617 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 0);
4618 return resultobj;
4619 fail:
4620 return NULL;
4621 }
4622
4623
4624 static PyObject *_wrap_Bitmap_CopyFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4625 PyObject *resultobj;
4626 wxBitmap *arg1 = (wxBitmap *) 0 ;
4627 wxIcon *arg2 = 0 ;
4628 bool result;
4629 PyObject * obj0 = 0 ;
4630 PyObject * obj1 = 0 ;
4631 char *kwnames[] = {
4632 (char *) "self",(char *) "icon", NULL
4633 };
4634
4635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_CopyFromIcon",kwnames,&obj0,&obj1)) goto fail;
4636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4637 if (SWIG_arg_fail(1)) SWIG_fail;
4638 {
4639 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4640 if (SWIG_arg_fail(2)) SWIG_fail;
4641 if (arg2 == NULL) {
4642 SWIG_null_ref("wxIcon");
4643 }
4644 if (SWIG_arg_fail(2)) SWIG_fail;
4645 }
4646 {
4647 PyThreadState* __tstate = wxPyBeginAllowThreads();
4648 result = (bool)(arg1)->CopyFromIcon((wxIcon const &)*arg2);
4649
4650 wxPyEndAllowThreads(__tstate);
4651 if (PyErr_Occurred()) SWIG_fail;
4652 }
4653 {
4654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4655 }
4656 return resultobj;
4657 fail:
4658 return NULL;
4659 }
4660
4661
4662 static PyObject *_wrap_Bitmap_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4663 PyObject *resultobj;
4664 wxBitmap *arg1 = (wxBitmap *) 0 ;
4665 int arg2 ;
4666 PyObject * obj0 = 0 ;
4667 PyObject * obj1 = 0 ;
4668 char *kwnames[] = {
4669 (char *) "self",(char *) "height", NULL
4670 };
4671
4672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetHeight",kwnames,&obj0,&obj1)) goto fail;
4673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4674 if (SWIG_arg_fail(1)) SWIG_fail;
4675 {
4676 arg2 = (int)(SWIG_As_int(obj1));
4677 if (SWIG_arg_fail(2)) SWIG_fail;
4678 }
4679 {
4680 PyThreadState* __tstate = wxPyBeginAllowThreads();
4681 (arg1)->SetHeight(arg2);
4682
4683 wxPyEndAllowThreads(__tstate);
4684 if (PyErr_Occurred()) SWIG_fail;
4685 }
4686 Py_INCREF(Py_None); resultobj = Py_None;
4687 return resultobj;
4688 fail:
4689 return NULL;
4690 }
4691
4692
4693 static PyObject *_wrap_Bitmap_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4694 PyObject *resultobj;
4695 wxBitmap *arg1 = (wxBitmap *) 0 ;
4696 int arg2 ;
4697 PyObject * obj0 = 0 ;
4698 PyObject * obj1 = 0 ;
4699 char *kwnames[] = {
4700 (char *) "self",(char *) "width", NULL
4701 };
4702
4703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetWidth",kwnames,&obj0,&obj1)) goto fail;
4704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4705 if (SWIG_arg_fail(1)) SWIG_fail;
4706 {
4707 arg2 = (int)(SWIG_As_int(obj1));
4708 if (SWIG_arg_fail(2)) SWIG_fail;
4709 }
4710 {
4711 PyThreadState* __tstate = wxPyBeginAllowThreads();
4712 (arg1)->SetWidth(arg2);
4713
4714 wxPyEndAllowThreads(__tstate);
4715 if (PyErr_Occurred()) SWIG_fail;
4716 }
4717 Py_INCREF(Py_None); resultobj = Py_None;
4718 return resultobj;
4719 fail:
4720 return NULL;
4721 }
4722
4723
4724 static PyObject *_wrap_Bitmap_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4725 PyObject *resultobj;
4726 wxBitmap *arg1 = (wxBitmap *) 0 ;
4727 int arg2 ;
4728 PyObject * obj0 = 0 ;
4729 PyObject * obj1 = 0 ;
4730 char *kwnames[] = {
4731 (char *) "self",(char *) "depth", NULL
4732 };
4733
4734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetDepth",kwnames,&obj0,&obj1)) goto fail;
4735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4736 if (SWIG_arg_fail(1)) SWIG_fail;
4737 {
4738 arg2 = (int)(SWIG_As_int(obj1));
4739 if (SWIG_arg_fail(2)) SWIG_fail;
4740 }
4741 {
4742 PyThreadState* __tstate = wxPyBeginAllowThreads();
4743 (arg1)->SetDepth(arg2);
4744
4745 wxPyEndAllowThreads(__tstate);
4746 if (PyErr_Occurred()) SWIG_fail;
4747 }
4748 Py_INCREF(Py_None); resultobj = Py_None;
4749 return resultobj;
4750 fail:
4751 return NULL;
4752 }
4753
4754
4755 static PyObject *_wrap_Bitmap_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4756 PyObject *resultobj;
4757 wxBitmap *arg1 = (wxBitmap *) 0 ;
4758 wxSize *arg2 = 0 ;
4759 wxSize temp2 ;
4760 PyObject * obj0 = 0 ;
4761 PyObject * obj1 = 0 ;
4762 char *kwnames[] = {
4763 (char *) "self",(char *) "size", NULL
4764 };
4765
4766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetSize",kwnames,&obj0,&obj1)) goto fail;
4767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4768 if (SWIG_arg_fail(1)) SWIG_fail;
4769 {
4770 arg2 = &temp2;
4771 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4772 }
4773 {
4774 PyThreadState* __tstate = wxPyBeginAllowThreads();
4775 wxBitmap_SetSize(arg1,(wxSize const &)*arg2);
4776
4777 wxPyEndAllowThreads(__tstate);
4778 if (PyErr_Occurred()) SWIG_fail;
4779 }
4780 Py_INCREF(Py_None); resultobj = Py_None;
4781 return resultobj;
4782 fail:
4783 return NULL;
4784 }
4785
4786
4787 static PyObject *_wrap_Bitmap___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4788 PyObject *resultobj;
4789 wxBitmap *arg1 = (wxBitmap *) 0 ;
4790 wxBitmap *arg2 = (wxBitmap *) 0 ;
4791 bool result;
4792 PyObject * obj0 = 0 ;
4793 PyObject * obj1 = 0 ;
4794 char *kwnames[] = {
4795 (char *) "self",(char *) "other", NULL
4796 };
4797
4798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___eq__",kwnames,&obj0,&obj1)) goto fail;
4799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4800 if (SWIG_arg_fail(1)) SWIG_fail;
4801 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4802 if (SWIG_arg_fail(2)) SWIG_fail;
4803 {
4804 PyThreadState* __tstate = wxPyBeginAllowThreads();
4805 result = (bool)wxBitmap___eq__(arg1,(wxBitmap const *)arg2);
4806
4807 wxPyEndAllowThreads(__tstate);
4808 if (PyErr_Occurred()) SWIG_fail;
4809 }
4810 {
4811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4812 }
4813 return resultobj;
4814 fail:
4815 return NULL;
4816 }
4817
4818
4819 static PyObject *_wrap_Bitmap___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4820 PyObject *resultobj;
4821 wxBitmap *arg1 = (wxBitmap *) 0 ;
4822 wxBitmap *arg2 = (wxBitmap *) 0 ;
4823 bool result;
4824 PyObject * obj0 = 0 ;
4825 PyObject * obj1 = 0 ;
4826 char *kwnames[] = {
4827 (char *) "self",(char *) "other", NULL
4828 };
4829
4830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___ne__",kwnames,&obj0,&obj1)) goto fail;
4831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4832 if (SWIG_arg_fail(1)) SWIG_fail;
4833 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4834 if (SWIG_arg_fail(2)) SWIG_fail;
4835 {
4836 PyThreadState* __tstate = wxPyBeginAllowThreads();
4837 result = (bool)wxBitmap___ne__(arg1,(wxBitmap const *)arg2);
4838
4839 wxPyEndAllowThreads(__tstate);
4840 if (PyErr_Occurred()) SWIG_fail;
4841 }
4842 {
4843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4844 }
4845 return resultobj;
4846 fail:
4847 return NULL;
4848 }
4849
4850
4851 static PyObject * Bitmap_swigregister(PyObject *, PyObject *args) {
4852 PyObject *obj;
4853 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4854 SWIG_TypeClientData(SWIGTYPE_p_wxBitmap, obj);
4855 Py_INCREF(obj);
4856 return Py_BuildValue((char *)"");
4857 }
4858 static PyObject *_wrap_new_Mask(PyObject *, PyObject *args, PyObject *kwargs) {
4859 PyObject *resultobj;
4860 wxBitmap *arg1 = 0 ;
4861 wxColour const &arg2_defvalue = wxNullColour ;
4862 wxColour *arg2 = (wxColour *) &arg2_defvalue ;
4863 wxMask *result;
4864 wxColour temp2 ;
4865 PyObject * obj0 = 0 ;
4866 PyObject * obj1 = 0 ;
4867 char *kwnames[] = {
4868 (char *) "bitmap",(char *) "colour", NULL
4869 };
4870
4871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Mask",kwnames,&obj0,&obj1)) goto fail;
4872 {
4873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4874 if (SWIG_arg_fail(1)) SWIG_fail;
4875 if (arg1 == NULL) {
4876 SWIG_null_ref("wxBitmap");
4877 }
4878 if (SWIG_arg_fail(1)) SWIG_fail;
4879 }
4880 if (obj1) {
4881 {
4882 arg2 = &temp2;
4883 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4884 }
4885 }
4886 {
4887 if (!wxPyCheckForApp()) SWIG_fail;
4888 PyThreadState* __tstate = wxPyBeginAllowThreads();
4889 result = (wxMask *)new_wxMask((wxBitmap const &)*arg1,(wxColour const &)*arg2);
4890
4891 wxPyEndAllowThreads(__tstate);
4892 if (PyErr_Occurred()) SWIG_fail;
4893 }
4894 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 1);
4895 return resultobj;
4896 fail:
4897 return NULL;
4898 }
4899
4900
4901 static PyObject * Mask_swigregister(PyObject *, PyObject *args) {
4902 PyObject *obj;
4903 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4904 SWIG_TypeClientData(SWIGTYPE_p_wxMask, obj);
4905 Py_INCREF(obj);
4906 return Py_BuildValue((char *)"");
4907 }
4908 static PyObject *_wrap_new_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
4909 PyObject *resultobj;
4910 wxString *arg1 = 0 ;
4911 wxBitmapType arg2 ;
4912 int arg3 = (int) -1 ;
4913 int arg4 = (int) -1 ;
4914 wxIcon *result;
4915 bool temp1 = false ;
4916 PyObject * obj0 = 0 ;
4917 PyObject * obj1 = 0 ;
4918 PyObject * obj2 = 0 ;
4919 PyObject * obj3 = 0 ;
4920 char *kwnames[] = {
4921 (char *) "name",(char *) "type",(char *) "desiredWidth",(char *) "desiredHeight", NULL
4922 };
4923
4924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Icon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4925 {
4926 arg1 = wxString_in_helper(obj0);
4927 if (arg1 == NULL) SWIG_fail;
4928 temp1 = true;
4929 }
4930 {
4931 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
4932 if (SWIG_arg_fail(2)) SWIG_fail;
4933 }
4934 if (obj2) {
4935 {
4936 arg3 = (int)(SWIG_As_int(obj2));
4937 if (SWIG_arg_fail(3)) SWIG_fail;
4938 }
4939 }
4940 if (obj3) {
4941 {
4942 arg4 = (int)(SWIG_As_int(obj3));
4943 if (SWIG_arg_fail(4)) SWIG_fail;
4944 }
4945 }
4946 {
4947 if (!wxPyCheckForApp()) SWIG_fail;
4948 PyThreadState* __tstate = wxPyBeginAllowThreads();
4949 result = (wxIcon *)new wxIcon((wxString const &)*arg1,(wxBitmapType )arg2,arg3,arg4);
4950
4951 wxPyEndAllowThreads(__tstate);
4952 if (PyErr_Occurred()) SWIG_fail;
4953 }
4954 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
4955 {
4956 if (temp1)
4957 delete arg1;
4958 }
4959 return resultobj;
4960 fail:
4961 {
4962 if (temp1)
4963 delete arg1;
4964 }
4965 return NULL;
4966 }
4967
4968
4969 static PyObject *_wrap_delete_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
4970 PyObject *resultobj;
4971 wxIcon *arg1 = (wxIcon *) 0 ;
4972 PyObject * obj0 = 0 ;
4973 char *kwnames[] = {
4974 (char *) "self", NULL
4975 };
4976
4977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Icon",kwnames,&obj0)) goto fail;
4978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4979 if (SWIG_arg_fail(1)) SWIG_fail;
4980 {
4981 PyThreadState* __tstate = wxPyBeginAllowThreads();
4982 delete arg1;
4983
4984 wxPyEndAllowThreads(__tstate);
4985 if (PyErr_Occurred()) SWIG_fail;
4986 }
4987 Py_INCREF(Py_None); resultobj = Py_None;
4988 return resultobj;
4989 fail:
4990 return NULL;
4991 }
4992
4993
4994 static PyObject *_wrap_new_EmptyIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4995 PyObject *resultobj;
4996 wxIcon *result;
4997 char *kwnames[] = {
4998 NULL
4999 };
5000
5001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EmptyIcon",kwnames)) goto fail;
5002 {
5003 if (!wxPyCheckForApp()) SWIG_fail;
5004 PyThreadState* __tstate = wxPyBeginAllowThreads();
5005 result = (wxIcon *)new wxIcon();
5006
5007 wxPyEndAllowThreads(__tstate);
5008 if (PyErr_Occurred()) SWIG_fail;
5009 }
5010 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5011 return resultobj;
5012 fail:
5013 return NULL;
5014 }
5015
5016
5017 static PyObject *_wrap_new_IconFromLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5018 PyObject *resultobj;
5019 wxIconLocation *arg1 = 0 ;
5020 wxIcon *result;
5021 PyObject * obj0 = 0 ;
5022 char *kwnames[] = {
5023 (char *) "loc", NULL
5024 };
5025
5026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromLocation",kwnames,&obj0)) goto fail;
5027 {
5028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5029 if (SWIG_arg_fail(1)) SWIG_fail;
5030 if (arg1 == NULL) {
5031 SWIG_null_ref("wxIconLocation");
5032 }
5033 if (SWIG_arg_fail(1)) SWIG_fail;
5034 }
5035 {
5036 if (!wxPyCheckForApp()) SWIG_fail;
5037 PyThreadState* __tstate = wxPyBeginAllowThreads();
5038 result = (wxIcon *)new wxIcon((wxIconLocation const &)*arg1);
5039
5040 wxPyEndAllowThreads(__tstate);
5041 if (PyErr_Occurred()) SWIG_fail;
5042 }
5043 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5044 return resultobj;
5045 fail:
5046 return NULL;
5047 }
5048
5049
5050 static PyObject *_wrap_new_IconFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5051 PyObject *resultobj;
5052 wxBitmap *arg1 = 0 ;
5053 wxIcon *result;
5054 PyObject * obj0 = 0 ;
5055 char *kwnames[] = {
5056 (char *) "bmp", NULL
5057 };
5058
5059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromBitmap",kwnames,&obj0)) goto fail;
5060 {
5061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5062 if (SWIG_arg_fail(1)) SWIG_fail;
5063 if (arg1 == NULL) {
5064 SWIG_null_ref("wxBitmap");
5065 }
5066 if (SWIG_arg_fail(1)) SWIG_fail;
5067 }
5068 {
5069 if (!wxPyCheckForApp()) SWIG_fail;
5070 PyThreadState* __tstate = wxPyBeginAllowThreads();
5071 result = (wxIcon *)new_wxIcon((wxBitmap const &)*arg1);
5072
5073 wxPyEndAllowThreads(__tstate);
5074 if (PyErr_Occurred()) SWIG_fail;
5075 }
5076 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5077 return resultobj;
5078 fail:
5079 return NULL;
5080 }
5081
5082
5083 static PyObject *_wrap_new_IconFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
5084 PyObject *resultobj;
5085 PyObject *arg1 = (PyObject *) 0 ;
5086 wxIcon *result;
5087 PyObject * obj0 = 0 ;
5088 char *kwnames[] = {
5089 (char *) "listOfStrings", NULL
5090 };
5091
5092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromXPMData",kwnames,&obj0)) goto fail;
5093 arg1 = obj0;
5094 {
5095 if (!wxPyCheckForApp()) SWIG_fail;
5096 PyThreadState* __tstate = wxPyBeginAllowThreads();
5097 result = (wxIcon *)new_wxIcon(arg1);
5098
5099 wxPyEndAllowThreads(__tstate);
5100 if (PyErr_Occurred()) SWIG_fail;
5101 }
5102 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5103 return resultobj;
5104 fail:
5105 return NULL;
5106 }
5107
5108
5109 static PyObject *_wrap_Icon_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
5110 PyObject *resultobj;
5111 wxIcon *arg1 = (wxIcon *) 0 ;
5112 wxString *arg2 = 0 ;
5113 wxBitmapType arg3 ;
5114 bool result;
5115 bool temp2 = false ;
5116 PyObject * obj0 = 0 ;
5117 PyObject * obj1 = 0 ;
5118 PyObject * obj2 = 0 ;
5119 char *kwnames[] = {
5120 (char *) "self",(char *) "name",(char *) "type", NULL
5121 };
5122
5123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Icon_LoadFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
5124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5125 if (SWIG_arg_fail(1)) SWIG_fail;
5126 {
5127 arg2 = wxString_in_helper(obj1);
5128 if (arg2 == NULL) SWIG_fail;
5129 temp2 = true;
5130 }
5131 {
5132 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
5133 if (SWIG_arg_fail(3)) SWIG_fail;
5134 }
5135 {
5136 PyThreadState* __tstate = wxPyBeginAllowThreads();
5137 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxBitmapType )arg3);
5138
5139 wxPyEndAllowThreads(__tstate);
5140 if (PyErr_Occurred()) SWIG_fail;
5141 }
5142 {
5143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5144 }
5145 {
5146 if (temp2)
5147 delete arg2;
5148 }
5149 return resultobj;
5150 fail:
5151 {
5152 if (temp2)
5153 delete arg2;
5154 }
5155 return NULL;
5156 }
5157
5158
5159 static PyObject *_wrap_Icon_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
5160 PyObject *resultobj;
5161 wxIcon *arg1 = (wxIcon *) 0 ;
5162 bool result;
5163 PyObject * obj0 = 0 ;
5164 char *kwnames[] = {
5165 (char *) "self", NULL
5166 };
5167
5168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_Ok",kwnames,&obj0)) goto fail;
5169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5170 if (SWIG_arg_fail(1)) SWIG_fail;
5171 {
5172 PyThreadState* __tstate = wxPyBeginAllowThreads();
5173 result = (bool)(arg1)->Ok();
5174
5175 wxPyEndAllowThreads(__tstate);
5176 if (PyErr_Occurred()) SWIG_fail;
5177 }
5178 {
5179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5180 }
5181 return resultobj;
5182 fail:
5183 return NULL;
5184 }
5185
5186
5187 static PyObject *_wrap_Icon_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5188 PyObject *resultobj;
5189 wxIcon *arg1 = (wxIcon *) 0 ;
5190 int result;
5191 PyObject * obj0 = 0 ;
5192 char *kwnames[] = {
5193 (char *) "self", NULL
5194 };
5195
5196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetWidth",kwnames,&obj0)) goto fail;
5197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5198 if (SWIG_arg_fail(1)) SWIG_fail;
5199 {
5200 PyThreadState* __tstate = wxPyBeginAllowThreads();
5201 result = (int)(arg1)->GetWidth();
5202
5203 wxPyEndAllowThreads(__tstate);
5204 if (PyErr_Occurred()) SWIG_fail;
5205 }
5206 {
5207 resultobj = SWIG_From_int((int)(result));
5208 }
5209 return resultobj;
5210 fail:
5211 return NULL;
5212 }
5213
5214
5215 static PyObject *_wrap_Icon_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5216 PyObject *resultobj;
5217 wxIcon *arg1 = (wxIcon *) 0 ;
5218 int result;
5219 PyObject * obj0 = 0 ;
5220 char *kwnames[] = {
5221 (char *) "self", NULL
5222 };
5223
5224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetHeight",kwnames,&obj0)) goto fail;
5225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5226 if (SWIG_arg_fail(1)) SWIG_fail;
5227 {
5228 PyThreadState* __tstate = wxPyBeginAllowThreads();
5229 result = (int)(arg1)->GetHeight();
5230
5231 wxPyEndAllowThreads(__tstate);
5232 if (PyErr_Occurred()) SWIG_fail;
5233 }
5234 {
5235 resultobj = SWIG_From_int((int)(result));
5236 }
5237 return resultobj;
5238 fail:
5239 return NULL;
5240 }
5241
5242
5243 static PyObject *_wrap_Icon_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5244 PyObject *resultobj;
5245 wxIcon *arg1 = (wxIcon *) 0 ;
5246 int result;
5247 PyObject * obj0 = 0 ;
5248 char *kwnames[] = {
5249 (char *) "self", NULL
5250 };
5251
5252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetDepth",kwnames,&obj0)) goto fail;
5253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5254 if (SWIG_arg_fail(1)) SWIG_fail;
5255 {
5256 PyThreadState* __tstate = wxPyBeginAllowThreads();
5257 result = (int)(arg1)->GetDepth();
5258
5259 wxPyEndAllowThreads(__tstate);
5260 if (PyErr_Occurred()) SWIG_fail;
5261 }
5262 {
5263 resultobj = SWIG_From_int((int)(result));
5264 }
5265 return resultobj;
5266 fail:
5267 return NULL;
5268 }
5269
5270
5271 static PyObject *_wrap_Icon_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5272 PyObject *resultobj;
5273 wxIcon *arg1 = (wxIcon *) 0 ;
5274 int arg2 ;
5275 PyObject * obj0 = 0 ;
5276 PyObject * obj1 = 0 ;
5277 char *kwnames[] = {
5278 (char *) "self",(char *) "w", NULL
5279 };
5280
5281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5283 if (SWIG_arg_fail(1)) SWIG_fail;
5284 {
5285 arg2 = (int)(SWIG_As_int(obj1));
5286 if (SWIG_arg_fail(2)) SWIG_fail;
5287 }
5288 {
5289 PyThreadState* __tstate = wxPyBeginAllowThreads();
5290 (arg1)->SetWidth(arg2);
5291
5292 wxPyEndAllowThreads(__tstate);
5293 if (PyErr_Occurred()) SWIG_fail;
5294 }
5295 Py_INCREF(Py_None); resultobj = Py_None;
5296 return resultobj;
5297 fail:
5298 return NULL;
5299 }
5300
5301
5302 static PyObject *_wrap_Icon_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5303 PyObject *resultobj;
5304 wxIcon *arg1 = (wxIcon *) 0 ;
5305 int arg2 ;
5306 PyObject * obj0 = 0 ;
5307 PyObject * obj1 = 0 ;
5308 char *kwnames[] = {
5309 (char *) "self",(char *) "h", NULL
5310 };
5311
5312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5314 if (SWIG_arg_fail(1)) SWIG_fail;
5315 {
5316 arg2 = (int)(SWIG_As_int(obj1));
5317 if (SWIG_arg_fail(2)) SWIG_fail;
5318 }
5319 {
5320 PyThreadState* __tstate = wxPyBeginAllowThreads();
5321 (arg1)->SetHeight(arg2);
5322
5323 wxPyEndAllowThreads(__tstate);
5324 if (PyErr_Occurred()) SWIG_fail;
5325 }
5326 Py_INCREF(Py_None); resultobj = Py_None;
5327 return resultobj;
5328 fail:
5329 return NULL;
5330 }
5331
5332
5333 static PyObject *_wrap_Icon_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5334 PyObject *resultobj;
5335 wxIcon *arg1 = (wxIcon *) 0 ;
5336 int arg2 ;
5337 PyObject * obj0 = 0 ;
5338 PyObject * obj1 = 0 ;
5339 char *kwnames[] = {
5340 (char *) "self",(char *) "d", NULL
5341 };
5342
5343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetDepth",kwnames,&obj0,&obj1)) goto fail;
5344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5345 if (SWIG_arg_fail(1)) SWIG_fail;
5346 {
5347 arg2 = (int)(SWIG_As_int(obj1));
5348 if (SWIG_arg_fail(2)) SWIG_fail;
5349 }
5350 {
5351 PyThreadState* __tstate = wxPyBeginAllowThreads();
5352 (arg1)->SetDepth(arg2);
5353
5354 wxPyEndAllowThreads(__tstate);
5355 if (PyErr_Occurred()) SWIG_fail;
5356 }
5357 Py_INCREF(Py_None); resultobj = Py_None;
5358 return resultobj;
5359 fail:
5360 return NULL;
5361 }
5362
5363
5364 static PyObject *_wrap_Icon_CopyFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5365 PyObject *resultobj;
5366 wxIcon *arg1 = (wxIcon *) 0 ;
5367 wxBitmap *arg2 = 0 ;
5368 PyObject * obj0 = 0 ;
5369 PyObject * obj1 = 0 ;
5370 char *kwnames[] = {
5371 (char *) "self",(char *) "bmp", NULL
5372 };
5373
5374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_CopyFromBitmap",kwnames,&obj0,&obj1)) goto fail;
5375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5376 if (SWIG_arg_fail(1)) SWIG_fail;
5377 {
5378 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5379 if (SWIG_arg_fail(2)) SWIG_fail;
5380 if (arg2 == NULL) {
5381 SWIG_null_ref("wxBitmap");
5382 }
5383 if (SWIG_arg_fail(2)) SWIG_fail;
5384 }
5385 {
5386 PyThreadState* __tstate = wxPyBeginAllowThreads();
5387 (arg1)->CopyFromBitmap((wxBitmap const &)*arg2);
5388
5389 wxPyEndAllowThreads(__tstate);
5390 if (PyErr_Occurred()) SWIG_fail;
5391 }
5392 Py_INCREF(Py_None); resultobj = Py_None;
5393 return resultobj;
5394 fail:
5395 return NULL;
5396 }
5397
5398
5399 static PyObject * Icon_swigregister(PyObject *, PyObject *args) {
5400 PyObject *obj;
5401 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5402 SWIG_TypeClientData(SWIGTYPE_p_wxIcon, obj);
5403 Py_INCREF(obj);
5404 return Py_BuildValue((char *)"");
5405 }
5406 static PyObject *_wrap_new_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5407 PyObject *resultobj;
5408 wxString *arg1 = (wxString *) &wxPyEmptyString ;
5409 int arg2 = (int) 0 ;
5410 wxIconLocation *result;
5411 bool temp1 = false ;
5412 PyObject * obj0 = 0 ;
5413 PyObject * obj1 = 0 ;
5414 char *kwnames[] = {
5415 (char *) "filename",(char *) "num", NULL
5416 };
5417
5418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconLocation",kwnames,&obj0,&obj1)) goto fail;
5419 if (obj0) {
5420 {
5421 arg1 = wxString_in_helper(obj0);
5422 if (arg1 == NULL) SWIG_fail;
5423 temp1 = true;
5424 }
5425 }
5426 if (obj1) {
5427 {
5428 arg2 = (int)(SWIG_As_int(obj1));
5429 if (SWIG_arg_fail(2)) SWIG_fail;
5430 }
5431 }
5432 {
5433 PyThreadState* __tstate = wxPyBeginAllowThreads();
5434 result = (wxIconLocation *)new_wxIconLocation((wxString const *)arg1,arg2);
5435
5436 wxPyEndAllowThreads(__tstate);
5437 if (PyErr_Occurred()) SWIG_fail;
5438 }
5439 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconLocation, 1);
5440 {
5441 if (temp1)
5442 delete arg1;
5443 }
5444 return resultobj;
5445 fail:
5446 {
5447 if (temp1)
5448 delete arg1;
5449 }
5450 return NULL;
5451 }
5452
5453
5454 static PyObject *_wrap_delete_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5455 PyObject *resultobj;
5456 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5457 PyObject * obj0 = 0 ;
5458 char *kwnames[] = {
5459 (char *) "self", NULL
5460 };
5461
5462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconLocation",kwnames,&obj0)) goto fail;
5463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5464 if (SWIG_arg_fail(1)) SWIG_fail;
5465 {
5466 PyThreadState* __tstate = wxPyBeginAllowThreads();
5467 delete arg1;
5468
5469 wxPyEndAllowThreads(__tstate);
5470 if (PyErr_Occurred()) SWIG_fail;
5471 }
5472 Py_INCREF(Py_None); resultobj = Py_None;
5473 return resultobj;
5474 fail:
5475 return NULL;
5476 }
5477
5478
5479 static PyObject *_wrap_IconLocation_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
5480 PyObject *resultobj;
5481 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5482 bool result;
5483 PyObject * obj0 = 0 ;
5484 char *kwnames[] = {
5485 (char *) "self", NULL
5486 };
5487
5488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_IsOk",kwnames,&obj0)) goto fail;
5489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5490 if (SWIG_arg_fail(1)) SWIG_fail;
5491 {
5492 PyThreadState* __tstate = wxPyBeginAllowThreads();
5493 result = (bool)((wxIconLocation const *)arg1)->IsOk();
5494
5495 wxPyEndAllowThreads(__tstate);
5496 if (PyErr_Occurred()) SWIG_fail;
5497 }
5498 {
5499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5500 }
5501 return resultobj;
5502 fail:
5503 return NULL;
5504 }
5505
5506
5507 static PyObject *_wrap_IconLocation_SetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5508 PyObject *resultobj;
5509 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5510 wxString *arg2 = 0 ;
5511 bool temp2 = false ;
5512 PyObject * obj0 = 0 ;
5513 PyObject * obj1 = 0 ;
5514 char *kwnames[] = {
5515 (char *) "self",(char *) "filename", NULL
5516 };
5517
5518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetFileName",kwnames,&obj0,&obj1)) goto fail;
5519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5520 if (SWIG_arg_fail(1)) SWIG_fail;
5521 {
5522 arg2 = wxString_in_helper(obj1);
5523 if (arg2 == NULL) SWIG_fail;
5524 temp2 = true;
5525 }
5526 {
5527 PyThreadState* __tstate = wxPyBeginAllowThreads();
5528 (arg1)->SetFileName((wxString const &)*arg2);
5529
5530 wxPyEndAllowThreads(__tstate);
5531 if (PyErr_Occurred()) SWIG_fail;
5532 }
5533 Py_INCREF(Py_None); resultobj = Py_None;
5534 {
5535 if (temp2)
5536 delete arg2;
5537 }
5538 return resultobj;
5539 fail:
5540 {
5541 if (temp2)
5542 delete arg2;
5543 }
5544 return NULL;
5545 }
5546
5547
5548 static PyObject *_wrap_IconLocation_GetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5549 PyObject *resultobj;
5550 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5551 wxString *result;
5552 PyObject * obj0 = 0 ;
5553 char *kwnames[] = {
5554 (char *) "self", NULL
5555 };
5556
5557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetFileName",kwnames,&obj0)) goto fail;
5558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5559 if (SWIG_arg_fail(1)) SWIG_fail;
5560 {
5561 PyThreadState* __tstate = wxPyBeginAllowThreads();
5562 {
5563 wxString const &_result_ref = ((wxIconLocation const *)arg1)->GetFileName();
5564 result = (wxString *) &_result_ref;
5565 }
5566
5567 wxPyEndAllowThreads(__tstate);
5568 if (PyErr_Occurred()) SWIG_fail;
5569 }
5570 {
5571 #if wxUSE_UNICODE
5572 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
5573 #else
5574 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
5575 #endif
5576 }
5577 return resultobj;
5578 fail:
5579 return NULL;
5580 }
5581
5582
5583 static PyObject *_wrap_IconLocation_SetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5584 PyObject *resultobj;
5585 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5586 int arg2 ;
5587 PyObject * obj0 = 0 ;
5588 PyObject * obj1 = 0 ;
5589 char *kwnames[] = {
5590 (char *) "self",(char *) "num", NULL
5591 };
5592
5593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetIndex",kwnames,&obj0,&obj1)) goto fail;
5594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5595 if (SWIG_arg_fail(1)) SWIG_fail;
5596 {
5597 arg2 = (int)(SWIG_As_int(obj1));
5598 if (SWIG_arg_fail(2)) SWIG_fail;
5599 }
5600 {
5601 PyThreadState* __tstate = wxPyBeginAllowThreads();
5602 wxIconLocation_SetIndex(arg1,arg2);
5603
5604 wxPyEndAllowThreads(__tstate);
5605 if (PyErr_Occurred()) SWIG_fail;
5606 }
5607 Py_INCREF(Py_None); resultobj = Py_None;
5608 return resultobj;
5609 fail:
5610 return NULL;
5611 }
5612
5613
5614 static PyObject *_wrap_IconLocation_GetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5615 PyObject *resultobj;
5616 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5617 int result;
5618 PyObject * obj0 = 0 ;
5619 char *kwnames[] = {
5620 (char *) "self", NULL
5621 };
5622
5623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetIndex",kwnames,&obj0)) goto fail;
5624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5625 if (SWIG_arg_fail(1)) SWIG_fail;
5626 {
5627 PyThreadState* __tstate = wxPyBeginAllowThreads();
5628 result = (int)wxIconLocation_GetIndex(arg1);
5629
5630 wxPyEndAllowThreads(__tstate);
5631 if (PyErr_Occurred()) SWIG_fail;
5632 }
5633 {
5634 resultobj = SWIG_From_int((int)(result));
5635 }
5636 return resultobj;
5637 fail:
5638 return NULL;
5639 }
5640
5641
5642 static PyObject * IconLocation_swigregister(PyObject *, PyObject *args) {
5643 PyObject *obj;
5644 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5645 SWIG_TypeClientData(SWIGTYPE_p_wxIconLocation, obj);
5646 Py_INCREF(obj);
5647 return Py_BuildValue((char *)"");
5648 }
5649 static PyObject *_wrap_new_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
5650 PyObject *resultobj;
5651 wxIconBundle *result;
5652 char *kwnames[] = {
5653 NULL
5654 };
5655
5656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IconBundle",kwnames)) goto fail;
5657 {
5658 PyThreadState* __tstate = wxPyBeginAllowThreads();
5659 result = (wxIconBundle *)new wxIconBundle();
5660
5661 wxPyEndAllowThreads(__tstate);
5662 if (PyErr_Occurred()) SWIG_fail;
5663 }
5664 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5665 return resultobj;
5666 fail:
5667 return NULL;
5668 }
5669
5670
5671 static PyObject *_wrap_new_IconBundleFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
5672 PyObject *resultobj;
5673 wxString *arg1 = 0 ;
5674 long arg2 ;
5675 wxIconBundle *result;
5676 bool temp1 = false ;
5677 PyObject * obj0 = 0 ;
5678 PyObject * obj1 = 0 ;
5679 char *kwnames[] = {
5680 (char *) "file",(char *) "type", NULL
5681 };
5682
5683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_IconBundleFromFile",kwnames,&obj0,&obj1)) goto fail;
5684 {
5685 arg1 = wxString_in_helper(obj0);
5686 if (arg1 == NULL) SWIG_fail;
5687 temp1 = true;
5688 }
5689 {
5690 arg2 = (long)(SWIG_As_long(obj1));
5691 if (SWIG_arg_fail(2)) SWIG_fail;
5692 }
5693 {
5694 PyThreadState* __tstate = wxPyBeginAllowThreads();
5695 result = (wxIconBundle *)new wxIconBundle((wxString const &)*arg1,arg2);
5696
5697 wxPyEndAllowThreads(__tstate);
5698 if (PyErr_Occurred()) SWIG_fail;
5699 }
5700 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5701 {
5702 if (temp1)
5703 delete arg1;
5704 }
5705 return resultobj;
5706 fail:
5707 {
5708 if (temp1)
5709 delete arg1;
5710 }
5711 return NULL;
5712 }
5713
5714
5715 static PyObject *_wrap_new_IconBundleFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5716 PyObject *resultobj;
5717 wxIcon *arg1 = 0 ;
5718 wxIconBundle *result;
5719 PyObject * obj0 = 0 ;
5720 char *kwnames[] = {
5721 (char *) "icon", NULL
5722 };
5723
5724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconBundleFromIcon",kwnames,&obj0)) goto fail;
5725 {
5726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5727 if (SWIG_arg_fail(1)) SWIG_fail;
5728 if (arg1 == NULL) {
5729 SWIG_null_ref("wxIcon");
5730 }
5731 if (SWIG_arg_fail(1)) SWIG_fail;
5732 }
5733 {
5734 PyThreadState* __tstate = wxPyBeginAllowThreads();
5735 result = (wxIconBundle *)new wxIconBundle((wxIcon const &)*arg1);
5736
5737 wxPyEndAllowThreads(__tstate);
5738 if (PyErr_Occurred()) SWIG_fail;
5739 }
5740 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5741 return resultobj;
5742 fail:
5743 return NULL;
5744 }
5745
5746
5747 static PyObject *_wrap_delete_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
5748 PyObject *resultobj;
5749 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5750 PyObject * obj0 = 0 ;
5751 char *kwnames[] = {
5752 (char *) "self", NULL
5753 };
5754
5755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconBundle",kwnames,&obj0)) goto fail;
5756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5757 if (SWIG_arg_fail(1)) SWIG_fail;
5758 {
5759 PyThreadState* __tstate = wxPyBeginAllowThreads();
5760 delete arg1;
5761
5762 wxPyEndAllowThreads(__tstate);
5763 if (PyErr_Occurred()) SWIG_fail;
5764 }
5765 Py_INCREF(Py_None); resultobj = Py_None;
5766 return resultobj;
5767 fail:
5768 return NULL;
5769 }
5770
5771
5772 static PyObject *_wrap_IconBundle_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5773 PyObject *resultobj;
5774 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5775 wxIcon *arg2 = 0 ;
5776 PyObject * obj0 = 0 ;
5777 PyObject * obj1 = 0 ;
5778 char *kwnames[] = {
5779 (char *) "self",(char *) "icon", NULL
5780 };
5781
5782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_AddIcon",kwnames,&obj0,&obj1)) goto fail;
5783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5784 if (SWIG_arg_fail(1)) SWIG_fail;
5785 {
5786 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5787 if (SWIG_arg_fail(2)) SWIG_fail;
5788 if (arg2 == NULL) {
5789 SWIG_null_ref("wxIcon");
5790 }
5791 if (SWIG_arg_fail(2)) SWIG_fail;
5792 }
5793 {
5794 PyThreadState* __tstate = wxPyBeginAllowThreads();
5795 (arg1)->AddIcon((wxIcon const &)*arg2);
5796
5797 wxPyEndAllowThreads(__tstate);
5798 if (PyErr_Occurred()) SWIG_fail;
5799 }
5800 Py_INCREF(Py_None); resultobj = Py_None;
5801 return resultobj;
5802 fail:
5803 return NULL;
5804 }
5805
5806
5807 static PyObject *_wrap_IconBundle_AddIconFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
5808 PyObject *resultobj;
5809 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5810 wxString *arg2 = 0 ;
5811 long arg3 ;
5812 bool temp2 = false ;
5813 PyObject * obj0 = 0 ;
5814 PyObject * obj1 = 0 ;
5815 PyObject * obj2 = 0 ;
5816 char *kwnames[] = {
5817 (char *) "self",(char *) "file",(char *) "type", NULL
5818 };
5819
5820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IconBundle_AddIconFromFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
5821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5822 if (SWIG_arg_fail(1)) SWIG_fail;
5823 {
5824 arg2 = wxString_in_helper(obj1);
5825 if (arg2 == NULL) SWIG_fail;
5826 temp2 = true;
5827 }
5828 {
5829 arg3 = (long)(SWIG_As_long(obj2));
5830 if (SWIG_arg_fail(3)) SWIG_fail;
5831 }
5832 {
5833 PyThreadState* __tstate = wxPyBeginAllowThreads();
5834 (arg1)->AddIcon((wxString const &)*arg2,arg3);
5835
5836 wxPyEndAllowThreads(__tstate);
5837 if (PyErr_Occurred()) SWIG_fail;
5838 }
5839 Py_INCREF(Py_None); resultobj = Py_None;
5840 {
5841 if (temp2)
5842 delete arg2;
5843 }
5844 return resultobj;
5845 fail:
5846 {
5847 if (temp2)
5848 delete arg2;
5849 }
5850 return NULL;
5851 }
5852
5853
5854 static PyObject *_wrap_IconBundle_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5855 PyObject *resultobj;
5856 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5857 wxSize *arg2 = 0 ;
5858 wxIcon *result;
5859 wxSize temp2 ;
5860 PyObject * obj0 = 0 ;
5861 PyObject * obj1 = 0 ;
5862 char *kwnames[] = {
5863 (char *) "self",(char *) "size", NULL
5864 };
5865
5866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_GetIcon",kwnames,&obj0,&obj1)) goto fail;
5867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5868 if (SWIG_arg_fail(1)) SWIG_fail;
5869 {
5870 arg2 = &temp2;
5871 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5872 }
5873 {
5874 PyThreadState* __tstate = wxPyBeginAllowThreads();
5875 {
5876 wxIcon const &_result_ref = ((wxIconBundle const *)arg1)->GetIcon((wxSize const &)*arg2);
5877 result = (wxIcon *) &_result_ref;
5878 }
5879
5880 wxPyEndAllowThreads(__tstate);
5881 if (PyErr_Occurred()) SWIG_fail;
5882 }
5883 {
5884 wxIcon* resultptr = new wxIcon(*result);
5885 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxIcon, 1);
5886 }
5887 return resultobj;
5888 fail:
5889 return NULL;
5890 }
5891
5892
5893 static PyObject * IconBundle_swigregister(PyObject *, PyObject *args) {
5894 PyObject *obj;
5895 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5896 SWIG_TypeClientData(SWIGTYPE_p_wxIconBundle, obj);
5897 Py_INCREF(obj);
5898 return Py_BuildValue((char *)"");
5899 }
5900 static PyObject *_wrap_new_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
5901 PyObject *resultobj;
5902 wxString *arg1 = 0 ;
5903 long arg2 ;
5904 int arg3 = (int) 0 ;
5905 int arg4 = (int) 0 ;
5906 wxCursor *result;
5907 bool temp1 = false ;
5908 PyObject * obj0 = 0 ;
5909 PyObject * obj1 = 0 ;
5910 PyObject * obj2 = 0 ;
5911 PyObject * obj3 = 0 ;
5912 char *kwnames[] = {
5913 (char *) "cursorName",(char *) "type",(char *) "hotSpotX",(char *) "hotSpotY", NULL
5914 };
5915
5916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Cursor",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5917 {
5918 arg1 = wxString_in_helper(obj0);
5919 if (arg1 == NULL) SWIG_fail;
5920 temp1 = true;
5921 }
5922 {
5923 arg2 = (long)(SWIG_As_long(obj1));
5924 if (SWIG_arg_fail(2)) SWIG_fail;
5925 }
5926 if (obj2) {
5927 {
5928 arg3 = (int)(SWIG_As_int(obj2));
5929 if (SWIG_arg_fail(3)) SWIG_fail;
5930 }
5931 }
5932 if (obj3) {
5933 {
5934 arg4 = (int)(SWIG_As_int(obj3));
5935 if (SWIG_arg_fail(4)) SWIG_fail;
5936 }
5937 }
5938 {
5939 if (!wxPyCheckForApp()) SWIG_fail;
5940 PyThreadState* __tstate = wxPyBeginAllowThreads();
5941 result = (wxCursor *)new_wxCursor((wxString const &)*arg1,arg2,arg3,arg4);
5942
5943 wxPyEndAllowThreads(__tstate);
5944 if (PyErr_Occurred()) SWIG_fail;
5945 }
5946 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
5947 {
5948 if (temp1)
5949 delete arg1;
5950 }
5951 return resultobj;
5952 fail:
5953 {
5954 if (temp1)
5955 delete arg1;
5956 }
5957 return NULL;
5958 }
5959
5960
5961 static PyObject *_wrap_delete_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
5962 PyObject *resultobj;
5963 wxCursor *arg1 = (wxCursor *) 0 ;
5964 PyObject * obj0 = 0 ;
5965 char *kwnames[] = {
5966 (char *) "self", NULL
5967 };
5968
5969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Cursor",kwnames,&obj0)) goto fail;
5970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5971 if (SWIG_arg_fail(1)) SWIG_fail;
5972 {
5973 PyThreadState* __tstate = wxPyBeginAllowThreads();
5974 delete arg1;
5975
5976 wxPyEndAllowThreads(__tstate);
5977 if (PyErr_Occurred()) SWIG_fail;
5978 }
5979 Py_INCREF(Py_None); resultobj = Py_None;
5980 return resultobj;
5981 fail:
5982 return NULL;
5983 }
5984
5985
5986 static PyObject *_wrap_new_StockCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5987 PyObject *resultobj;
5988 int arg1 ;
5989 wxCursor *result;
5990 PyObject * obj0 = 0 ;
5991 char *kwnames[] = {
5992 (char *) "id", NULL
5993 };
5994
5995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_StockCursor",kwnames,&obj0)) goto fail;
5996 {
5997 arg1 = (int)(SWIG_As_int(obj0));
5998 if (SWIG_arg_fail(1)) SWIG_fail;
5999 }
6000 {
6001 if (!wxPyCheckForApp()) SWIG_fail;
6002 PyThreadState* __tstate = wxPyBeginAllowThreads();
6003 result = (wxCursor *)new wxCursor(arg1);
6004
6005 wxPyEndAllowThreads(__tstate);
6006 if (PyErr_Occurred()) SWIG_fail;
6007 }
6008 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6009 return resultobj;
6010 fail:
6011 return NULL;
6012 }
6013
6014
6015 static PyObject *_wrap_new_CursorFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
6016 PyObject *resultobj;
6017 wxImage *arg1 = 0 ;
6018 wxCursor *result;
6019 PyObject * obj0 = 0 ;
6020 char *kwnames[] = {
6021 (char *) "image", NULL
6022 };
6023
6024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CursorFromImage",kwnames,&obj0)) goto fail;
6025 {
6026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
6027 if (SWIG_arg_fail(1)) SWIG_fail;
6028 if (arg1 == NULL) {
6029 SWIG_null_ref("wxImage");
6030 }
6031 if (SWIG_arg_fail(1)) SWIG_fail;
6032 }
6033 {
6034 if (!wxPyCheckForApp()) SWIG_fail;
6035 PyThreadState* __tstate = wxPyBeginAllowThreads();
6036 result = (wxCursor *)new wxCursor((wxImage const &)*arg1);
6037
6038 wxPyEndAllowThreads(__tstate);
6039 if (PyErr_Occurred()) SWIG_fail;
6040 }
6041 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6042 return resultobj;
6043 fail:
6044 return NULL;
6045 }
6046
6047
6048 static PyObject *_wrap_Cursor_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
6049 PyObject *resultobj;
6050 wxCursor *arg1 = (wxCursor *) 0 ;
6051 bool result;
6052 PyObject * obj0 = 0 ;
6053 char *kwnames[] = {
6054 (char *) "self", NULL
6055 };
6056
6057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_Ok",kwnames,&obj0)) goto fail;
6058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6059 if (SWIG_arg_fail(1)) SWIG_fail;
6060 {
6061 PyThreadState* __tstate = wxPyBeginAllowThreads();
6062 result = (bool)(arg1)->Ok();
6063
6064 wxPyEndAllowThreads(__tstate);
6065 if (PyErr_Occurred()) SWIG_fail;
6066 }
6067 {
6068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6069 }
6070 return resultobj;
6071 fail:
6072 return NULL;
6073 }
6074
6075
6076 static PyObject * Cursor_swigregister(PyObject *, PyObject *args) {
6077 PyObject *obj;
6078 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6079 SWIG_TypeClientData(SWIGTYPE_p_wxCursor, obj);
6080 Py_INCREF(obj);
6081 return Py_BuildValue((char *)"");
6082 }
6083 static PyObject *_wrap_new_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6084 PyObject *resultobj;
6085 int arg1 = (int) 0 ;
6086 int arg2 = (int) 0 ;
6087 int arg3 = (int) 0 ;
6088 int arg4 = (int) 0 ;
6089 wxRegion *result;
6090 PyObject * obj0 = 0 ;
6091 PyObject * obj1 = 0 ;
6092 PyObject * obj2 = 0 ;
6093 PyObject * obj3 = 0 ;
6094 char *kwnames[] = {
6095 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6096 };
6097
6098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Region",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6099 if (obj0) {
6100 {
6101 arg1 = (int)(SWIG_As_int(obj0));
6102 if (SWIG_arg_fail(1)) SWIG_fail;
6103 }
6104 }
6105 if (obj1) {
6106 {
6107 arg2 = (int)(SWIG_As_int(obj1));
6108 if (SWIG_arg_fail(2)) SWIG_fail;
6109 }
6110 }
6111 if (obj2) {
6112 {
6113 arg3 = (int)(SWIG_As_int(obj2));
6114 if (SWIG_arg_fail(3)) SWIG_fail;
6115 }
6116 }
6117 if (obj3) {
6118 {
6119 arg4 = (int)(SWIG_As_int(obj3));
6120 if (SWIG_arg_fail(4)) SWIG_fail;
6121 }
6122 }
6123 {
6124 if (!wxPyCheckForApp()) SWIG_fail;
6125 PyThreadState* __tstate = wxPyBeginAllowThreads();
6126 result = (wxRegion *)new wxRegion(arg1,arg2,arg3,arg4);
6127
6128 wxPyEndAllowThreads(__tstate);
6129 if (PyErr_Occurred()) SWIG_fail;
6130 }
6131 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6132 return resultobj;
6133 fail:
6134 return NULL;
6135 }
6136
6137
6138 static PyObject *_wrap_new_RegionFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
6139 PyObject *resultobj;
6140 wxBitmap *arg1 = 0 ;
6141 wxRegion *result;
6142 PyObject * obj0 = 0 ;
6143 char *kwnames[] = {
6144 (char *) "bmp", NULL
6145 };
6146
6147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionFromBitmap",kwnames,&obj0)) goto fail;
6148 {
6149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6150 if (SWIG_arg_fail(1)) SWIG_fail;
6151 if (arg1 == NULL) {
6152 SWIG_null_ref("wxBitmap");
6153 }
6154 if (SWIG_arg_fail(1)) SWIG_fail;
6155 }
6156 {
6157 if (!wxPyCheckForApp()) SWIG_fail;
6158 PyThreadState* __tstate = wxPyBeginAllowThreads();
6159 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1);
6160
6161 wxPyEndAllowThreads(__tstate);
6162 if (PyErr_Occurred()) SWIG_fail;
6163 }
6164 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6165 return resultobj;
6166 fail:
6167 return NULL;
6168 }
6169
6170
6171 static PyObject *_wrap_new_RegionFromBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
6172 PyObject *resultobj;
6173 wxBitmap *arg1 = 0 ;
6174 wxColour *arg2 = 0 ;
6175 int arg3 = (int) 0 ;
6176 wxRegion *result;
6177 wxColour temp2 ;
6178 PyObject * obj0 = 0 ;
6179 PyObject * obj1 = 0 ;
6180 PyObject * obj2 = 0 ;
6181 char *kwnames[] = {
6182 (char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
6183 };
6184
6185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_RegionFromBitmapColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
6186 {
6187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6188 if (SWIG_arg_fail(1)) SWIG_fail;
6189 if (arg1 == NULL) {
6190 SWIG_null_ref("wxBitmap");
6191 }
6192 if (SWIG_arg_fail(1)) SWIG_fail;
6193 }
6194 {
6195 arg2 = &temp2;
6196 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6197 }
6198 if (obj2) {
6199 {
6200 arg3 = (int)(SWIG_As_int(obj2));
6201 if (SWIG_arg_fail(3)) SWIG_fail;
6202 }
6203 }
6204 {
6205 if (!wxPyCheckForApp()) SWIG_fail;
6206 PyThreadState* __tstate = wxPyBeginAllowThreads();
6207 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1,(wxColour const &)*arg2,arg3);
6208
6209 wxPyEndAllowThreads(__tstate);
6210 if (PyErr_Occurred()) SWIG_fail;
6211 }
6212 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6213 return resultobj;
6214 fail:
6215 return NULL;
6216 }
6217
6218
6219 static PyObject *_wrap_new_RegionFromPoints(PyObject *, PyObject *args, PyObject *kwargs) {
6220 PyObject *resultobj;
6221 int arg1 ;
6222 wxPoint *arg2 = (wxPoint *) 0 ;
6223 int arg3 = (int) wxWINDING_RULE ;
6224 wxRegion *result;
6225 PyObject * obj0 = 0 ;
6226 PyObject * obj1 = 0 ;
6227 char *kwnames[] = {
6228 (char *) "points",(char *) "fillStyle", NULL
6229 };
6230
6231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_RegionFromPoints",kwnames,&obj0,&obj1)) goto fail;
6232 {
6233 arg2 = wxPoint_LIST_helper(obj0, &arg1);
6234 if (arg2 == NULL) SWIG_fail;
6235 }
6236 if (obj1) {
6237 {
6238 arg3 = (int)(SWIG_As_int(obj1));
6239 if (SWIG_arg_fail(3)) SWIG_fail;
6240 }
6241 }
6242 {
6243 if (!wxPyCheckForApp()) SWIG_fail;
6244 PyThreadState* __tstate = wxPyBeginAllowThreads();
6245 result = (wxRegion *)new wxRegion(arg1,arg2,arg3);
6246
6247 wxPyEndAllowThreads(__tstate);
6248 if (PyErr_Occurred()) SWIG_fail;
6249 }
6250 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6251 {
6252 if (arg2) delete [] arg2;
6253 }
6254 return resultobj;
6255 fail:
6256 {
6257 if (arg2) delete [] arg2;
6258 }
6259 return NULL;
6260 }
6261
6262
6263 static PyObject *_wrap_delete_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6264 PyObject *resultobj;
6265 wxRegion *arg1 = (wxRegion *) 0 ;
6266 PyObject * obj0 = 0 ;
6267 char *kwnames[] = {
6268 (char *) "self", NULL
6269 };
6270
6271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Region",kwnames,&obj0)) goto fail;
6272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6273 if (SWIG_arg_fail(1)) SWIG_fail;
6274 {
6275 PyThreadState* __tstate = wxPyBeginAllowThreads();
6276 delete arg1;
6277
6278 wxPyEndAllowThreads(__tstate);
6279 if (PyErr_Occurred()) SWIG_fail;
6280 }
6281 Py_INCREF(Py_None); resultobj = Py_None;
6282 return resultobj;
6283 fail:
6284 return NULL;
6285 }
6286
6287
6288 static PyObject *_wrap_Region_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
6289 PyObject *resultobj;
6290 wxRegion *arg1 = (wxRegion *) 0 ;
6291 PyObject * obj0 = 0 ;
6292 char *kwnames[] = {
6293 (char *) "self", NULL
6294 };
6295
6296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_Clear",kwnames,&obj0)) goto fail;
6297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6298 if (SWIG_arg_fail(1)) SWIG_fail;
6299 {
6300 PyThreadState* __tstate = wxPyBeginAllowThreads();
6301 (arg1)->Clear();
6302
6303 wxPyEndAllowThreads(__tstate);
6304 if (PyErr_Occurred()) SWIG_fail;
6305 }
6306 Py_INCREF(Py_None); resultobj = Py_None;
6307 return resultobj;
6308 fail:
6309 return NULL;
6310 }
6311
6312
6313 static PyObject *_wrap_Region_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
6314 PyObject *resultobj;
6315 wxRegion *arg1 = (wxRegion *) 0 ;
6316 int arg2 ;
6317 int arg3 ;
6318 bool result;
6319 PyObject * obj0 = 0 ;
6320 PyObject * obj1 = 0 ;
6321 PyObject * obj2 = 0 ;
6322 char *kwnames[] = {
6323 (char *) "self",(char *) "x",(char *) "y", NULL
6324 };
6325
6326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Offset",kwnames,&obj0,&obj1,&obj2)) goto fail;
6327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6328 if (SWIG_arg_fail(1)) SWIG_fail;
6329 {
6330 arg2 = (int)(SWIG_As_int(obj1));
6331 if (SWIG_arg_fail(2)) SWIG_fail;
6332 }
6333 {
6334 arg3 = (int)(SWIG_As_int(obj2));
6335 if (SWIG_arg_fail(3)) SWIG_fail;
6336 }
6337 {
6338 PyThreadState* __tstate = wxPyBeginAllowThreads();
6339 result = (bool)(arg1)->Offset(arg2,arg3);
6340
6341 wxPyEndAllowThreads(__tstate);
6342 if (PyErr_Occurred()) SWIG_fail;
6343 }
6344 {
6345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6346 }
6347 return resultobj;
6348 fail:
6349 return NULL;
6350 }
6351
6352
6353 static PyObject *_wrap_Region_Contains(PyObject *, PyObject *args, PyObject *kwargs) {
6354 PyObject *resultobj;
6355 wxRegion *arg1 = (wxRegion *) 0 ;
6356 int arg2 ;
6357 int arg3 ;
6358 wxRegionContain result;
6359 PyObject * obj0 = 0 ;
6360 PyObject * obj1 = 0 ;
6361 PyObject * obj2 = 0 ;
6362 char *kwnames[] = {
6363 (char *) "self",(char *) "x",(char *) "y", NULL
6364 };
6365
6366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Contains",kwnames,&obj0,&obj1,&obj2)) goto fail;
6367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6368 if (SWIG_arg_fail(1)) SWIG_fail;
6369 {
6370 arg2 = (int)(SWIG_As_int(obj1));
6371 if (SWIG_arg_fail(2)) SWIG_fail;
6372 }
6373 {
6374 arg3 = (int)(SWIG_As_int(obj2));
6375 if (SWIG_arg_fail(3)) SWIG_fail;
6376 }
6377 {
6378 PyThreadState* __tstate = wxPyBeginAllowThreads();
6379 result = (wxRegionContain)(arg1)->Contains(arg2,arg3);
6380
6381 wxPyEndAllowThreads(__tstate);
6382 if (PyErr_Occurred()) SWIG_fail;
6383 }
6384 resultobj = SWIG_From_int((result));
6385 return resultobj;
6386 fail:
6387 return NULL;
6388 }
6389
6390
6391 static PyObject *_wrap_Region_ContainsPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6392 PyObject *resultobj;
6393 wxRegion *arg1 = (wxRegion *) 0 ;
6394 wxPoint *arg2 = 0 ;
6395 wxRegionContain result;
6396 wxPoint temp2 ;
6397 PyObject * obj0 = 0 ;
6398 PyObject * obj1 = 0 ;
6399 char *kwnames[] = {
6400 (char *) "self",(char *) "pt", NULL
6401 };
6402
6403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsPoint",kwnames,&obj0,&obj1)) goto fail;
6404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6405 if (SWIG_arg_fail(1)) SWIG_fail;
6406 {
6407 arg2 = &temp2;
6408 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6409 }
6410 {
6411 PyThreadState* __tstate = wxPyBeginAllowThreads();
6412 result = (wxRegionContain)(arg1)->Contains((wxPoint const &)*arg2);
6413
6414 wxPyEndAllowThreads(__tstate);
6415 if (PyErr_Occurred()) SWIG_fail;
6416 }
6417 resultobj = SWIG_From_int((result));
6418 return resultobj;
6419 fail:
6420 return NULL;
6421 }
6422
6423
6424 static PyObject *_wrap_Region_ContainsRect(PyObject *, PyObject *args, PyObject *kwargs) {
6425 PyObject *resultobj;
6426 wxRegion *arg1 = (wxRegion *) 0 ;
6427 wxRect *arg2 = 0 ;
6428 wxRegionContain result;
6429 wxRect temp2 ;
6430 PyObject * obj0 = 0 ;
6431 PyObject * obj1 = 0 ;
6432 char *kwnames[] = {
6433 (char *) "self",(char *) "rect", NULL
6434 };
6435
6436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsRect",kwnames,&obj0,&obj1)) goto fail;
6437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6438 if (SWIG_arg_fail(1)) SWIG_fail;
6439 {
6440 arg2 = &temp2;
6441 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6442 }
6443 {
6444 PyThreadState* __tstate = wxPyBeginAllowThreads();
6445 result = (wxRegionContain)(arg1)->Contains((wxRect const &)*arg2);
6446
6447 wxPyEndAllowThreads(__tstate);
6448 if (PyErr_Occurred()) SWIG_fail;
6449 }
6450 resultobj = SWIG_From_int((result));
6451 return resultobj;
6452 fail:
6453 return NULL;
6454 }
6455
6456
6457 static PyObject *_wrap_Region_ContainsRectDim(PyObject *, PyObject *args, PyObject *kwargs) {
6458 PyObject *resultobj;
6459 wxRegion *arg1 = (wxRegion *) 0 ;
6460 int arg2 ;
6461 int arg3 ;
6462 int arg4 ;
6463 int arg5 ;
6464 wxRegionContain result;
6465 PyObject * obj0 = 0 ;
6466 PyObject * obj1 = 0 ;
6467 PyObject * obj2 = 0 ;
6468 PyObject * obj3 = 0 ;
6469 PyObject * obj4 = 0 ;
6470 char *kwnames[] = {
6471 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
6472 };
6473
6474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_ContainsRectDim",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6476 if (SWIG_arg_fail(1)) SWIG_fail;
6477 {
6478 arg2 = (int)(SWIG_As_int(obj1));
6479 if (SWIG_arg_fail(2)) SWIG_fail;
6480 }
6481 {
6482 arg3 = (int)(SWIG_As_int(obj2));
6483 if (SWIG_arg_fail(3)) SWIG_fail;
6484 }
6485 {
6486 arg4 = (int)(SWIG_As_int(obj3));
6487 if (SWIG_arg_fail(4)) SWIG_fail;
6488 }
6489 {
6490 arg5 = (int)(SWIG_As_int(obj4));
6491 if (SWIG_arg_fail(5)) SWIG_fail;
6492 }
6493 {
6494 PyThreadState* __tstate = wxPyBeginAllowThreads();
6495 result = (wxRegionContain)(arg1)->Contains(arg2,arg3,arg4,arg5);
6496
6497 wxPyEndAllowThreads(__tstate);
6498 if (PyErr_Occurred()) SWIG_fail;
6499 }
6500 resultobj = SWIG_From_int((result));
6501 return resultobj;
6502 fail:
6503 return NULL;
6504 }
6505
6506
6507 static PyObject *_wrap_Region_GetBox(PyObject *, PyObject *args, PyObject *kwargs) {
6508 PyObject *resultobj;
6509 wxRegion *arg1 = (wxRegion *) 0 ;
6510 wxRect result;
6511 PyObject * obj0 = 0 ;
6512 char *kwnames[] = {
6513 (char *) "self", NULL
6514 };
6515
6516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_GetBox",kwnames,&obj0)) goto fail;
6517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6518 if (SWIG_arg_fail(1)) SWIG_fail;
6519 {
6520 PyThreadState* __tstate = wxPyBeginAllowThreads();
6521 result = (arg1)->GetBox();
6522
6523 wxPyEndAllowThreads(__tstate);
6524 if (PyErr_Occurred()) SWIG_fail;
6525 }
6526 {
6527 wxRect * resultptr;
6528 resultptr = new wxRect((wxRect &)(result));
6529 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6530 }
6531 return resultobj;
6532 fail:
6533 return NULL;
6534 }
6535
6536
6537 static PyObject *_wrap_Region_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
6538 PyObject *resultobj;
6539 wxRegion *arg1 = (wxRegion *) 0 ;
6540 int arg2 ;
6541 int arg3 ;
6542 int arg4 ;
6543 int arg5 ;
6544 bool result;
6545 PyObject * obj0 = 0 ;
6546 PyObject * obj1 = 0 ;
6547 PyObject * obj2 = 0 ;
6548 PyObject * obj3 = 0 ;
6549 PyObject * obj4 = 0 ;
6550 char *kwnames[] = {
6551 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6552 };
6553
6554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Intersect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6556 if (SWIG_arg_fail(1)) SWIG_fail;
6557 {
6558 arg2 = (int)(SWIG_As_int(obj1));
6559 if (SWIG_arg_fail(2)) SWIG_fail;
6560 }
6561 {
6562 arg3 = (int)(SWIG_As_int(obj2));
6563 if (SWIG_arg_fail(3)) SWIG_fail;
6564 }
6565 {
6566 arg4 = (int)(SWIG_As_int(obj3));
6567 if (SWIG_arg_fail(4)) SWIG_fail;
6568 }
6569 {
6570 arg5 = (int)(SWIG_As_int(obj4));
6571 if (SWIG_arg_fail(5)) SWIG_fail;
6572 }
6573 {
6574 PyThreadState* __tstate = wxPyBeginAllowThreads();
6575 result = (bool)(arg1)->Intersect(arg2,arg3,arg4,arg5);
6576
6577 wxPyEndAllowThreads(__tstate);
6578 if (PyErr_Occurred()) SWIG_fail;
6579 }
6580 {
6581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6582 }
6583 return resultobj;
6584 fail:
6585 return NULL;
6586 }
6587
6588
6589 static PyObject *_wrap_Region_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6590 PyObject *resultobj;
6591 wxRegion *arg1 = (wxRegion *) 0 ;
6592 wxRect *arg2 = 0 ;
6593 bool result;
6594 wxRect temp2 ;
6595 PyObject * obj0 = 0 ;
6596 PyObject * obj1 = 0 ;
6597 char *kwnames[] = {
6598 (char *) "self",(char *) "rect", NULL
6599 };
6600
6601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6603 if (SWIG_arg_fail(1)) SWIG_fail;
6604 {
6605 arg2 = &temp2;
6606 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6607 }
6608 {
6609 PyThreadState* __tstate = wxPyBeginAllowThreads();
6610 result = (bool)(arg1)->Intersect((wxRect const &)*arg2);
6611
6612 wxPyEndAllowThreads(__tstate);
6613 if (PyErr_Occurred()) SWIG_fail;
6614 }
6615 {
6616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6617 }
6618 return resultobj;
6619 fail:
6620 return NULL;
6621 }
6622
6623
6624 static PyObject *_wrap_Region_IntersectRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6625 PyObject *resultobj;
6626 wxRegion *arg1 = (wxRegion *) 0 ;
6627 wxRegion *arg2 = 0 ;
6628 bool result;
6629 PyObject * obj0 = 0 ;
6630 PyObject * obj1 = 0 ;
6631 char *kwnames[] = {
6632 (char *) "self",(char *) "region", NULL
6633 };
6634
6635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRegion",kwnames,&obj0,&obj1)) goto fail;
6636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6637 if (SWIG_arg_fail(1)) SWIG_fail;
6638 {
6639 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6640 if (SWIG_arg_fail(2)) SWIG_fail;
6641 if (arg2 == NULL) {
6642 SWIG_null_ref("wxRegion");
6643 }
6644 if (SWIG_arg_fail(2)) SWIG_fail;
6645 }
6646 {
6647 PyThreadState* __tstate = wxPyBeginAllowThreads();
6648 result = (bool)(arg1)->Intersect((wxRegion const &)*arg2);
6649
6650 wxPyEndAllowThreads(__tstate);
6651 if (PyErr_Occurred()) SWIG_fail;
6652 }
6653 {
6654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6655 }
6656 return resultobj;
6657 fail:
6658 return NULL;
6659 }
6660
6661
6662 static PyObject *_wrap_Region_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
6663 PyObject *resultobj;
6664 wxRegion *arg1 = (wxRegion *) 0 ;
6665 bool result;
6666 PyObject * obj0 = 0 ;
6667 char *kwnames[] = {
6668 (char *) "self", NULL
6669 };
6670
6671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_IsEmpty",kwnames,&obj0)) goto fail;
6672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6673 if (SWIG_arg_fail(1)) SWIG_fail;
6674 {
6675 PyThreadState* __tstate = wxPyBeginAllowThreads();
6676 result = (bool)(arg1)->IsEmpty();
6677
6678 wxPyEndAllowThreads(__tstate);
6679 if (PyErr_Occurred()) SWIG_fail;
6680 }
6681 {
6682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6683 }
6684 return resultobj;
6685 fail:
6686 return NULL;
6687 }
6688
6689
6690 static PyObject *_wrap_Region_Union(PyObject *, PyObject *args, PyObject *kwargs) {
6691 PyObject *resultobj;
6692 wxRegion *arg1 = (wxRegion *) 0 ;
6693 int arg2 ;
6694 int arg3 ;
6695 int arg4 ;
6696 int arg5 ;
6697 bool result;
6698 PyObject * obj0 = 0 ;
6699 PyObject * obj1 = 0 ;
6700 PyObject * obj2 = 0 ;
6701 PyObject * obj3 = 0 ;
6702 PyObject * obj4 = 0 ;
6703 char *kwnames[] = {
6704 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6705 };
6706
6707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Union",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6709 if (SWIG_arg_fail(1)) SWIG_fail;
6710 {
6711 arg2 = (int)(SWIG_As_int(obj1));
6712 if (SWIG_arg_fail(2)) SWIG_fail;
6713 }
6714 {
6715 arg3 = (int)(SWIG_As_int(obj2));
6716 if (SWIG_arg_fail(3)) SWIG_fail;
6717 }
6718 {
6719 arg4 = (int)(SWIG_As_int(obj3));
6720 if (SWIG_arg_fail(4)) SWIG_fail;
6721 }
6722 {
6723 arg5 = (int)(SWIG_As_int(obj4));
6724 if (SWIG_arg_fail(5)) SWIG_fail;
6725 }
6726 {
6727 PyThreadState* __tstate = wxPyBeginAllowThreads();
6728 result = (bool)(arg1)->Union(arg2,arg3,arg4,arg5);
6729
6730 wxPyEndAllowThreads(__tstate);
6731 if (PyErr_Occurred()) SWIG_fail;
6732 }
6733 {
6734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6735 }
6736 return resultobj;
6737 fail:
6738 return NULL;
6739 }
6740
6741
6742 static PyObject *_wrap_Region_UnionRect(PyObject *, PyObject *args, PyObject *kwargs) {
6743 PyObject *resultobj;
6744 wxRegion *arg1 = (wxRegion *) 0 ;
6745 wxRect *arg2 = 0 ;
6746 bool result;
6747 wxRect temp2 ;
6748 PyObject * obj0 = 0 ;
6749 PyObject * obj1 = 0 ;
6750 char *kwnames[] = {
6751 (char *) "self",(char *) "rect", NULL
6752 };
6753
6754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRect",kwnames,&obj0,&obj1)) goto fail;
6755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6756 if (SWIG_arg_fail(1)) SWIG_fail;
6757 {
6758 arg2 = &temp2;
6759 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6760 }
6761 {
6762 PyThreadState* __tstate = wxPyBeginAllowThreads();
6763 result = (bool)(arg1)->Union((wxRect const &)*arg2);
6764
6765 wxPyEndAllowThreads(__tstate);
6766 if (PyErr_Occurred()) SWIG_fail;
6767 }
6768 {
6769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6770 }
6771 return resultobj;
6772 fail:
6773 return NULL;
6774 }
6775
6776
6777 static PyObject *_wrap_Region_UnionRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6778 PyObject *resultobj;
6779 wxRegion *arg1 = (wxRegion *) 0 ;
6780 wxRegion *arg2 = 0 ;
6781 bool result;
6782 PyObject * obj0 = 0 ;
6783 PyObject * obj1 = 0 ;
6784 char *kwnames[] = {
6785 (char *) "self",(char *) "region", NULL
6786 };
6787
6788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRegion",kwnames,&obj0,&obj1)) goto fail;
6789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6790 if (SWIG_arg_fail(1)) SWIG_fail;
6791 {
6792 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6793 if (SWIG_arg_fail(2)) SWIG_fail;
6794 if (arg2 == NULL) {
6795 SWIG_null_ref("wxRegion");
6796 }
6797 if (SWIG_arg_fail(2)) SWIG_fail;
6798 }
6799 {
6800 PyThreadState* __tstate = wxPyBeginAllowThreads();
6801 result = (bool)(arg1)->Union((wxRegion const &)*arg2);
6802
6803 wxPyEndAllowThreads(__tstate);
6804 if (PyErr_Occurred()) SWIG_fail;
6805 }
6806 {
6807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6808 }
6809 return resultobj;
6810 fail:
6811 return NULL;
6812 }
6813
6814
6815 static PyObject *_wrap_Region_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
6816 PyObject *resultobj;
6817 wxRegion *arg1 = (wxRegion *) 0 ;
6818 int arg2 ;
6819 int arg3 ;
6820 int arg4 ;
6821 int arg5 ;
6822 bool result;
6823 PyObject * obj0 = 0 ;
6824 PyObject * obj1 = 0 ;
6825 PyObject * obj2 = 0 ;
6826 PyObject * obj3 = 0 ;
6827 PyObject * obj4 = 0 ;
6828 char *kwnames[] = {
6829 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6830 };
6831
6832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Subtract",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6834 if (SWIG_arg_fail(1)) SWIG_fail;
6835 {
6836 arg2 = (int)(SWIG_As_int(obj1));
6837 if (SWIG_arg_fail(2)) SWIG_fail;
6838 }
6839 {
6840 arg3 = (int)(SWIG_As_int(obj2));
6841 if (SWIG_arg_fail(3)) SWIG_fail;
6842 }
6843 {
6844 arg4 = (int)(SWIG_As_int(obj3));
6845 if (SWIG_arg_fail(4)) SWIG_fail;
6846 }
6847 {
6848 arg5 = (int)(SWIG_As_int(obj4));
6849 if (SWIG_arg_fail(5)) SWIG_fail;
6850 }
6851 {
6852 PyThreadState* __tstate = wxPyBeginAllowThreads();
6853 result = (bool)(arg1)->Subtract(arg2,arg3,arg4,arg5);
6854
6855 wxPyEndAllowThreads(__tstate);
6856 if (PyErr_Occurred()) SWIG_fail;
6857 }
6858 {
6859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6860 }
6861 return resultobj;
6862 fail:
6863 return NULL;
6864 }
6865
6866
6867 static PyObject *_wrap_Region_SubtractRect(PyObject *, PyObject *args, PyObject *kwargs) {
6868 PyObject *resultobj;
6869 wxRegion *arg1 = (wxRegion *) 0 ;
6870 wxRect *arg2 = 0 ;
6871 bool result;
6872 wxRect temp2 ;
6873 PyObject * obj0 = 0 ;
6874 PyObject * obj1 = 0 ;
6875 char *kwnames[] = {
6876 (char *) "self",(char *) "rect", NULL
6877 };
6878
6879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRect",kwnames,&obj0,&obj1)) goto fail;
6880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6881 if (SWIG_arg_fail(1)) SWIG_fail;
6882 {
6883 arg2 = &temp2;
6884 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6885 }
6886 {
6887 PyThreadState* __tstate = wxPyBeginAllowThreads();
6888 result = (bool)(arg1)->Subtract((wxRect const &)*arg2);
6889
6890 wxPyEndAllowThreads(__tstate);
6891 if (PyErr_Occurred()) SWIG_fail;
6892 }
6893 {
6894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6895 }
6896 return resultobj;
6897 fail:
6898 return NULL;
6899 }
6900
6901
6902 static PyObject *_wrap_Region_SubtractRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6903 PyObject *resultobj;
6904 wxRegion *arg1 = (wxRegion *) 0 ;
6905 wxRegion *arg2 = 0 ;
6906 bool result;
6907 PyObject * obj0 = 0 ;
6908 PyObject * obj1 = 0 ;
6909 char *kwnames[] = {
6910 (char *) "self",(char *) "region", NULL
6911 };
6912
6913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRegion",kwnames,&obj0,&obj1)) goto fail;
6914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6915 if (SWIG_arg_fail(1)) SWIG_fail;
6916 {
6917 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6918 if (SWIG_arg_fail(2)) SWIG_fail;
6919 if (arg2 == NULL) {
6920 SWIG_null_ref("wxRegion");
6921 }
6922 if (SWIG_arg_fail(2)) SWIG_fail;
6923 }
6924 {
6925 PyThreadState* __tstate = wxPyBeginAllowThreads();
6926 result = (bool)(arg1)->Subtract((wxRegion const &)*arg2);
6927
6928 wxPyEndAllowThreads(__tstate);
6929 if (PyErr_Occurred()) SWIG_fail;
6930 }
6931 {
6932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6933 }
6934 return resultobj;
6935 fail:
6936 return NULL;
6937 }
6938
6939
6940 static PyObject *_wrap_Region_Xor(PyObject *, PyObject *args, PyObject *kwargs) {
6941 PyObject *resultobj;
6942 wxRegion *arg1 = (wxRegion *) 0 ;
6943 int arg2 ;
6944 int arg3 ;
6945 int arg4 ;
6946 int arg5 ;
6947 bool result;
6948 PyObject * obj0 = 0 ;
6949 PyObject * obj1 = 0 ;
6950 PyObject * obj2 = 0 ;
6951 PyObject * obj3 = 0 ;
6952 PyObject * obj4 = 0 ;
6953 char *kwnames[] = {
6954 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6955 };
6956
6957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Xor",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6959 if (SWIG_arg_fail(1)) SWIG_fail;
6960 {
6961 arg2 = (int)(SWIG_As_int(obj1));
6962 if (SWIG_arg_fail(2)) SWIG_fail;
6963 }
6964 {
6965 arg3 = (int)(SWIG_As_int(obj2));
6966 if (SWIG_arg_fail(3)) SWIG_fail;
6967 }
6968 {
6969 arg4 = (int)(SWIG_As_int(obj3));
6970 if (SWIG_arg_fail(4)) SWIG_fail;
6971 }
6972 {
6973 arg5 = (int)(SWIG_As_int(obj4));
6974 if (SWIG_arg_fail(5)) SWIG_fail;
6975 }
6976 {
6977 PyThreadState* __tstate = wxPyBeginAllowThreads();
6978 result = (bool)(arg1)->Xor(arg2,arg3,arg4,arg5);
6979
6980 wxPyEndAllowThreads(__tstate);
6981 if (PyErr_Occurred()) SWIG_fail;
6982 }
6983 {
6984 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6985 }
6986 return resultobj;
6987 fail:
6988 return NULL;
6989 }
6990
6991
6992 static PyObject *_wrap_Region_XorRect(PyObject *, PyObject *args, PyObject *kwargs) {
6993 PyObject *resultobj;
6994 wxRegion *arg1 = (wxRegion *) 0 ;
6995 wxRect *arg2 = 0 ;
6996 bool result;
6997 wxRect temp2 ;
6998 PyObject * obj0 = 0 ;
6999 PyObject * obj1 = 0 ;
7000 char *kwnames[] = {
7001 (char *) "self",(char *) "rect", NULL
7002 };
7003
7004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRect",kwnames,&obj0,&obj1)) goto fail;
7005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7006 if (SWIG_arg_fail(1)) SWIG_fail;
7007 {
7008 arg2 = &temp2;
7009 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7010 }
7011 {
7012 PyThreadState* __tstate = wxPyBeginAllowThreads();
7013 result = (bool)(arg1)->Xor((wxRect const &)*arg2);
7014
7015 wxPyEndAllowThreads(__tstate);
7016 if (PyErr_Occurred()) SWIG_fail;
7017 }
7018 {
7019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7020 }
7021 return resultobj;
7022 fail:
7023 return NULL;
7024 }
7025
7026
7027 static PyObject *_wrap_Region_XorRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7028 PyObject *resultobj;
7029 wxRegion *arg1 = (wxRegion *) 0 ;
7030 wxRegion *arg2 = 0 ;
7031 bool result;
7032 PyObject * obj0 = 0 ;
7033 PyObject * obj1 = 0 ;
7034 char *kwnames[] = {
7035 (char *) "self",(char *) "region", NULL
7036 };
7037
7038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRegion",kwnames,&obj0,&obj1)) goto fail;
7039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7040 if (SWIG_arg_fail(1)) SWIG_fail;
7041 {
7042 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7043 if (SWIG_arg_fail(2)) SWIG_fail;
7044 if (arg2 == NULL) {
7045 SWIG_null_ref("wxRegion");
7046 }
7047 if (SWIG_arg_fail(2)) SWIG_fail;
7048 }
7049 {
7050 PyThreadState* __tstate = wxPyBeginAllowThreads();
7051 result = (bool)(arg1)->Xor((wxRegion const &)*arg2);
7052
7053 wxPyEndAllowThreads(__tstate);
7054 if (PyErr_Occurred()) SWIG_fail;
7055 }
7056 {
7057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7058 }
7059 return resultobj;
7060 fail:
7061 return NULL;
7062 }
7063
7064
7065 static PyObject *_wrap_Region_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7066 PyObject *resultobj;
7067 wxRegion *arg1 = (wxRegion *) 0 ;
7068 SwigValueWrapper<wxBitmap > result;
7069 PyObject * obj0 = 0 ;
7070 char *kwnames[] = {
7071 (char *) "self", NULL
7072 };
7073
7074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_ConvertToBitmap",kwnames,&obj0)) goto fail;
7075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7076 if (SWIG_arg_fail(1)) SWIG_fail;
7077 {
7078 PyThreadState* __tstate = wxPyBeginAllowThreads();
7079 result = (arg1)->ConvertToBitmap();
7080
7081 wxPyEndAllowThreads(__tstate);
7082 if (PyErr_Occurred()) SWIG_fail;
7083 }
7084 {
7085 wxBitmap * resultptr;
7086 resultptr = new wxBitmap((wxBitmap &)(result));
7087 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
7088 }
7089 return resultobj;
7090 fail:
7091 return NULL;
7092 }
7093
7094
7095 static PyObject *_wrap_Region_UnionBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7096 PyObject *resultobj;
7097 wxRegion *arg1 = (wxRegion *) 0 ;
7098 wxBitmap *arg2 = 0 ;
7099 bool result;
7100 PyObject * obj0 = 0 ;
7101 PyObject * obj1 = 0 ;
7102 char *kwnames[] = {
7103 (char *) "self",(char *) "bmp", NULL
7104 };
7105
7106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionBitmap",kwnames,&obj0,&obj1)) goto fail;
7107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7108 if (SWIG_arg_fail(1)) SWIG_fail;
7109 {
7110 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7111 if (SWIG_arg_fail(2)) SWIG_fail;
7112 if (arg2 == NULL) {
7113 SWIG_null_ref("wxBitmap");
7114 }
7115 if (SWIG_arg_fail(2)) SWIG_fail;
7116 }
7117 {
7118 PyThreadState* __tstate = wxPyBeginAllowThreads();
7119 result = (bool)(arg1)->Union((wxBitmap const &)*arg2);
7120
7121 wxPyEndAllowThreads(__tstate);
7122 if (PyErr_Occurred()) SWIG_fail;
7123 }
7124 {
7125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7126 }
7127 return resultobj;
7128 fail:
7129 return NULL;
7130 }
7131
7132
7133 static PyObject *_wrap_Region_UnionBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
7134 PyObject *resultobj;
7135 wxRegion *arg1 = (wxRegion *) 0 ;
7136 wxBitmap *arg2 = 0 ;
7137 wxColour *arg3 = 0 ;
7138 int arg4 = (int) 0 ;
7139 bool result;
7140 wxColour temp3 ;
7141 PyObject * obj0 = 0 ;
7142 PyObject * obj1 = 0 ;
7143 PyObject * obj2 = 0 ;
7144 PyObject * obj3 = 0 ;
7145 char *kwnames[] = {
7146 (char *) "self",(char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
7147 };
7148
7149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Region_UnionBitmapColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7151 if (SWIG_arg_fail(1)) SWIG_fail;
7152 {
7153 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7154 if (SWIG_arg_fail(2)) SWIG_fail;
7155 if (arg2 == NULL) {
7156 SWIG_null_ref("wxBitmap");
7157 }
7158 if (SWIG_arg_fail(2)) SWIG_fail;
7159 }
7160 {
7161 arg3 = &temp3;
7162 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
7163 }
7164 if (obj3) {
7165 {
7166 arg4 = (int)(SWIG_As_int(obj3));
7167 if (SWIG_arg_fail(4)) SWIG_fail;
7168 }
7169 }
7170 {
7171 PyThreadState* __tstate = wxPyBeginAllowThreads();
7172 result = (bool)(arg1)->Union((wxBitmap const &)*arg2,(wxColour const &)*arg3,arg4);
7173
7174 wxPyEndAllowThreads(__tstate);
7175 if (PyErr_Occurred()) SWIG_fail;
7176 }
7177 {
7178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7179 }
7180 return resultobj;
7181 fail:
7182 return NULL;
7183 }
7184
7185
7186 static PyObject * Region_swigregister(PyObject *, PyObject *args) {
7187 PyObject *obj;
7188 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7189 SWIG_TypeClientData(SWIGTYPE_p_wxRegion, obj);
7190 Py_INCREF(obj);
7191 return Py_BuildValue((char *)"");
7192 }
7193 static PyObject *_wrap_new_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7194 PyObject *resultobj;
7195 wxRegion *arg1 = 0 ;
7196 wxRegionIterator *result;
7197 PyObject * obj0 = 0 ;
7198 char *kwnames[] = {
7199 (char *) "region", NULL
7200 };
7201
7202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionIterator",kwnames,&obj0)) goto fail;
7203 {
7204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7205 if (SWIG_arg_fail(1)) SWIG_fail;
7206 if (arg1 == NULL) {
7207 SWIG_null_ref("wxRegion");
7208 }
7209 if (SWIG_arg_fail(1)) SWIG_fail;
7210 }
7211 {
7212 if (!wxPyCheckForApp()) SWIG_fail;
7213 PyThreadState* __tstate = wxPyBeginAllowThreads();
7214 result = (wxRegionIterator *)new wxRegionIterator((wxRegion const &)*arg1);
7215
7216 wxPyEndAllowThreads(__tstate);
7217 if (PyErr_Occurred()) SWIG_fail;
7218 }
7219 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegionIterator, 1);
7220 return resultobj;
7221 fail:
7222 return NULL;
7223 }
7224
7225
7226 static PyObject *_wrap_delete_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7227 PyObject *resultobj;
7228 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7229 PyObject * obj0 = 0 ;
7230 char *kwnames[] = {
7231 (char *) "self", NULL
7232 };
7233
7234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RegionIterator",kwnames,&obj0)) goto fail;
7235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7236 if (SWIG_arg_fail(1)) SWIG_fail;
7237 {
7238 PyThreadState* __tstate = wxPyBeginAllowThreads();
7239 delete arg1;
7240
7241 wxPyEndAllowThreads(__tstate);
7242 if (PyErr_Occurred()) SWIG_fail;
7243 }
7244 Py_INCREF(Py_None); resultobj = Py_None;
7245 return resultobj;
7246 fail:
7247 return NULL;
7248 }
7249
7250
7251 static PyObject *_wrap_RegionIterator_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
7252 PyObject *resultobj;
7253 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7254 int result;
7255 PyObject * obj0 = 0 ;
7256 char *kwnames[] = {
7257 (char *) "self", NULL
7258 };
7259
7260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetX",kwnames,&obj0)) goto fail;
7261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7262 if (SWIG_arg_fail(1)) SWIG_fail;
7263 {
7264 PyThreadState* __tstate = wxPyBeginAllowThreads();
7265 result = (int)(arg1)->GetX();
7266
7267 wxPyEndAllowThreads(__tstate);
7268 if (PyErr_Occurred()) SWIG_fail;
7269 }
7270 {
7271 resultobj = SWIG_From_int((int)(result));
7272 }
7273 return resultobj;
7274 fail:
7275 return NULL;
7276 }
7277
7278
7279 static PyObject *_wrap_RegionIterator_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
7280 PyObject *resultobj;
7281 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7282 int result;
7283 PyObject * obj0 = 0 ;
7284 char *kwnames[] = {
7285 (char *) "self", NULL
7286 };
7287
7288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetY",kwnames,&obj0)) goto fail;
7289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7290 if (SWIG_arg_fail(1)) SWIG_fail;
7291 {
7292 PyThreadState* __tstate = wxPyBeginAllowThreads();
7293 result = (int)(arg1)->GetY();
7294
7295 wxPyEndAllowThreads(__tstate);
7296 if (PyErr_Occurred()) SWIG_fail;
7297 }
7298 {
7299 resultobj = SWIG_From_int((int)(result));
7300 }
7301 return resultobj;
7302 fail:
7303 return NULL;
7304 }
7305
7306
7307 static PyObject *_wrap_RegionIterator_GetW(PyObject *, PyObject *args, PyObject *kwargs) {
7308 PyObject *resultobj;
7309 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7310 int result;
7311 PyObject * obj0 = 0 ;
7312 char *kwnames[] = {
7313 (char *) "self", NULL
7314 };
7315
7316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetW",kwnames,&obj0)) goto fail;
7317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7318 if (SWIG_arg_fail(1)) SWIG_fail;
7319 {
7320 PyThreadState* __tstate = wxPyBeginAllowThreads();
7321 result = (int)(arg1)->GetW();
7322
7323 wxPyEndAllowThreads(__tstate);
7324 if (PyErr_Occurred()) SWIG_fail;
7325 }
7326 {
7327 resultobj = SWIG_From_int((int)(result));
7328 }
7329 return resultobj;
7330 fail:
7331 return NULL;
7332 }
7333
7334
7335 static PyObject *_wrap_RegionIterator_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
7336 PyObject *resultobj;
7337 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7338 int result;
7339 PyObject * obj0 = 0 ;
7340 char *kwnames[] = {
7341 (char *) "self", NULL
7342 };
7343
7344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetWidth",kwnames,&obj0)) goto fail;
7345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7346 if (SWIG_arg_fail(1)) SWIG_fail;
7347 {
7348 PyThreadState* __tstate = wxPyBeginAllowThreads();
7349 result = (int)(arg1)->GetWidth();
7350
7351 wxPyEndAllowThreads(__tstate);
7352 if (PyErr_Occurred()) SWIG_fail;
7353 }
7354 {
7355 resultobj = SWIG_From_int((int)(result));
7356 }
7357 return resultobj;
7358 fail:
7359 return NULL;
7360 }
7361
7362
7363 static PyObject *_wrap_RegionIterator_GetH(PyObject *, PyObject *args, PyObject *kwargs) {
7364 PyObject *resultobj;
7365 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7366 int result;
7367 PyObject * obj0 = 0 ;
7368 char *kwnames[] = {
7369 (char *) "self", NULL
7370 };
7371
7372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetH",kwnames,&obj0)) goto fail;
7373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7374 if (SWIG_arg_fail(1)) SWIG_fail;
7375 {
7376 PyThreadState* __tstate = wxPyBeginAllowThreads();
7377 result = (int)(arg1)->GetH();
7378
7379 wxPyEndAllowThreads(__tstate);
7380 if (PyErr_Occurred()) SWIG_fail;
7381 }
7382 {
7383 resultobj = SWIG_From_int((int)(result));
7384 }
7385 return resultobj;
7386 fail:
7387 return NULL;
7388 }
7389
7390
7391 static PyObject *_wrap_RegionIterator_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
7392 PyObject *resultobj;
7393 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7394 int result;
7395 PyObject * obj0 = 0 ;
7396 char *kwnames[] = {
7397 (char *) "self", NULL
7398 };
7399
7400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetHeight",kwnames,&obj0)) goto fail;
7401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7402 if (SWIG_arg_fail(1)) SWIG_fail;
7403 {
7404 PyThreadState* __tstate = wxPyBeginAllowThreads();
7405 result = (int)(arg1)->GetHeight();
7406
7407 wxPyEndAllowThreads(__tstate);
7408 if (PyErr_Occurred()) SWIG_fail;
7409 }
7410 {
7411 resultobj = SWIG_From_int((int)(result));
7412 }
7413 return resultobj;
7414 fail:
7415 return NULL;
7416 }
7417
7418
7419 static PyObject *_wrap_RegionIterator_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
7420 PyObject *resultobj;
7421 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7422 wxRect result;
7423 PyObject * obj0 = 0 ;
7424 char *kwnames[] = {
7425 (char *) "self", NULL
7426 };
7427
7428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetRect",kwnames,&obj0)) goto fail;
7429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7430 if (SWIG_arg_fail(1)) SWIG_fail;
7431 {
7432 PyThreadState* __tstate = wxPyBeginAllowThreads();
7433 result = (arg1)->GetRect();
7434
7435 wxPyEndAllowThreads(__tstate);
7436 if (PyErr_Occurred()) SWIG_fail;
7437 }
7438 {
7439 wxRect * resultptr;
7440 resultptr = new wxRect((wxRect &)(result));
7441 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
7442 }
7443 return resultobj;
7444 fail:
7445 return NULL;
7446 }
7447
7448
7449 static PyObject *_wrap_RegionIterator_HaveRects(PyObject *, PyObject *args, PyObject *kwargs) {
7450 PyObject *resultobj;
7451 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7452 bool result;
7453 PyObject * obj0 = 0 ;
7454 char *kwnames[] = {
7455 (char *) "self", NULL
7456 };
7457
7458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_HaveRects",kwnames,&obj0)) goto fail;
7459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7460 if (SWIG_arg_fail(1)) SWIG_fail;
7461 {
7462 PyThreadState* __tstate = wxPyBeginAllowThreads();
7463 result = (bool)(arg1)->HaveRects();
7464
7465 wxPyEndAllowThreads(__tstate);
7466 if (PyErr_Occurred()) SWIG_fail;
7467 }
7468 {
7469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7470 }
7471 return resultobj;
7472 fail:
7473 return NULL;
7474 }
7475
7476
7477 static PyObject *_wrap_RegionIterator_Reset(PyObject *, PyObject *args, PyObject *kwargs) {
7478 PyObject *resultobj;
7479 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7480 PyObject * obj0 = 0 ;
7481 char *kwnames[] = {
7482 (char *) "self", NULL
7483 };
7484
7485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Reset",kwnames,&obj0)) goto fail;
7486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7487 if (SWIG_arg_fail(1)) SWIG_fail;
7488 {
7489 PyThreadState* __tstate = wxPyBeginAllowThreads();
7490 (arg1)->Reset();
7491
7492 wxPyEndAllowThreads(__tstate);
7493 if (PyErr_Occurred()) SWIG_fail;
7494 }
7495 Py_INCREF(Py_None); resultobj = Py_None;
7496 return resultobj;
7497 fail:
7498 return NULL;
7499 }
7500
7501
7502 static PyObject *_wrap_RegionIterator_Next(PyObject *, PyObject *args, PyObject *kwargs) {
7503 PyObject *resultobj;
7504 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7505 PyObject * obj0 = 0 ;
7506 char *kwnames[] = {
7507 (char *) "self", NULL
7508 };
7509
7510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Next",kwnames,&obj0)) goto fail;
7511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7512 if (SWIG_arg_fail(1)) SWIG_fail;
7513 {
7514 PyThreadState* __tstate = wxPyBeginAllowThreads();
7515 wxRegionIterator_Next(arg1);
7516
7517 wxPyEndAllowThreads(__tstate);
7518 if (PyErr_Occurred()) SWIG_fail;
7519 }
7520 Py_INCREF(Py_None); resultobj = Py_None;
7521 return resultobj;
7522 fail:
7523 return NULL;
7524 }
7525
7526
7527 static PyObject *_wrap_RegionIterator___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
7528 PyObject *resultobj;
7529 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7530 bool result;
7531 PyObject * obj0 = 0 ;
7532 char *kwnames[] = {
7533 (char *) "self", NULL
7534 };
7535
7536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator___nonzero__",kwnames,&obj0)) goto fail;
7537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7538 if (SWIG_arg_fail(1)) SWIG_fail;
7539 {
7540 PyThreadState* __tstate = wxPyBeginAllowThreads();
7541 result = (bool)wxRegionIterator___nonzero__(arg1);
7542
7543 wxPyEndAllowThreads(__tstate);
7544 if (PyErr_Occurred()) SWIG_fail;
7545 }
7546 {
7547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7548 }
7549 return resultobj;
7550 fail:
7551 return NULL;
7552 }
7553
7554
7555 static PyObject * RegionIterator_swigregister(PyObject *, PyObject *args) {
7556 PyObject *obj;
7557 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7558 SWIG_TypeClientData(SWIGTYPE_p_wxRegionIterator, obj);
7559 Py_INCREF(obj);
7560 return Py_BuildValue((char *)"");
7561 }
7562 static PyObject *_wrap_new_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7563 PyObject *resultobj;
7564 wxNativeFontInfo *result;
7565 char *kwnames[] = {
7566 NULL
7567 };
7568
7569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeFontInfo",kwnames)) goto fail;
7570 {
7571 PyThreadState* __tstate = wxPyBeginAllowThreads();
7572 result = (wxNativeFontInfo *)new wxNativeFontInfo();
7573
7574 wxPyEndAllowThreads(__tstate);
7575 if (PyErr_Occurred()) SWIG_fail;
7576 }
7577 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 1);
7578 return resultobj;
7579 fail:
7580 return NULL;
7581 }
7582
7583
7584 static PyObject *_wrap_delete_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7585 PyObject *resultobj;
7586 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7587 PyObject * obj0 = 0 ;
7588 char *kwnames[] = {
7589 (char *) "self", NULL
7590 };
7591
7592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeFontInfo",kwnames,&obj0)) goto fail;
7593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7594 if (SWIG_arg_fail(1)) SWIG_fail;
7595 {
7596 PyThreadState* __tstate = wxPyBeginAllowThreads();
7597 delete arg1;
7598
7599 wxPyEndAllowThreads(__tstate);
7600 if (PyErr_Occurred()) SWIG_fail;
7601 }
7602 Py_INCREF(Py_None); resultobj = Py_None;
7603 return resultobj;
7604 fail:
7605 return NULL;
7606 }
7607
7608
7609 static PyObject *_wrap_NativeFontInfo_Init(PyObject *, PyObject *args, PyObject *kwargs) {
7610 PyObject *resultobj;
7611 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7612 PyObject * obj0 = 0 ;
7613 char *kwnames[] = {
7614 (char *) "self", NULL
7615 };
7616
7617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_Init",kwnames,&obj0)) goto fail;
7618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7619 if (SWIG_arg_fail(1)) SWIG_fail;
7620 {
7621 PyThreadState* __tstate = wxPyBeginAllowThreads();
7622 (arg1)->Init();
7623
7624 wxPyEndAllowThreads(__tstate);
7625 if (PyErr_Occurred()) SWIG_fail;
7626 }
7627 Py_INCREF(Py_None); resultobj = Py_None;
7628 return resultobj;
7629 fail:
7630 return NULL;
7631 }
7632
7633
7634 static PyObject *_wrap_NativeFontInfo_InitFromFont(PyObject *, PyObject *args, PyObject *kwargs) {
7635 PyObject *resultobj;
7636 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7637 wxFont *arg2 = 0 ;
7638 PyObject * obj0 = 0 ;
7639 PyObject * obj1 = 0 ;
7640 char *kwnames[] = {
7641 (char *) "self",(char *) "font", NULL
7642 };
7643
7644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_InitFromFont",kwnames,&obj0,&obj1)) goto fail;
7645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7646 if (SWIG_arg_fail(1)) SWIG_fail;
7647 {
7648 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
7649 if (SWIG_arg_fail(2)) SWIG_fail;
7650 if (arg2 == NULL) {
7651 SWIG_null_ref("wxFont");
7652 }
7653 if (SWIG_arg_fail(2)) SWIG_fail;
7654 }
7655 {
7656 PyThreadState* __tstate = wxPyBeginAllowThreads();
7657 (arg1)->InitFromFont((wxFont const &)*arg2);
7658
7659 wxPyEndAllowThreads(__tstate);
7660 if (PyErr_Occurred()) SWIG_fail;
7661 }
7662 Py_INCREF(Py_None); resultobj = Py_None;
7663 return resultobj;
7664 fail:
7665 return NULL;
7666 }
7667
7668
7669 static PyObject *_wrap_NativeFontInfo_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
7670 PyObject *resultobj;
7671 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7672 int result;
7673 PyObject * obj0 = 0 ;
7674 char *kwnames[] = {
7675 (char *) "self", NULL
7676 };
7677
7678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetPointSize",kwnames,&obj0)) goto fail;
7679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7680 if (SWIG_arg_fail(1)) SWIG_fail;
7681 {
7682 PyThreadState* __tstate = wxPyBeginAllowThreads();
7683 result = (int)((wxNativeFontInfo const *)arg1)->GetPointSize();
7684
7685 wxPyEndAllowThreads(__tstate);
7686 if (PyErr_Occurred()) SWIG_fail;
7687 }
7688 {
7689 resultobj = SWIG_From_int((int)(result));
7690 }
7691 return resultobj;
7692 fail:
7693 return NULL;
7694 }
7695
7696
7697 static PyObject *_wrap_NativeFontInfo_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
7698 PyObject *resultobj;
7699 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7700 wxFontStyle result;
7701 PyObject * obj0 = 0 ;
7702 char *kwnames[] = {
7703 (char *) "self", NULL
7704 };
7705
7706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetStyle",kwnames,&obj0)) goto fail;
7707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7708 if (SWIG_arg_fail(1)) SWIG_fail;
7709 {
7710 PyThreadState* __tstate = wxPyBeginAllowThreads();
7711 result = (wxFontStyle)((wxNativeFontInfo const *)arg1)->GetStyle();
7712
7713 wxPyEndAllowThreads(__tstate);
7714 if (PyErr_Occurred()) SWIG_fail;
7715 }
7716 resultobj = SWIG_From_int((result));
7717 return resultobj;
7718 fail:
7719 return NULL;
7720 }
7721
7722
7723 static PyObject *_wrap_NativeFontInfo_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
7724 PyObject *resultobj;
7725 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7726 wxFontWeight result;
7727 PyObject * obj0 = 0 ;
7728 char *kwnames[] = {
7729 (char *) "self", NULL
7730 };
7731
7732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetWeight",kwnames,&obj0)) goto fail;
7733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7734 if (SWIG_arg_fail(1)) SWIG_fail;
7735 {
7736 PyThreadState* __tstate = wxPyBeginAllowThreads();
7737 result = (wxFontWeight)((wxNativeFontInfo const *)arg1)->GetWeight();
7738
7739 wxPyEndAllowThreads(__tstate);
7740 if (PyErr_Occurred()) SWIG_fail;
7741 }
7742 resultobj = SWIG_From_int((result));
7743 return resultobj;
7744 fail:
7745 return NULL;
7746 }
7747
7748
7749 static PyObject *_wrap_NativeFontInfo_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
7750 PyObject *resultobj;
7751 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7752 bool result;
7753 PyObject * obj0 = 0 ;
7754 char *kwnames[] = {
7755 (char *) "self", NULL
7756 };
7757
7758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetUnderlined",kwnames,&obj0)) goto fail;
7759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7760 if (SWIG_arg_fail(1)) SWIG_fail;
7761 {
7762 PyThreadState* __tstate = wxPyBeginAllowThreads();
7763 result = (bool)((wxNativeFontInfo const *)arg1)->GetUnderlined();
7764
7765 wxPyEndAllowThreads(__tstate);
7766 if (PyErr_Occurred()) SWIG_fail;
7767 }
7768 {
7769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7770 }
7771 return resultobj;
7772 fail:
7773 return NULL;
7774 }
7775
7776
7777 static PyObject *_wrap_NativeFontInfo_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
7778 PyObject *resultobj;
7779 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7780 wxString result;
7781 PyObject * obj0 = 0 ;
7782 char *kwnames[] = {
7783 (char *) "self", NULL
7784 };
7785
7786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFaceName",kwnames,&obj0)) goto fail;
7787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7788 if (SWIG_arg_fail(1)) SWIG_fail;
7789 {
7790 PyThreadState* __tstate = wxPyBeginAllowThreads();
7791 result = ((wxNativeFontInfo const *)arg1)->GetFaceName();
7792
7793 wxPyEndAllowThreads(__tstate);
7794 if (PyErr_Occurred()) SWIG_fail;
7795 }
7796 {
7797 #if wxUSE_UNICODE
7798 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7799 #else
7800 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7801 #endif
7802 }
7803 return resultobj;
7804 fail:
7805 return NULL;
7806 }
7807
7808
7809 static PyObject *_wrap_NativeFontInfo_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
7810 PyObject *resultobj;
7811 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7812 wxFontFamily result;
7813 PyObject * obj0 = 0 ;
7814 char *kwnames[] = {
7815 (char *) "self", NULL
7816 };
7817
7818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFamily",kwnames,&obj0)) goto fail;
7819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7820 if (SWIG_arg_fail(1)) SWIG_fail;
7821 {
7822 PyThreadState* __tstate = wxPyBeginAllowThreads();
7823 result = (wxFontFamily)((wxNativeFontInfo const *)arg1)->GetFamily();
7824
7825 wxPyEndAllowThreads(__tstate);
7826 if (PyErr_Occurred()) SWIG_fail;
7827 }
7828 resultobj = SWIG_From_int((result));
7829 return resultobj;
7830 fail:
7831 return NULL;
7832 }
7833
7834
7835 static PyObject *_wrap_NativeFontInfo_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
7836 PyObject *resultobj;
7837 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7838 wxFontEncoding result;
7839 PyObject * obj0 = 0 ;
7840 char *kwnames[] = {
7841 (char *) "self", NULL
7842 };
7843
7844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetEncoding",kwnames,&obj0)) goto fail;
7845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7846 if (SWIG_arg_fail(1)) SWIG_fail;
7847 {
7848 PyThreadState* __tstate = wxPyBeginAllowThreads();
7849 result = (wxFontEncoding)((wxNativeFontInfo const *)arg1)->GetEncoding();
7850
7851 wxPyEndAllowThreads(__tstate);
7852 if (PyErr_Occurred()) SWIG_fail;
7853 }
7854 resultobj = SWIG_From_int((result));
7855 return resultobj;
7856 fail:
7857 return NULL;
7858 }
7859
7860
7861 static PyObject *_wrap_NativeFontInfo_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
7862 PyObject *resultobj;
7863 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7864 int arg2 ;
7865 PyObject * obj0 = 0 ;
7866 PyObject * obj1 = 0 ;
7867 char *kwnames[] = {
7868 (char *) "self",(char *) "pointsize", NULL
7869 };
7870
7871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
7872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7873 if (SWIG_arg_fail(1)) SWIG_fail;
7874 {
7875 arg2 = (int)(SWIG_As_int(obj1));
7876 if (SWIG_arg_fail(2)) SWIG_fail;
7877 }
7878 {
7879 PyThreadState* __tstate = wxPyBeginAllowThreads();
7880 (arg1)->SetPointSize(arg2);
7881
7882 wxPyEndAllowThreads(__tstate);
7883 if (PyErr_Occurred()) SWIG_fail;
7884 }
7885 Py_INCREF(Py_None); resultobj = Py_None;
7886 return resultobj;
7887 fail:
7888 return NULL;
7889 }
7890
7891
7892 static PyObject *_wrap_NativeFontInfo_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
7893 PyObject *resultobj;
7894 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7895 wxFontStyle arg2 ;
7896 PyObject * obj0 = 0 ;
7897 PyObject * obj1 = 0 ;
7898 char *kwnames[] = {
7899 (char *) "self",(char *) "style", NULL
7900 };
7901
7902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetStyle",kwnames,&obj0,&obj1)) goto fail;
7903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7904 if (SWIG_arg_fail(1)) SWIG_fail;
7905 {
7906 arg2 = (wxFontStyle)(SWIG_As_int(obj1));
7907 if (SWIG_arg_fail(2)) SWIG_fail;
7908 }
7909 {
7910 PyThreadState* __tstate = wxPyBeginAllowThreads();
7911 (arg1)->SetStyle((wxFontStyle )arg2);
7912
7913 wxPyEndAllowThreads(__tstate);
7914 if (PyErr_Occurred()) SWIG_fail;
7915 }
7916 Py_INCREF(Py_None); resultobj = Py_None;
7917 return resultobj;
7918 fail:
7919 return NULL;
7920 }
7921
7922
7923 static PyObject *_wrap_NativeFontInfo_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
7924 PyObject *resultobj;
7925 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7926 wxFontWeight arg2 ;
7927 PyObject * obj0 = 0 ;
7928 PyObject * obj1 = 0 ;
7929 char *kwnames[] = {
7930 (char *) "self",(char *) "weight", NULL
7931 };
7932
7933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetWeight",kwnames,&obj0,&obj1)) goto fail;
7934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7935 if (SWIG_arg_fail(1)) SWIG_fail;
7936 {
7937 arg2 = (wxFontWeight)(SWIG_As_int(obj1));
7938 if (SWIG_arg_fail(2)) SWIG_fail;
7939 }
7940 {
7941 PyThreadState* __tstate = wxPyBeginAllowThreads();
7942 (arg1)->SetWeight((wxFontWeight )arg2);
7943
7944 wxPyEndAllowThreads(__tstate);
7945 if (PyErr_Occurred()) SWIG_fail;
7946 }
7947 Py_INCREF(Py_None); resultobj = Py_None;
7948 return resultobj;
7949 fail:
7950 return NULL;
7951 }
7952
7953
7954 static PyObject *_wrap_NativeFontInfo_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
7955 PyObject *resultobj;
7956 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7957 bool arg2 ;
7958 PyObject * obj0 = 0 ;
7959 PyObject * obj1 = 0 ;
7960 char *kwnames[] = {
7961 (char *) "self",(char *) "underlined", NULL
7962 };
7963
7964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
7965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7966 if (SWIG_arg_fail(1)) SWIG_fail;
7967 {
7968 arg2 = (bool)(SWIG_As_bool(obj1));
7969 if (SWIG_arg_fail(2)) SWIG_fail;
7970 }
7971 {
7972 PyThreadState* __tstate = wxPyBeginAllowThreads();
7973 (arg1)->SetUnderlined(arg2);
7974
7975 wxPyEndAllowThreads(__tstate);
7976 if (PyErr_Occurred()) SWIG_fail;
7977 }
7978 Py_INCREF(Py_None); resultobj = Py_None;
7979 return resultobj;
7980 fail:
7981 return NULL;
7982 }
7983
7984
7985 static PyObject *_wrap_NativeFontInfo_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
7986 PyObject *resultobj;
7987 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7988 wxString arg2 ;
7989 PyObject * obj0 = 0 ;
7990 PyObject * obj1 = 0 ;
7991 char *kwnames[] = {
7992 (char *) "self",(char *) "facename", NULL
7993 };
7994
7995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
7996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7997 if (SWIG_arg_fail(1)) SWIG_fail;
7998 {
7999 wxString* sptr = wxString_in_helper(obj1);
8000 if (sptr == NULL) SWIG_fail;
8001 arg2 = *sptr;
8002 delete sptr;
8003 }
8004 {
8005 PyThreadState* __tstate = wxPyBeginAllowThreads();
8006 (arg1)->SetFaceName(arg2);
8007
8008 wxPyEndAllowThreads(__tstate);
8009 if (PyErr_Occurred()) SWIG_fail;
8010 }
8011 Py_INCREF(Py_None); resultobj = Py_None;
8012 return resultobj;
8013 fail:
8014 return NULL;
8015 }
8016
8017
8018 static PyObject *_wrap_NativeFontInfo_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
8019 PyObject *resultobj;
8020 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8021 wxFontFamily arg2 ;
8022 PyObject * obj0 = 0 ;
8023 PyObject * obj1 = 0 ;
8024 char *kwnames[] = {
8025 (char *) "self",(char *) "family", NULL
8026 };
8027
8028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFamily",kwnames,&obj0,&obj1)) goto fail;
8029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8030 if (SWIG_arg_fail(1)) SWIG_fail;
8031 {
8032 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
8033 if (SWIG_arg_fail(2)) SWIG_fail;
8034 }
8035 {
8036 PyThreadState* __tstate = wxPyBeginAllowThreads();
8037 (arg1)->SetFamily((wxFontFamily )arg2);
8038
8039 wxPyEndAllowThreads(__tstate);
8040 if (PyErr_Occurred()) SWIG_fail;
8041 }
8042 Py_INCREF(Py_None); resultobj = Py_None;
8043 return resultobj;
8044 fail:
8045 return NULL;
8046 }
8047
8048
8049 static PyObject *_wrap_NativeFontInfo_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8050 PyObject *resultobj;
8051 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8052 wxFontEncoding arg2 ;
8053 PyObject * obj0 = 0 ;
8054 PyObject * obj1 = 0 ;
8055 char *kwnames[] = {
8056 (char *) "self",(char *) "encoding", NULL
8057 };
8058
8059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
8060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8061 if (SWIG_arg_fail(1)) SWIG_fail;
8062 {
8063 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8064 if (SWIG_arg_fail(2)) SWIG_fail;
8065 }
8066 {
8067 PyThreadState* __tstate = wxPyBeginAllowThreads();
8068 (arg1)->SetEncoding((wxFontEncoding )arg2);
8069
8070 wxPyEndAllowThreads(__tstate);
8071 if (PyErr_Occurred()) SWIG_fail;
8072 }
8073 Py_INCREF(Py_None); resultobj = Py_None;
8074 return resultobj;
8075 fail:
8076 return NULL;
8077 }
8078
8079
8080 static PyObject *_wrap_NativeFontInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
8081 PyObject *resultobj;
8082 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8083 wxString *arg2 = 0 ;
8084 bool result;
8085 bool temp2 = false ;
8086 PyObject * obj0 = 0 ;
8087 PyObject * obj1 = 0 ;
8088 char *kwnames[] = {
8089 (char *) "self",(char *) "s", NULL
8090 };
8091
8092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
8093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8094 if (SWIG_arg_fail(1)) SWIG_fail;
8095 {
8096 arg2 = wxString_in_helper(obj1);
8097 if (arg2 == NULL) SWIG_fail;
8098 temp2 = true;
8099 }
8100 {
8101 PyThreadState* __tstate = wxPyBeginAllowThreads();
8102 result = (bool)(arg1)->FromString((wxString const &)*arg2);
8103
8104 wxPyEndAllowThreads(__tstate);
8105 if (PyErr_Occurred()) SWIG_fail;
8106 }
8107 {
8108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8109 }
8110 {
8111 if (temp2)
8112 delete arg2;
8113 }
8114 return resultobj;
8115 fail:
8116 {
8117 if (temp2)
8118 delete arg2;
8119 }
8120 return NULL;
8121 }
8122
8123
8124 static PyObject *_wrap_NativeFontInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
8125 PyObject *resultobj;
8126 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8127 wxString result;
8128 PyObject * obj0 = 0 ;
8129 char *kwnames[] = {
8130 (char *) "self", NULL
8131 };
8132
8133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToString",kwnames,&obj0)) goto fail;
8134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8135 if (SWIG_arg_fail(1)) SWIG_fail;
8136 {
8137 PyThreadState* __tstate = wxPyBeginAllowThreads();
8138 result = ((wxNativeFontInfo const *)arg1)->ToString();
8139
8140 wxPyEndAllowThreads(__tstate);
8141 if (PyErr_Occurred()) SWIG_fail;
8142 }
8143 {
8144 #if wxUSE_UNICODE
8145 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8146 #else
8147 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8148 #endif
8149 }
8150 return resultobj;
8151 fail:
8152 return NULL;
8153 }
8154
8155
8156 static PyObject *_wrap_NativeFontInfo___str__(PyObject *, PyObject *args, PyObject *kwargs) {
8157 PyObject *resultobj;
8158 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8159 wxString result;
8160 PyObject * obj0 = 0 ;
8161 char *kwnames[] = {
8162 (char *) "self", NULL
8163 };
8164
8165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo___str__",kwnames,&obj0)) goto fail;
8166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8167 if (SWIG_arg_fail(1)) SWIG_fail;
8168 {
8169 PyThreadState* __tstate = wxPyBeginAllowThreads();
8170 result = wxNativeFontInfo___str__(arg1);
8171
8172 wxPyEndAllowThreads(__tstate);
8173 if (PyErr_Occurred()) SWIG_fail;
8174 }
8175 {
8176 #if wxUSE_UNICODE
8177 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8178 #else
8179 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8180 #endif
8181 }
8182 return resultobj;
8183 fail:
8184 return NULL;
8185 }
8186
8187
8188 static PyObject *_wrap_NativeFontInfo_FromUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8189 PyObject *resultobj;
8190 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8191 wxString *arg2 = 0 ;
8192 bool result;
8193 bool temp2 = false ;
8194 PyObject * obj0 = 0 ;
8195 PyObject * obj1 = 0 ;
8196 char *kwnames[] = {
8197 (char *) "self",(char *) "s", NULL
8198 };
8199
8200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromUserString",kwnames,&obj0,&obj1)) goto fail;
8201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8202 if (SWIG_arg_fail(1)) SWIG_fail;
8203 {
8204 arg2 = wxString_in_helper(obj1);
8205 if (arg2 == NULL) SWIG_fail;
8206 temp2 = true;
8207 }
8208 {
8209 PyThreadState* __tstate = wxPyBeginAllowThreads();
8210 result = (bool)(arg1)->FromUserString((wxString const &)*arg2);
8211
8212 wxPyEndAllowThreads(__tstate);
8213 if (PyErr_Occurred()) SWIG_fail;
8214 }
8215 {
8216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8217 }
8218 {
8219 if (temp2)
8220 delete arg2;
8221 }
8222 return resultobj;
8223 fail:
8224 {
8225 if (temp2)
8226 delete arg2;
8227 }
8228 return NULL;
8229 }
8230
8231
8232 static PyObject *_wrap_NativeFontInfo_ToUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8233 PyObject *resultobj;
8234 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8235 wxString result;
8236 PyObject * obj0 = 0 ;
8237 char *kwnames[] = {
8238 (char *) "self", NULL
8239 };
8240
8241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToUserString",kwnames,&obj0)) goto fail;
8242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8243 if (SWIG_arg_fail(1)) SWIG_fail;
8244 {
8245 PyThreadState* __tstate = wxPyBeginAllowThreads();
8246 result = ((wxNativeFontInfo const *)arg1)->ToUserString();
8247
8248 wxPyEndAllowThreads(__tstate);
8249 if (PyErr_Occurred()) SWIG_fail;
8250 }
8251 {
8252 #if wxUSE_UNICODE
8253 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8254 #else
8255 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8256 #endif
8257 }
8258 return resultobj;
8259 fail:
8260 return NULL;
8261 }
8262
8263
8264 static PyObject * NativeFontInfo_swigregister(PyObject *, PyObject *args) {
8265 PyObject *obj;
8266 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8267 SWIG_TypeClientData(SWIGTYPE_p_wxNativeFontInfo, obj);
8268 Py_INCREF(obj);
8269 return Py_BuildValue((char *)"");
8270 }
8271 static PyObject *_wrap_NativeEncodingInfo_facename_set(PyObject *, PyObject *args, PyObject *kwargs) {
8272 PyObject *resultobj;
8273 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8274 wxString *arg2 = (wxString *) 0 ;
8275 bool temp2 = false ;
8276 PyObject * obj0 = 0 ;
8277 PyObject * obj1 = 0 ;
8278 char *kwnames[] = {
8279 (char *) "self",(char *) "facename", NULL
8280 };
8281
8282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_facename_set",kwnames,&obj0,&obj1)) goto fail;
8283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8284 if (SWIG_arg_fail(1)) SWIG_fail;
8285 {
8286 arg2 = wxString_in_helper(obj1);
8287 if (arg2 == NULL) SWIG_fail;
8288 temp2 = true;
8289 }
8290 if (arg1) (arg1)->facename = *arg2;
8291
8292 Py_INCREF(Py_None); resultobj = Py_None;
8293 {
8294 if (temp2)
8295 delete arg2;
8296 }
8297 return resultobj;
8298 fail:
8299 {
8300 if (temp2)
8301 delete arg2;
8302 }
8303 return NULL;
8304 }
8305
8306
8307 static PyObject *_wrap_NativeEncodingInfo_facename_get(PyObject *, PyObject *args, PyObject *kwargs) {
8308 PyObject *resultobj;
8309 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8310 wxString *result;
8311 PyObject * obj0 = 0 ;
8312 char *kwnames[] = {
8313 (char *) "self", NULL
8314 };
8315
8316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_facename_get",kwnames,&obj0)) goto fail;
8317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8318 if (SWIG_arg_fail(1)) SWIG_fail;
8319 result = (wxString *)& ((arg1)->facename);
8320
8321 {
8322 #if wxUSE_UNICODE
8323 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8324 #else
8325 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8326 #endif
8327 }
8328 return resultobj;
8329 fail:
8330 return NULL;
8331 }
8332
8333
8334 static PyObject *_wrap_NativeEncodingInfo_encoding_set(PyObject *, PyObject *args, PyObject *kwargs) {
8335 PyObject *resultobj;
8336 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8337 wxFontEncoding arg2 ;
8338 PyObject * obj0 = 0 ;
8339 PyObject * obj1 = 0 ;
8340 char *kwnames[] = {
8341 (char *) "self",(char *) "encoding", NULL
8342 };
8343
8344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_encoding_set",kwnames,&obj0,&obj1)) goto fail;
8345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8346 if (SWIG_arg_fail(1)) SWIG_fail;
8347 {
8348 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8349 if (SWIG_arg_fail(2)) SWIG_fail;
8350 }
8351 if (arg1) (arg1)->encoding = (wxFontEncoding )arg2;
8352
8353 Py_INCREF(Py_None); resultobj = Py_None;
8354 return resultobj;
8355 fail:
8356 return NULL;
8357 }
8358
8359
8360 static PyObject *_wrap_NativeEncodingInfo_encoding_get(PyObject *, PyObject *args, PyObject *kwargs) {
8361 PyObject *resultobj;
8362 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8363 wxFontEncoding result;
8364 PyObject * obj0 = 0 ;
8365 char *kwnames[] = {
8366 (char *) "self", NULL
8367 };
8368
8369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_encoding_get",kwnames,&obj0)) goto fail;
8370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8371 if (SWIG_arg_fail(1)) SWIG_fail;
8372 result = (wxFontEncoding) ((arg1)->encoding);
8373
8374 resultobj = SWIG_From_int((result));
8375 return resultobj;
8376 fail:
8377 return NULL;
8378 }
8379
8380
8381 static PyObject *_wrap_new_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8382 PyObject *resultobj;
8383 wxNativeEncodingInfo *result;
8384 char *kwnames[] = {
8385 NULL
8386 };
8387
8388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeEncodingInfo",kwnames)) goto fail;
8389 {
8390 PyThreadState* __tstate = wxPyBeginAllowThreads();
8391 result = (wxNativeEncodingInfo *)new wxNativeEncodingInfo();
8392
8393 wxPyEndAllowThreads(__tstate);
8394 if (PyErr_Occurred()) SWIG_fail;
8395 }
8396 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 1);
8397 return resultobj;
8398 fail:
8399 return NULL;
8400 }
8401
8402
8403 static PyObject *_wrap_delete_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8404 PyObject *resultobj;
8405 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8406 PyObject * obj0 = 0 ;
8407 char *kwnames[] = {
8408 (char *) "self", NULL
8409 };
8410
8411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeEncodingInfo",kwnames,&obj0)) goto fail;
8412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8413 if (SWIG_arg_fail(1)) SWIG_fail;
8414 {
8415 PyThreadState* __tstate = wxPyBeginAllowThreads();
8416 delete arg1;
8417
8418 wxPyEndAllowThreads(__tstate);
8419 if (PyErr_Occurred()) SWIG_fail;
8420 }
8421 Py_INCREF(Py_None); resultobj = Py_None;
8422 return resultobj;
8423 fail:
8424 return NULL;
8425 }
8426
8427
8428 static PyObject *_wrap_NativeEncodingInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
8429 PyObject *resultobj;
8430 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8431 wxString *arg2 = 0 ;
8432 bool result;
8433 bool temp2 = false ;
8434 PyObject * obj0 = 0 ;
8435 PyObject * obj1 = 0 ;
8436 char *kwnames[] = {
8437 (char *) "self",(char *) "s", NULL
8438 };
8439
8440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
8441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8442 if (SWIG_arg_fail(1)) SWIG_fail;
8443 {
8444 arg2 = wxString_in_helper(obj1);
8445 if (arg2 == NULL) SWIG_fail;
8446 temp2 = true;
8447 }
8448 {
8449 PyThreadState* __tstate = wxPyBeginAllowThreads();
8450 result = (bool)(arg1)->FromString((wxString const &)*arg2);
8451
8452 wxPyEndAllowThreads(__tstate);
8453 if (PyErr_Occurred()) SWIG_fail;
8454 }
8455 {
8456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8457 }
8458 {
8459 if (temp2)
8460 delete arg2;
8461 }
8462 return resultobj;
8463 fail:
8464 {
8465 if (temp2)
8466 delete arg2;
8467 }
8468 return NULL;
8469 }
8470
8471
8472 static PyObject *_wrap_NativeEncodingInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
8473 PyObject *resultobj;
8474 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8475 wxString result;
8476 PyObject * obj0 = 0 ;
8477 char *kwnames[] = {
8478 (char *) "self", NULL
8479 };
8480
8481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_ToString",kwnames,&obj0)) goto fail;
8482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8483 if (SWIG_arg_fail(1)) SWIG_fail;
8484 {
8485 PyThreadState* __tstate = wxPyBeginAllowThreads();
8486 result = ((wxNativeEncodingInfo const *)arg1)->ToString();
8487
8488 wxPyEndAllowThreads(__tstate);
8489 if (PyErr_Occurred()) SWIG_fail;
8490 }
8491 {
8492 #if wxUSE_UNICODE
8493 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8494 #else
8495 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8496 #endif
8497 }
8498 return resultobj;
8499 fail:
8500 return NULL;
8501 }
8502
8503
8504 static PyObject * NativeEncodingInfo_swigregister(PyObject *, PyObject *args) {
8505 PyObject *obj;
8506 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8507 SWIG_TypeClientData(SWIGTYPE_p_wxNativeEncodingInfo, obj);
8508 Py_INCREF(obj);
8509 return Py_BuildValue((char *)"");
8510 }
8511 static PyObject *_wrap_GetNativeFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8512 PyObject *resultobj;
8513 wxFontEncoding arg1 ;
8514 wxNativeEncodingInfo *result;
8515 PyObject * obj0 = 0 ;
8516 char *kwnames[] = {
8517 (char *) "encoding", NULL
8518 };
8519
8520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetNativeFontEncoding",kwnames,&obj0)) goto fail;
8521 {
8522 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8523 if (SWIG_arg_fail(1)) SWIG_fail;
8524 }
8525 {
8526 PyThreadState* __tstate = wxPyBeginAllowThreads();
8527 result = (wxNativeEncodingInfo *)wxGetNativeFontEncoding((wxFontEncoding )arg1);
8528
8529 wxPyEndAllowThreads(__tstate);
8530 if (PyErr_Occurred()) SWIG_fail;
8531 }
8532 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 0);
8533 return resultobj;
8534 fail:
8535 return NULL;
8536 }
8537
8538
8539 static PyObject *_wrap_TestFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8540 PyObject *resultobj;
8541 wxNativeEncodingInfo *arg1 = 0 ;
8542 bool result;
8543 PyObject * obj0 = 0 ;
8544 char *kwnames[] = {
8545 (char *) "info", NULL
8546 };
8547
8548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TestFontEncoding",kwnames,&obj0)) goto fail;
8549 {
8550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8551 if (SWIG_arg_fail(1)) SWIG_fail;
8552 if (arg1 == NULL) {
8553 SWIG_null_ref("wxNativeEncodingInfo");
8554 }
8555 if (SWIG_arg_fail(1)) SWIG_fail;
8556 }
8557 {
8558 PyThreadState* __tstate = wxPyBeginAllowThreads();
8559 result = (bool)wxTestFontEncoding((wxNativeEncodingInfo const &)*arg1);
8560
8561 wxPyEndAllowThreads(__tstate);
8562 if (PyErr_Occurred()) SWIG_fail;
8563 }
8564 {
8565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8566 }
8567 return resultobj;
8568 fail:
8569 return NULL;
8570 }
8571
8572
8573 static PyObject *_wrap_new_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
8574 PyObject *resultobj;
8575 wxFontMapper *result;
8576 char *kwnames[] = {
8577 NULL
8578 };
8579
8580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontMapper",kwnames)) goto fail;
8581 {
8582 PyThreadState* __tstate = wxPyBeginAllowThreads();
8583 result = (wxFontMapper *)new wxFontMapper();
8584
8585 wxPyEndAllowThreads(__tstate);
8586 if (PyErr_Occurred()) SWIG_fail;
8587 }
8588 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 1);
8589 return resultobj;
8590 fail:
8591 return NULL;
8592 }
8593
8594
8595 static PyObject *_wrap_delete_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
8596 PyObject *resultobj;
8597 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8598 PyObject * obj0 = 0 ;
8599 char *kwnames[] = {
8600 (char *) "self", NULL
8601 };
8602
8603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontMapper",kwnames,&obj0)) goto fail;
8604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8605 if (SWIG_arg_fail(1)) SWIG_fail;
8606 {
8607 PyThreadState* __tstate = wxPyBeginAllowThreads();
8608 delete arg1;
8609
8610 wxPyEndAllowThreads(__tstate);
8611 if (PyErr_Occurred()) SWIG_fail;
8612 }
8613 Py_INCREF(Py_None); resultobj = Py_None;
8614 return resultobj;
8615 fail:
8616 return NULL;
8617 }
8618
8619
8620 static PyObject *_wrap_FontMapper_Get(PyObject *, PyObject *args, PyObject *kwargs) {
8621 PyObject *resultobj;
8622 wxFontMapper *result;
8623 char *kwnames[] = {
8624 NULL
8625 };
8626
8627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_Get",kwnames)) goto fail;
8628 {
8629 PyThreadState* __tstate = wxPyBeginAllowThreads();
8630 result = (wxFontMapper *)wxFontMapper::Get();
8631
8632 wxPyEndAllowThreads(__tstate);
8633 if (PyErr_Occurred()) SWIG_fail;
8634 }
8635 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
8636 return resultobj;
8637 fail:
8638 return NULL;
8639 }
8640
8641
8642 static PyObject *_wrap_FontMapper_Set(PyObject *, PyObject *args, PyObject *kwargs) {
8643 PyObject *resultobj;
8644 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8645 wxFontMapper *result;
8646 PyObject * obj0 = 0 ;
8647 char *kwnames[] = {
8648 (char *) "mapper", NULL
8649 };
8650
8651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_Set",kwnames,&obj0)) goto fail;
8652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8653 if (SWIG_arg_fail(1)) SWIG_fail;
8654 {
8655 PyThreadState* __tstate = wxPyBeginAllowThreads();
8656 result = (wxFontMapper *)wxFontMapper::Set(arg1);
8657
8658 wxPyEndAllowThreads(__tstate);
8659 if (PyErr_Occurred()) SWIG_fail;
8660 }
8661 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
8662 return resultobj;
8663 fail:
8664 return NULL;
8665 }
8666
8667
8668 static PyObject *_wrap_FontMapper_CharsetToEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8669 PyObject *resultobj;
8670 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8671 wxString *arg2 = 0 ;
8672 bool arg3 = (bool) true ;
8673 wxFontEncoding result;
8674 bool temp2 = false ;
8675 PyObject * obj0 = 0 ;
8676 PyObject * obj1 = 0 ;
8677 PyObject * obj2 = 0 ;
8678 char *kwnames[] = {
8679 (char *) "self",(char *) "charset",(char *) "interactive", NULL
8680 };
8681
8682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_CharsetToEncoding",kwnames,&obj0,&obj1,&obj2)) goto fail;
8683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8684 if (SWIG_arg_fail(1)) SWIG_fail;
8685 {
8686 arg2 = wxString_in_helper(obj1);
8687 if (arg2 == NULL) SWIG_fail;
8688 temp2 = true;
8689 }
8690 if (obj2) {
8691 {
8692 arg3 = (bool)(SWIG_As_bool(obj2));
8693 if (SWIG_arg_fail(3)) SWIG_fail;
8694 }
8695 }
8696 {
8697 PyThreadState* __tstate = wxPyBeginAllowThreads();
8698 result = (wxFontEncoding)(arg1)->CharsetToEncoding((wxString const &)*arg2,arg3);
8699
8700 wxPyEndAllowThreads(__tstate);
8701 if (PyErr_Occurred()) SWIG_fail;
8702 }
8703 resultobj = SWIG_From_int((result));
8704 {
8705 if (temp2)
8706 delete arg2;
8707 }
8708 return resultobj;
8709 fail:
8710 {
8711 if (temp2)
8712 delete arg2;
8713 }
8714 return NULL;
8715 }
8716
8717
8718 static PyObject *_wrap_FontMapper_GetSupportedEncodingsCount(PyObject *, PyObject *args, PyObject *kwargs) {
8719 PyObject *resultobj;
8720 size_t result;
8721 char *kwnames[] = {
8722 NULL
8723 };
8724
8725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetSupportedEncodingsCount",kwnames)) goto fail;
8726 {
8727 PyThreadState* __tstate = wxPyBeginAllowThreads();
8728 result = (size_t)wxFontMapper::GetSupportedEncodingsCount();
8729
8730 wxPyEndAllowThreads(__tstate);
8731 if (PyErr_Occurred()) SWIG_fail;
8732 }
8733 {
8734 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
8735 }
8736 return resultobj;
8737 fail:
8738 return NULL;
8739 }
8740
8741
8742 static PyObject *_wrap_FontMapper_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8743 PyObject *resultobj;
8744 size_t arg1 ;
8745 wxFontEncoding result;
8746 PyObject * obj0 = 0 ;
8747 char *kwnames[] = {
8748 (char *) "n", NULL
8749 };
8750
8751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncoding",kwnames,&obj0)) goto fail;
8752 {
8753 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8754 if (SWIG_arg_fail(1)) SWIG_fail;
8755 }
8756 {
8757 PyThreadState* __tstate = wxPyBeginAllowThreads();
8758 result = (wxFontEncoding)wxFontMapper::GetEncoding(arg1);
8759
8760 wxPyEndAllowThreads(__tstate);
8761 if (PyErr_Occurred()) SWIG_fail;
8762 }
8763 resultobj = SWIG_From_int((result));
8764 return resultobj;
8765 fail:
8766 return NULL;
8767 }
8768
8769
8770 static PyObject *_wrap_FontMapper_GetEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
8771 PyObject *resultobj;
8772 wxFontEncoding arg1 ;
8773 wxString result;
8774 PyObject * obj0 = 0 ;
8775 char *kwnames[] = {
8776 (char *) "encoding", NULL
8777 };
8778
8779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingName",kwnames,&obj0)) goto fail;
8780 {
8781 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8782 if (SWIG_arg_fail(1)) SWIG_fail;
8783 }
8784 {
8785 PyThreadState* __tstate = wxPyBeginAllowThreads();
8786 result = wxFontMapper::GetEncodingName((wxFontEncoding )arg1);
8787
8788 wxPyEndAllowThreads(__tstate);
8789 if (PyErr_Occurred()) SWIG_fail;
8790 }
8791 {
8792 #if wxUSE_UNICODE
8793 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8794 #else
8795 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8796 #endif
8797 }
8798 return resultobj;
8799 fail:
8800 return NULL;
8801 }
8802
8803
8804 static PyObject *_wrap_FontMapper_GetEncodingDescription(PyObject *, PyObject *args, PyObject *kwargs) {
8805 PyObject *resultobj;
8806 wxFontEncoding arg1 ;
8807 wxString result;
8808 PyObject * obj0 = 0 ;
8809 char *kwnames[] = {
8810 (char *) "encoding", NULL
8811 };
8812
8813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingDescription",kwnames,&obj0)) goto fail;
8814 {
8815 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8816 if (SWIG_arg_fail(1)) SWIG_fail;
8817 }
8818 {
8819 PyThreadState* __tstate = wxPyBeginAllowThreads();
8820 result = wxFontMapper::GetEncodingDescription((wxFontEncoding )arg1);
8821
8822 wxPyEndAllowThreads(__tstate);
8823 if (PyErr_Occurred()) SWIG_fail;
8824 }
8825 {
8826 #if wxUSE_UNICODE
8827 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8828 #else
8829 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8830 #endif
8831 }
8832 return resultobj;
8833 fail:
8834 return NULL;
8835 }
8836
8837
8838 static PyObject *_wrap_FontMapper_GetEncodingFromName(PyObject *, PyObject *args, PyObject *kwargs) {
8839 PyObject *resultobj;
8840 wxString *arg1 = 0 ;
8841 wxFontEncoding result;
8842 bool temp1 = false ;
8843 PyObject * obj0 = 0 ;
8844 char *kwnames[] = {
8845 (char *) "name", NULL
8846 };
8847
8848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingFromName",kwnames,&obj0)) goto fail;
8849 {
8850 arg1 = wxString_in_helper(obj0);
8851 if (arg1 == NULL) SWIG_fail;
8852 temp1 = true;
8853 }
8854 {
8855 PyThreadState* __tstate = wxPyBeginAllowThreads();
8856 result = (wxFontEncoding)wxFontMapper::GetEncodingFromName((wxString const &)*arg1);
8857
8858 wxPyEndAllowThreads(__tstate);
8859 if (PyErr_Occurred()) SWIG_fail;
8860 }
8861 resultobj = SWIG_From_int((result));
8862 {
8863 if (temp1)
8864 delete arg1;
8865 }
8866 return resultobj;
8867 fail:
8868 {
8869 if (temp1)
8870 delete arg1;
8871 }
8872 return NULL;
8873 }
8874
8875
8876 static PyObject *_wrap_FontMapper_SetConfig(PyObject *, PyObject *args, PyObject *kwargs) {
8877 PyObject *resultobj;
8878 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8879 wxConfigBase *arg2 = (wxConfigBase *) 0 ;
8880 PyObject * obj0 = 0 ;
8881 PyObject * obj1 = 0 ;
8882 char *kwnames[] = {
8883 (char *) "self",(char *) "config", NULL
8884 };
8885
8886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfig",kwnames,&obj0,&obj1)) goto fail;
8887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8888 if (SWIG_arg_fail(1)) SWIG_fail;
8889 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
8890 if (SWIG_arg_fail(2)) SWIG_fail;
8891 {
8892 PyThreadState* __tstate = wxPyBeginAllowThreads();
8893 (arg1)->SetConfig(arg2);
8894
8895 wxPyEndAllowThreads(__tstate);
8896 if (PyErr_Occurred()) SWIG_fail;
8897 }
8898 Py_INCREF(Py_None); resultobj = Py_None;
8899 return resultobj;
8900 fail:
8901 return NULL;
8902 }
8903
8904
8905 static PyObject *_wrap_FontMapper_SetConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
8906 PyObject *resultobj;
8907 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8908 wxString *arg2 = 0 ;
8909 bool temp2 = false ;
8910 PyObject * obj0 = 0 ;
8911 PyObject * obj1 = 0 ;
8912 char *kwnames[] = {
8913 (char *) "self",(char *) "prefix", NULL
8914 };
8915
8916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfigPath",kwnames,&obj0,&obj1)) goto fail;
8917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8918 if (SWIG_arg_fail(1)) SWIG_fail;
8919 {
8920 arg2 = wxString_in_helper(obj1);
8921 if (arg2 == NULL) SWIG_fail;
8922 temp2 = true;
8923 }
8924 {
8925 PyThreadState* __tstate = wxPyBeginAllowThreads();
8926 (arg1)->SetConfigPath((wxString const &)*arg2);
8927
8928 wxPyEndAllowThreads(__tstate);
8929 if (PyErr_Occurred()) SWIG_fail;
8930 }
8931 Py_INCREF(Py_None); resultobj = Py_None;
8932 {
8933 if (temp2)
8934 delete arg2;
8935 }
8936 return resultobj;
8937 fail:
8938 {
8939 if (temp2)
8940 delete arg2;
8941 }
8942 return NULL;
8943 }
8944
8945
8946 static PyObject *_wrap_FontMapper_GetDefaultConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
8947 PyObject *resultobj;
8948 wxString result;
8949 char *kwnames[] = {
8950 NULL
8951 };
8952
8953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetDefaultConfigPath",kwnames)) goto fail;
8954 {
8955 PyThreadState* __tstate = wxPyBeginAllowThreads();
8956 result = wxFontMapper::GetDefaultConfigPath();
8957
8958 wxPyEndAllowThreads(__tstate);
8959 if (PyErr_Occurred()) SWIG_fail;
8960 }
8961 {
8962 #if wxUSE_UNICODE
8963 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8964 #else
8965 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8966 #endif
8967 }
8968 return resultobj;
8969 fail:
8970 return NULL;
8971 }
8972
8973
8974 static PyObject *_wrap_FontMapper_GetAltForEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8975 PyObject *resultobj;
8976 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8977 wxFontEncoding arg2 ;
8978 wxString const &arg3_defvalue = wxPyEmptyString ;
8979 wxString *arg3 = (wxString *) &arg3_defvalue ;
8980 bool arg4 = (bool) true ;
8981 PyObject *result;
8982 bool temp3 = false ;
8983 PyObject * obj0 = 0 ;
8984 PyObject * obj1 = 0 ;
8985 PyObject * obj2 = 0 ;
8986 PyObject * obj3 = 0 ;
8987 char *kwnames[] = {
8988 (char *) "self",(char *) "encoding",(char *) "facename",(char *) "interactive", NULL
8989 };
8990
8991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:FontMapper_GetAltForEncoding",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8993 if (SWIG_arg_fail(1)) SWIG_fail;
8994 {
8995 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8996 if (SWIG_arg_fail(2)) SWIG_fail;
8997 }
8998 if (obj2) {
8999 {
9000 arg3 = wxString_in_helper(obj2);
9001 if (arg3 == NULL) SWIG_fail;
9002 temp3 = true;
9003 }
9004 }
9005 if (obj3) {
9006 {
9007 arg4 = (bool)(SWIG_As_bool(obj3));
9008 if (SWIG_arg_fail(4)) SWIG_fail;
9009 }
9010 }
9011 {
9012 PyThreadState* __tstate = wxPyBeginAllowThreads();
9013 result = (PyObject *)wxFontMapper_GetAltForEncoding(arg1,(wxFontEncoding )arg2,(wxString const &)*arg3,arg4);
9014
9015 wxPyEndAllowThreads(__tstate);
9016 if (PyErr_Occurred()) SWIG_fail;
9017 }
9018 resultobj = result;
9019 {
9020 if (temp3)
9021 delete arg3;
9022 }
9023 return resultobj;
9024 fail:
9025 {
9026 if (temp3)
9027 delete arg3;
9028 }
9029 return NULL;
9030 }
9031
9032
9033 static PyObject *_wrap_FontMapper_IsEncodingAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
9034 PyObject *resultobj;
9035 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9036 wxFontEncoding arg2 ;
9037 wxString const &arg3_defvalue = wxPyEmptyString ;
9038 wxString *arg3 = (wxString *) &arg3_defvalue ;
9039 bool result;
9040 bool temp3 = false ;
9041 PyObject * obj0 = 0 ;
9042 PyObject * obj1 = 0 ;
9043 PyObject * obj2 = 0 ;
9044 char *kwnames[] = {
9045 (char *) "self",(char *) "encoding",(char *) "facename", NULL
9046 };
9047
9048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_IsEncodingAvailable",kwnames,&obj0,&obj1,&obj2)) goto fail;
9049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9050 if (SWIG_arg_fail(1)) SWIG_fail;
9051 {
9052 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9053 if (SWIG_arg_fail(2)) SWIG_fail;
9054 }
9055 if (obj2) {
9056 {
9057 arg3 = wxString_in_helper(obj2);
9058 if (arg3 == NULL) SWIG_fail;
9059 temp3 = true;
9060 }
9061 }
9062 {
9063 PyThreadState* __tstate = wxPyBeginAllowThreads();
9064 result = (bool)(arg1)->IsEncodingAvailable((wxFontEncoding )arg2,(wxString const &)*arg3);
9065
9066 wxPyEndAllowThreads(__tstate);
9067 if (PyErr_Occurred()) SWIG_fail;
9068 }
9069 {
9070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9071 }
9072 {
9073 if (temp3)
9074 delete arg3;
9075 }
9076 return resultobj;
9077 fail:
9078 {
9079 if (temp3)
9080 delete arg3;
9081 }
9082 return NULL;
9083 }
9084
9085
9086 static PyObject *_wrap_FontMapper_SetDialogParent(PyObject *, PyObject *args, PyObject *kwargs) {
9087 PyObject *resultobj;
9088 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9089 wxWindow *arg2 = (wxWindow *) 0 ;
9090 PyObject * obj0 = 0 ;
9091 PyObject * obj1 = 0 ;
9092 char *kwnames[] = {
9093 (char *) "self",(char *) "parent", NULL
9094 };
9095
9096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogParent",kwnames,&obj0,&obj1)) goto fail;
9097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9098 if (SWIG_arg_fail(1)) SWIG_fail;
9099 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
9100 if (SWIG_arg_fail(2)) SWIG_fail;
9101 {
9102 PyThreadState* __tstate = wxPyBeginAllowThreads();
9103 (arg1)->SetDialogParent(arg2);
9104
9105 wxPyEndAllowThreads(__tstate);
9106 if (PyErr_Occurred()) SWIG_fail;
9107 }
9108 Py_INCREF(Py_None); resultobj = Py_None;
9109 return resultobj;
9110 fail:
9111 return NULL;
9112 }
9113
9114
9115 static PyObject *_wrap_FontMapper_SetDialogTitle(PyObject *, PyObject *args, PyObject *kwargs) {
9116 PyObject *resultobj;
9117 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9118 wxString *arg2 = 0 ;
9119 bool temp2 = false ;
9120 PyObject * obj0 = 0 ;
9121 PyObject * obj1 = 0 ;
9122 char *kwnames[] = {
9123 (char *) "self",(char *) "title", NULL
9124 };
9125
9126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogTitle",kwnames,&obj0,&obj1)) goto fail;
9127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9128 if (SWIG_arg_fail(1)) SWIG_fail;
9129 {
9130 arg2 = wxString_in_helper(obj1);
9131 if (arg2 == NULL) SWIG_fail;
9132 temp2 = true;
9133 }
9134 {
9135 PyThreadState* __tstate = wxPyBeginAllowThreads();
9136 (arg1)->SetDialogTitle((wxString const &)*arg2);
9137
9138 wxPyEndAllowThreads(__tstate);
9139 if (PyErr_Occurred()) SWIG_fail;
9140 }
9141 Py_INCREF(Py_None); resultobj = Py_None;
9142 {
9143 if (temp2)
9144 delete arg2;
9145 }
9146 return resultobj;
9147 fail:
9148 {
9149 if (temp2)
9150 delete arg2;
9151 }
9152 return NULL;
9153 }
9154
9155
9156 static PyObject * FontMapper_swigregister(PyObject *, PyObject *args) {
9157 PyObject *obj;
9158 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9159 SWIG_TypeClientData(SWIGTYPE_p_wxFontMapper, obj);
9160 Py_INCREF(obj);
9161 return Py_BuildValue((char *)"");
9162 }
9163 static PyObject *_wrap_new_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9164 PyObject *resultobj;
9165 int arg1 ;
9166 int arg2 ;
9167 int arg3 ;
9168 int arg4 ;
9169 bool arg5 = (bool) false ;
9170 wxString const &arg6_defvalue = wxPyEmptyString ;
9171 wxString *arg6 = (wxString *) &arg6_defvalue ;
9172 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9173 wxFont *result;
9174 bool temp6 = false ;
9175 PyObject * obj0 = 0 ;
9176 PyObject * obj1 = 0 ;
9177 PyObject * obj2 = 0 ;
9178 PyObject * obj3 = 0 ;
9179 PyObject * obj4 = 0 ;
9180 PyObject * obj5 = 0 ;
9181 PyObject * obj6 = 0 ;
9182 char *kwnames[] = {
9183 (char *) "pointSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "face",(char *) "encoding", NULL
9184 };
9185
9186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_Font",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9187 {
9188 arg1 = (int)(SWIG_As_int(obj0));
9189 if (SWIG_arg_fail(1)) SWIG_fail;
9190 }
9191 {
9192 arg2 = (int)(SWIG_As_int(obj1));
9193 if (SWIG_arg_fail(2)) SWIG_fail;
9194 }
9195 {
9196 arg3 = (int)(SWIG_As_int(obj2));
9197 if (SWIG_arg_fail(3)) SWIG_fail;
9198 }
9199 {
9200 arg4 = (int)(SWIG_As_int(obj3));
9201 if (SWIG_arg_fail(4)) SWIG_fail;
9202 }
9203 if (obj4) {
9204 {
9205 arg5 = (bool)(SWIG_As_bool(obj4));
9206 if (SWIG_arg_fail(5)) SWIG_fail;
9207 }
9208 }
9209 if (obj5) {
9210 {
9211 arg6 = wxString_in_helper(obj5);
9212 if (arg6 == NULL) SWIG_fail;
9213 temp6 = true;
9214 }
9215 }
9216 if (obj6) {
9217 {
9218 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
9219 if (SWIG_arg_fail(7)) SWIG_fail;
9220 }
9221 }
9222 {
9223 if (!wxPyCheckForApp()) SWIG_fail;
9224 PyThreadState* __tstate = wxPyBeginAllowThreads();
9225 result = (wxFont *)new wxFont(arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
9226
9227 wxPyEndAllowThreads(__tstate);
9228 if (PyErr_Occurred()) SWIG_fail;
9229 }
9230 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9231 {
9232 if (temp6)
9233 delete arg6;
9234 }
9235 return resultobj;
9236 fail:
9237 {
9238 if (temp6)
9239 delete arg6;
9240 }
9241 return NULL;
9242 }
9243
9244
9245 static PyObject *_wrap_delete_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9246 PyObject *resultobj;
9247 wxFont *arg1 = (wxFont *) 0 ;
9248 PyObject * obj0 = 0 ;
9249 char *kwnames[] = {
9250 (char *) "self", NULL
9251 };
9252
9253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Font",kwnames,&obj0)) goto fail;
9254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9255 if (SWIG_arg_fail(1)) SWIG_fail;
9256 {
9257 PyThreadState* __tstate = wxPyBeginAllowThreads();
9258 delete arg1;
9259
9260 wxPyEndAllowThreads(__tstate);
9261 if (PyErr_Occurred()) SWIG_fail;
9262 }
9263 Py_INCREF(Py_None); resultobj = Py_None;
9264 return resultobj;
9265 fail:
9266 return NULL;
9267 }
9268
9269
9270 static PyObject *_wrap_new_FontFromNativeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9271 PyObject *resultobj;
9272 wxNativeFontInfo *arg1 = 0 ;
9273 wxFont *result;
9274 PyObject * obj0 = 0 ;
9275 char *kwnames[] = {
9276 (char *) "info", NULL
9277 };
9278
9279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfo",kwnames,&obj0)) goto fail;
9280 {
9281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
9282 if (SWIG_arg_fail(1)) SWIG_fail;
9283 if (arg1 == NULL) {
9284 SWIG_null_ref("wxNativeFontInfo");
9285 }
9286 if (SWIG_arg_fail(1)) SWIG_fail;
9287 }
9288 {
9289 if (!wxPyCheckForApp()) SWIG_fail;
9290 PyThreadState* __tstate = wxPyBeginAllowThreads();
9291 result = (wxFont *)new wxFont((wxNativeFontInfo const &)*arg1);
9292
9293 wxPyEndAllowThreads(__tstate);
9294 if (PyErr_Occurred()) SWIG_fail;
9295 }
9296 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9297 return resultobj;
9298 fail:
9299 return NULL;
9300 }
9301
9302
9303 static PyObject *_wrap_new_FontFromNativeInfoString(PyObject *, PyObject *args, PyObject *kwargs) {
9304 PyObject *resultobj;
9305 wxString *arg1 = 0 ;
9306 wxFont *result;
9307 bool temp1 = false ;
9308 PyObject * obj0 = 0 ;
9309 char *kwnames[] = {
9310 (char *) "info", NULL
9311 };
9312
9313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfoString",kwnames,&obj0)) goto fail;
9314 {
9315 arg1 = wxString_in_helper(obj0);
9316 if (arg1 == NULL) SWIG_fail;
9317 temp1 = true;
9318 }
9319 {
9320 if (!wxPyCheckForApp()) SWIG_fail;
9321 PyThreadState* __tstate = wxPyBeginAllowThreads();
9322 result = (wxFont *)new_wxFont((wxString const &)*arg1);
9323
9324 wxPyEndAllowThreads(__tstate);
9325 if (PyErr_Occurred()) SWIG_fail;
9326 }
9327 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9328 {
9329 if (temp1)
9330 delete arg1;
9331 }
9332 return resultobj;
9333 fail:
9334 {
9335 if (temp1)
9336 delete arg1;
9337 }
9338 return NULL;
9339 }
9340
9341
9342 static PyObject *_wrap_new_Font2(PyObject *, PyObject *args, PyObject *kwargs) {
9343 PyObject *resultobj;
9344 int arg1 ;
9345 wxFontFamily arg2 ;
9346 int arg3 = (int) wxFONTFLAG_DEFAULT ;
9347 wxString const &arg4_defvalue = wxPyEmptyString ;
9348 wxString *arg4 = (wxString *) &arg4_defvalue ;
9349 wxFontEncoding arg5 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9350 wxFont *result;
9351 bool temp4 = false ;
9352 PyObject * obj0 = 0 ;
9353 PyObject * obj1 = 0 ;
9354 PyObject * obj2 = 0 ;
9355 PyObject * obj3 = 0 ;
9356 PyObject * obj4 = 0 ;
9357 char *kwnames[] = {
9358 (char *) "pointSize",(char *) "family",(char *) "flags",(char *) "face",(char *) "encoding", NULL
9359 };
9360
9361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_Font2",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
9362 {
9363 arg1 = (int)(SWIG_As_int(obj0));
9364 if (SWIG_arg_fail(1)) SWIG_fail;
9365 }
9366 {
9367 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
9368 if (SWIG_arg_fail(2)) SWIG_fail;
9369 }
9370 if (obj2) {
9371 {
9372 arg3 = (int)(SWIG_As_int(obj2));
9373 if (SWIG_arg_fail(3)) SWIG_fail;
9374 }
9375 }
9376 if (obj3) {
9377 {
9378 arg4 = wxString_in_helper(obj3);
9379 if (arg4 == NULL) SWIG_fail;
9380 temp4 = true;
9381 }
9382 }
9383 if (obj4) {
9384 {
9385 arg5 = (wxFontEncoding)(SWIG_As_int(obj4));
9386 if (SWIG_arg_fail(5)) SWIG_fail;
9387 }
9388 }
9389 {
9390 if (!wxPyCheckForApp()) SWIG_fail;
9391 PyThreadState* __tstate = wxPyBeginAllowThreads();
9392 result = (wxFont *)new_wxFont(arg1,(wxFontFamily )arg2,arg3,(wxString const &)*arg4,(wxFontEncoding )arg5);
9393
9394 wxPyEndAllowThreads(__tstate);
9395 if (PyErr_Occurred()) SWIG_fail;
9396 }
9397 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9398 {
9399 if (temp4)
9400 delete arg4;
9401 }
9402 return resultobj;
9403 fail:
9404 {
9405 if (temp4)
9406 delete arg4;
9407 }
9408 return NULL;
9409 }
9410
9411
9412 static PyObject *_wrap_new_FontFromPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
9413 PyObject *resultobj;
9414 wxSize *arg1 = 0 ;
9415 int arg2 ;
9416 int arg3 ;
9417 int arg4 ;
9418 bool arg5 = (bool) false ;
9419 wxString const &arg6_defvalue = wxEmptyString ;
9420 wxString *arg6 = (wxString *) &arg6_defvalue ;
9421 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9422 wxFont *result;
9423 wxSize temp1 ;
9424 bool temp6 = false ;
9425 PyObject * obj0 = 0 ;
9426 PyObject * obj1 = 0 ;
9427 PyObject * obj2 = 0 ;
9428 PyObject * obj3 = 0 ;
9429 PyObject * obj4 = 0 ;
9430 PyObject * obj5 = 0 ;
9431 PyObject * obj6 = 0 ;
9432 char *kwnames[] = {
9433 (char *) "pixelSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underlined",(char *) "face",(char *) "encoding", NULL
9434 };
9435
9436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_FontFromPixelSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9437 {
9438 arg1 = &temp1;
9439 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
9440 }
9441 {
9442 arg2 = (int)(SWIG_As_int(obj1));
9443 if (SWIG_arg_fail(2)) SWIG_fail;
9444 }
9445 {
9446 arg3 = (int)(SWIG_As_int(obj2));
9447 if (SWIG_arg_fail(3)) SWIG_fail;
9448 }
9449 {
9450 arg4 = (int)(SWIG_As_int(obj3));
9451 if (SWIG_arg_fail(4)) SWIG_fail;
9452 }
9453 if (obj4) {
9454 {
9455 arg5 = (bool)(SWIG_As_bool(obj4));
9456 if (SWIG_arg_fail(5)) SWIG_fail;
9457 }
9458 }
9459 if (obj5) {
9460 {
9461 arg6 = wxString_in_helper(obj5);
9462 if (arg6 == NULL) SWIG_fail;
9463 temp6 = true;
9464 }
9465 }
9466 if (obj6) {
9467 {
9468 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
9469 if (SWIG_arg_fail(7)) SWIG_fail;
9470 }
9471 }
9472 {
9473 if (!wxPyCheckForApp()) SWIG_fail;
9474 PyThreadState* __tstate = wxPyBeginAllowThreads();
9475 result = (wxFont *)new_wxFont((wxSize const &)*arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
9476
9477 wxPyEndAllowThreads(__tstate);
9478 if (PyErr_Occurred()) SWIG_fail;
9479 }
9480 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9481 {
9482 if (temp6)
9483 delete arg6;
9484 }
9485 return resultobj;
9486 fail:
9487 {
9488 if (temp6)
9489 delete arg6;
9490 }
9491 return NULL;
9492 }
9493
9494
9495 static PyObject *_wrap_Font_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
9496 PyObject *resultobj;
9497 wxFont *arg1 = (wxFont *) 0 ;
9498 bool result;
9499 PyObject * obj0 = 0 ;
9500 char *kwnames[] = {
9501 (char *) "self", NULL
9502 };
9503
9504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_Ok",kwnames,&obj0)) goto fail;
9505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9506 if (SWIG_arg_fail(1)) SWIG_fail;
9507 {
9508 PyThreadState* __tstate = wxPyBeginAllowThreads();
9509 result = (bool)((wxFont const *)arg1)->Ok();
9510
9511 wxPyEndAllowThreads(__tstate);
9512 if (PyErr_Occurred()) SWIG_fail;
9513 }
9514 {
9515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9516 }
9517 return resultobj;
9518 fail:
9519 return NULL;
9520 }
9521
9522
9523 static PyObject *_wrap_Font___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
9524 PyObject *resultobj;
9525 wxFont *arg1 = (wxFont *) 0 ;
9526 wxFont *arg2 = (wxFont *) 0 ;
9527 bool result;
9528 PyObject * obj0 = 0 ;
9529 PyObject * obj1 = 0 ;
9530 char *kwnames[] = {
9531 (char *) "self",(char *) "other", NULL
9532 };
9533
9534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___eq__",kwnames,&obj0,&obj1)) goto fail;
9535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9536 if (SWIG_arg_fail(1)) SWIG_fail;
9537 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9538 if (SWIG_arg_fail(2)) SWIG_fail;
9539 {
9540 PyThreadState* __tstate = wxPyBeginAllowThreads();
9541 result = (bool)wxFont___eq__(arg1,(wxFont const *)arg2);
9542
9543 wxPyEndAllowThreads(__tstate);
9544 if (PyErr_Occurred()) SWIG_fail;
9545 }
9546 {
9547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9548 }
9549 return resultobj;
9550 fail:
9551 return NULL;
9552 }
9553
9554
9555 static PyObject *_wrap_Font___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
9556 PyObject *resultobj;
9557 wxFont *arg1 = (wxFont *) 0 ;
9558 wxFont *arg2 = (wxFont *) 0 ;
9559 bool result;
9560 PyObject * obj0 = 0 ;
9561 PyObject * obj1 = 0 ;
9562 char *kwnames[] = {
9563 (char *) "self",(char *) "other", NULL
9564 };
9565
9566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___ne__",kwnames,&obj0,&obj1)) goto fail;
9567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9568 if (SWIG_arg_fail(1)) SWIG_fail;
9569 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9570 if (SWIG_arg_fail(2)) SWIG_fail;
9571 {
9572 PyThreadState* __tstate = wxPyBeginAllowThreads();
9573 result = (bool)wxFont___ne__(arg1,(wxFont const *)arg2);
9574
9575 wxPyEndAllowThreads(__tstate);
9576 if (PyErr_Occurred()) SWIG_fail;
9577 }
9578 {
9579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9580 }
9581 return resultobj;
9582 fail:
9583 return NULL;
9584 }
9585
9586
9587 static PyObject *_wrap_Font_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
9588 PyObject *resultobj;
9589 wxFont *arg1 = (wxFont *) 0 ;
9590 int result;
9591 PyObject * obj0 = 0 ;
9592 char *kwnames[] = {
9593 (char *) "self", NULL
9594 };
9595
9596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPointSize",kwnames,&obj0)) goto fail;
9597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9598 if (SWIG_arg_fail(1)) SWIG_fail;
9599 {
9600 PyThreadState* __tstate = wxPyBeginAllowThreads();
9601 result = (int)((wxFont const *)arg1)->GetPointSize();
9602
9603 wxPyEndAllowThreads(__tstate);
9604 if (PyErr_Occurred()) SWIG_fail;
9605 }
9606 {
9607 resultobj = SWIG_From_int((int)(result));
9608 }
9609 return resultobj;
9610 fail:
9611 return NULL;
9612 }
9613
9614
9615 static PyObject *_wrap_Font_GetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
9616 PyObject *resultobj;
9617 wxFont *arg1 = (wxFont *) 0 ;
9618 wxSize result;
9619 PyObject * obj0 = 0 ;
9620 char *kwnames[] = {
9621 (char *) "self", NULL
9622 };
9623
9624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPixelSize",kwnames,&obj0)) goto fail;
9625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9626 if (SWIG_arg_fail(1)) SWIG_fail;
9627 {
9628 PyThreadState* __tstate = wxPyBeginAllowThreads();
9629 result = ((wxFont const *)arg1)->GetPixelSize();
9630
9631 wxPyEndAllowThreads(__tstate);
9632 if (PyErr_Occurred()) SWIG_fail;
9633 }
9634 {
9635 wxSize * resultptr;
9636 resultptr = new wxSize((wxSize &)(result));
9637 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
9638 }
9639 return resultobj;
9640 fail:
9641 return NULL;
9642 }
9643
9644
9645 static PyObject *_wrap_Font_IsUsingSizeInPixels(PyObject *, PyObject *args, PyObject *kwargs) {
9646 PyObject *resultobj;
9647 wxFont *arg1 = (wxFont *) 0 ;
9648 bool result;
9649 PyObject * obj0 = 0 ;
9650 char *kwnames[] = {
9651 (char *) "self", NULL
9652 };
9653
9654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsUsingSizeInPixels",kwnames,&obj0)) goto fail;
9655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9656 if (SWIG_arg_fail(1)) SWIG_fail;
9657 {
9658 PyThreadState* __tstate = wxPyBeginAllowThreads();
9659 result = (bool)((wxFont const *)arg1)->IsUsingSizeInPixels();
9660
9661 wxPyEndAllowThreads(__tstate);
9662 if (PyErr_Occurred()) SWIG_fail;
9663 }
9664 {
9665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9666 }
9667 return resultobj;
9668 fail:
9669 return NULL;
9670 }
9671
9672
9673 static PyObject *_wrap_Font_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
9674 PyObject *resultobj;
9675 wxFont *arg1 = (wxFont *) 0 ;
9676 int result;
9677 PyObject * obj0 = 0 ;
9678 char *kwnames[] = {
9679 (char *) "self", NULL
9680 };
9681
9682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamily",kwnames,&obj0)) goto fail;
9683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9684 if (SWIG_arg_fail(1)) SWIG_fail;
9685 {
9686 PyThreadState* __tstate = wxPyBeginAllowThreads();
9687 result = (int)((wxFont const *)arg1)->GetFamily();
9688
9689 wxPyEndAllowThreads(__tstate);
9690 if (PyErr_Occurred()) SWIG_fail;
9691 }
9692 {
9693 resultobj = SWIG_From_int((int)(result));
9694 }
9695 return resultobj;
9696 fail:
9697 return NULL;
9698 }
9699
9700
9701 static PyObject *_wrap_Font_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
9702 PyObject *resultobj;
9703 wxFont *arg1 = (wxFont *) 0 ;
9704 int result;
9705 PyObject * obj0 = 0 ;
9706 char *kwnames[] = {
9707 (char *) "self", NULL
9708 };
9709
9710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyle",kwnames,&obj0)) goto fail;
9711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9712 if (SWIG_arg_fail(1)) SWIG_fail;
9713 {
9714 PyThreadState* __tstate = wxPyBeginAllowThreads();
9715 result = (int)((wxFont const *)arg1)->GetStyle();
9716
9717 wxPyEndAllowThreads(__tstate);
9718 if (PyErr_Occurred()) SWIG_fail;
9719 }
9720 {
9721 resultobj = SWIG_From_int((int)(result));
9722 }
9723 return resultobj;
9724 fail:
9725 return NULL;
9726 }
9727
9728
9729 static PyObject *_wrap_Font_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
9730 PyObject *resultobj;
9731 wxFont *arg1 = (wxFont *) 0 ;
9732 int result;
9733 PyObject * obj0 = 0 ;
9734 char *kwnames[] = {
9735 (char *) "self", NULL
9736 };
9737
9738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeight",kwnames,&obj0)) goto fail;
9739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9740 if (SWIG_arg_fail(1)) SWIG_fail;
9741 {
9742 PyThreadState* __tstate = wxPyBeginAllowThreads();
9743 result = (int)((wxFont const *)arg1)->GetWeight();
9744
9745 wxPyEndAllowThreads(__tstate);
9746 if (PyErr_Occurred()) SWIG_fail;
9747 }
9748 {
9749 resultobj = SWIG_From_int((int)(result));
9750 }
9751 return resultobj;
9752 fail:
9753 return NULL;
9754 }
9755
9756
9757 static PyObject *_wrap_Font_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
9758 PyObject *resultobj;
9759 wxFont *arg1 = (wxFont *) 0 ;
9760 bool result;
9761 PyObject * obj0 = 0 ;
9762 char *kwnames[] = {
9763 (char *) "self", NULL
9764 };
9765
9766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetUnderlined",kwnames,&obj0)) goto fail;
9767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9768 if (SWIG_arg_fail(1)) SWIG_fail;
9769 {
9770 PyThreadState* __tstate = wxPyBeginAllowThreads();
9771 result = (bool)((wxFont const *)arg1)->GetUnderlined();
9772
9773 wxPyEndAllowThreads(__tstate);
9774 if (PyErr_Occurred()) SWIG_fail;
9775 }
9776 {
9777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9778 }
9779 return resultobj;
9780 fail:
9781 return NULL;
9782 }
9783
9784
9785 static PyObject *_wrap_Font_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
9786 PyObject *resultobj;
9787 wxFont *arg1 = (wxFont *) 0 ;
9788 wxString result;
9789 PyObject * obj0 = 0 ;
9790 char *kwnames[] = {
9791 (char *) "self", NULL
9792 };
9793
9794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFaceName",kwnames,&obj0)) goto fail;
9795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9796 if (SWIG_arg_fail(1)) SWIG_fail;
9797 {
9798 PyThreadState* __tstate = wxPyBeginAllowThreads();
9799 result = ((wxFont const *)arg1)->GetFaceName();
9800
9801 wxPyEndAllowThreads(__tstate);
9802 if (PyErr_Occurred()) SWIG_fail;
9803 }
9804 {
9805 #if wxUSE_UNICODE
9806 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9807 #else
9808 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9809 #endif
9810 }
9811 return resultobj;
9812 fail:
9813 return NULL;
9814 }
9815
9816
9817 static PyObject *_wrap_Font_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9818 PyObject *resultobj;
9819 wxFont *arg1 = (wxFont *) 0 ;
9820 wxFontEncoding result;
9821 PyObject * obj0 = 0 ;
9822 char *kwnames[] = {
9823 (char *) "self", NULL
9824 };
9825
9826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetEncoding",kwnames,&obj0)) goto fail;
9827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9828 if (SWIG_arg_fail(1)) SWIG_fail;
9829 {
9830 PyThreadState* __tstate = wxPyBeginAllowThreads();
9831 result = (wxFontEncoding)((wxFont const *)arg1)->GetEncoding();
9832
9833 wxPyEndAllowThreads(__tstate);
9834 if (PyErr_Occurred()) SWIG_fail;
9835 }
9836 resultobj = SWIG_From_int((result));
9837 return resultobj;
9838 fail:
9839 return NULL;
9840 }
9841
9842
9843 static PyObject *_wrap_Font_GetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9844 PyObject *resultobj;
9845 wxFont *arg1 = (wxFont *) 0 ;
9846 wxNativeFontInfo *result;
9847 PyObject * obj0 = 0 ;
9848 char *kwnames[] = {
9849 (char *) "self", NULL
9850 };
9851
9852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfo",kwnames,&obj0)) goto fail;
9853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9854 if (SWIG_arg_fail(1)) SWIG_fail;
9855 {
9856 PyThreadState* __tstate = wxPyBeginAllowThreads();
9857 result = (wxNativeFontInfo *)((wxFont const *)arg1)->GetNativeFontInfo();
9858
9859 wxPyEndAllowThreads(__tstate);
9860 if (PyErr_Occurred()) SWIG_fail;
9861 }
9862 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 0);
9863 return resultobj;
9864 fail:
9865 return NULL;
9866 }
9867
9868
9869 static PyObject *_wrap_Font_IsFixedWidth(PyObject *, PyObject *args, PyObject *kwargs) {
9870 PyObject *resultobj;
9871 wxFont *arg1 = (wxFont *) 0 ;
9872 bool result;
9873 PyObject * obj0 = 0 ;
9874 char *kwnames[] = {
9875 (char *) "self", NULL
9876 };
9877
9878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsFixedWidth",kwnames,&obj0)) goto fail;
9879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9880 if (SWIG_arg_fail(1)) SWIG_fail;
9881 {
9882 PyThreadState* __tstate = wxPyBeginAllowThreads();
9883 result = (bool)((wxFont const *)arg1)->IsFixedWidth();
9884
9885 wxPyEndAllowThreads(__tstate);
9886 if (PyErr_Occurred()) SWIG_fail;
9887 }
9888 {
9889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9890 }
9891 return resultobj;
9892 fail:
9893 return NULL;
9894 }
9895
9896
9897 static PyObject *_wrap_Font_GetNativeFontInfoDesc(PyObject *, PyObject *args, PyObject *kwargs) {
9898 PyObject *resultobj;
9899 wxFont *arg1 = (wxFont *) 0 ;
9900 wxString result;
9901 PyObject * obj0 = 0 ;
9902 char *kwnames[] = {
9903 (char *) "self", NULL
9904 };
9905
9906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoDesc",kwnames,&obj0)) goto fail;
9907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9908 if (SWIG_arg_fail(1)) SWIG_fail;
9909 {
9910 PyThreadState* __tstate = wxPyBeginAllowThreads();
9911 result = ((wxFont const *)arg1)->GetNativeFontInfoDesc();
9912
9913 wxPyEndAllowThreads(__tstate);
9914 if (PyErr_Occurred()) SWIG_fail;
9915 }
9916 {
9917 #if wxUSE_UNICODE
9918 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9919 #else
9920 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9921 #endif
9922 }
9923 return resultobj;
9924 fail:
9925 return NULL;
9926 }
9927
9928
9929 static PyObject *_wrap_Font_GetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
9930 PyObject *resultobj;
9931 wxFont *arg1 = (wxFont *) 0 ;
9932 wxString result;
9933 PyObject * obj0 = 0 ;
9934 char *kwnames[] = {
9935 (char *) "self", NULL
9936 };
9937
9938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoUserDesc",kwnames,&obj0)) goto fail;
9939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9940 if (SWIG_arg_fail(1)) SWIG_fail;
9941 {
9942 PyThreadState* __tstate = wxPyBeginAllowThreads();
9943 result = ((wxFont const *)arg1)->GetNativeFontInfoUserDesc();
9944
9945 wxPyEndAllowThreads(__tstate);
9946 if (PyErr_Occurred()) SWIG_fail;
9947 }
9948 {
9949 #if wxUSE_UNICODE
9950 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9951 #else
9952 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9953 #endif
9954 }
9955 return resultobj;
9956 fail:
9957 return NULL;
9958 }
9959
9960
9961 static PyObject *_wrap_Font_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
9962 PyObject *resultobj;
9963 wxFont *arg1 = (wxFont *) 0 ;
9964 int arg2 ;
9965 PyObject * obj0 = 0 ;
9966 PyObject * obj1 = 0 ;
9967 char *kwnames[] = {
9968 (char *) "self",(char *) "pointSize", NULL
9969 };
9970
9971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
9972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9973 if (SWIG_arg_fail(1)) SWIG_fail;
9974 {
9975 arg2 = (int)(SWIG_As_int(obj1));
9976 if (SWIG_arg_fail(2)) SWIG_fail;
9977 }
9978 {
9979 PyThreadState* __tstate = wxPyBeginAllowThreads();
9980 (arg1)->SetPointSize(arg2);
9981
9982 wxPyEndAllowThreads(__tstate);
9983 if (PyErr_Occurred()) SWIG_fail;
9984 }
9985 Py_INCREF(Py_None); resultobj = Py_None;
9986 return resultobj;
9987 fail:
9988 return NULL;
9989 }
9990
9991
9992 static PyObject *_wrap_Font_SetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
9993 PyObject *resultobj;
9994 wxFont *arg1 = (wxFont *) 0 ;
9995 wxSize *arg2 = 0 ;
9996 wxSize temp2 ;
9997 PyObject * obj0 = 0 ;
9998 PyObject * obj1 = 0 ;
9999 char *kwnames[] = {
10000 (char *) "self",(char *) "pixelSize", NULL
10001 };
10002
10003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPixelSize",kwnames,&obj0,&obj1)) goto fail;
10004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10005 if (SWIG_arg_fail(1)) SWIG_fail;
10006 {
10007 arg2 = &temp2;
10008 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
10009 }
10010 {
10011 PyThreadState* __tstate = wxPyBeginAllowThreads();
10012 (arg1)->SetPixelSize((wxSize const &)*arg2);
10013
10014 wxPyEndAllowThreads(__tstate);
10015 if (PyErr_Occurred()) SWIG_fail;
10016 }
10017 Py_INCREF(Py_None); resultobj = Py_None;
10018 return resultobj;
10019 fail:
10020 return NULL;
10021 }
10022
10023
10024 static PyObject *_wrap_Font_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
10025 PyObject *resultobj;
10026 wxFont *arg1 = (wxFont *) 0 ;
10027 int arg2 ;
10028 PyObject * obj0 = 0 ;
10029 PyObject * obj1 = 0 ;
10030 char *kwnames[] = {
10031 (char *) "self",(char *) "family", NULL
10032 };
10033
10034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFamily",kwnames,&obj0,&obj1)) goto fail;
10035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10036 if (SWIG_arg_fail(1)) SWIG_fail;
10037 {
10038 arg2 = (int)(SWIG_As_int(obj1));
10039 if (SWIG_arg_fail(2)) SWIG_fail;
10040 }
10041 {
10042 PyThreadState* __tstate = wxPyBeginAllowThreads();
10043 (arg1)->SetFamily(arg2);
10044
10045 wxPyEndAllowThreads(__tstate);
10046 if (PyErr_Occurred()) SWIG_fail;
10047 }
10048 Py_INCREF(Py_None); resultobj = Py_None;
10049 return resultobj;
10050 fail:
10051 return NULL;
10052 }
10053
10054
10055 static PyObject *_wrap_Font_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
10056 PyObject *resultobj;
10057 wxFont *arg1 = (wxFont *) 0 ;
10058 int arg2 ;
10059 PyObject * obj0 = 0 ;
10060 PyObject * obj1 = 0 ;
10061 char *kwnames[] = {
10062 (char *) "self",(char *) "style", NULL
10063 };
10064
10065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetStyle",kwnames,&obj0,&obj1)) goto fail;
10066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10067 if (SWIG_arg_fail(1)) SWIG_fail;
10068 {
10069 arg2 = (int)(SWIG_As_int(obj1));
10070 if (SWIG_arg_fail(2)) SWIG_fail;
10071 }
10072 {
10073 PyThreadState* __tstate = wxPyBeginAllowThreads();
10074 (arg1)->SetStyle(arg2);
10075
10076 wxPyEndAllowThreads(__tstate);
10077 if (PyErr_Occurred()) SWIG_fail;
10078 }
10079 Py_INCREF(Py_None); resultobj = Py_None;
10080 return resultobj;
10081 fail:
10082 return NULL;
10083 }
10084
10085
10086 static PyObject *_wrap_Font_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
10087 PyObject *resultobj;
10088 wxFont *arg1 = (wxFont *) 0 ;
10089 int arg2 ;
10090 PyObject * obj0 = 0 ;
10091 PyObject * obj1 = 0 ;
10092 char *kwnames[] = {
10093 (char *) "self",(char *) "weight", NULL
10094 };
10095
10096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetWeight",kwnames,&obj0,&obj1)) goto fail;
10097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10098 if (SWIG_arg_fail(1)) SWIG_fail;
10099 {
10100 arg2 = (int)(SWIG_As_int(obj1));
10101 if (SWIG_arg_fail(2)) SWIG_fail;
10102 }
10103 {
10104 PyThreadState* __tstate = wxPyBeginAllowThreads();
10105 (arg1)->SetWeight(arg2);
10106
10107 wxPyEndAllowThreads(__tstate);
10108 if (PyErr_Occurred()) SWIG_fail;
10109 }
10110 Py_INCREF(Py_None); resultobj = Py_None;
10111 return resultobj;
10112 fail:
10113 return NULL;
10114 }
10115
10116
10117 static PyObject *_wrap_Font_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
10118 PyObject *resultobj;
10119 wxFont *arg1 = (wxFont *) 0 ;
10120 wxString *arg2 = 0 ;
10121 bool temp2 = false ;
10122 PyObject * obj0 = 0 ;
10123 PyObject * obj1 = 0 ;
10124 char *kwnames[] = {
10125 (char *) "self",(char *) "faceName", NULL
10126 };
10127
10128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
10129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10130 if (SWIG_arg_fail(1)) SWIG_fail;
10131 {
10132 arg2 = wxString_in_helper(obj1);
10133 if (arg2 == NULL) SWIG_fail;
10134 temp2 = true;
10135 }
10136 {
10137 PyThreadState* __tstate = wxPyBeginAllowThreads();
10138 (arg1)->SetFaceName((wxString const &)*arg2);
10139
10140 wxPyEndAllowThreads(__tstate);
10141 if (PyErr_Occurred()) SWIG_fail;
10142 }
10143 Py_INCREF(Py_None); resultobj = Py_None;
10144 {
10145 if (temp2)
10146 delete arg2;
10147 }
10148 return resultobj;
10149 fail:
10150 {
10151 if (temp2)
10152 delete arg2;
10153 }
10154 return NULL;
10155 }
10156
10157
10158 static PyObject *_wrap_Font_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
10159 PyObject *resultobj;
10160 wxFont *arg1 = (wxFont *) 0 ;
10161 bool arg2 ;
10162 PyObject * obj0 = 0 ;
10163 PyObject * obj1 = 0 ;
10164 char *kwnames[] = {
10165 (char *) "self",(char *) "underlined", NULL
10166 };
10167
10168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
10169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10170 if (SWIG_arg_fail(1)) SWIG_fail;
10171 {
10172 arg2 = (bool)(SWIG_As_bool(obj1));
10173 if (SWIG_arg_fail(2)) SWIG_fail;
10174 }
10175 {
10176 PyThreadState* __tstate = wxPyBeginAllowThreads();
10177 (arg1)->SetUnderlined(arg2);
10178
10179 wxPyEndAllowThreads(__tstate);
10180 if (PyErr_Occurred()) SWIG_fail;
10181 }
10182 Py_INCREF(Py_None); resultobj = Py_None;
10183 return resultobj;
10184 fail:
10185 return NULL;
10186 }
10187
10188
10189 static PyObject *_wrap_Font_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10190 PyObject *resultobj;
10191 wxFont *arg1 = (wxFont *) 0 ;
10192 wxFontEncoding arg2 ;
10193 PyObject * obj0 = 0 ;
10194 PyObject * obj1 = 0 ;
10195 char *kwnames[] = {
10196 (char *) "self",(char *) "encoding", NULL
10197 };
10198
10199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
10200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10201 if (SWIG_arg_fail(1)) SWIG_fail;
10202 {
10203 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
10204 if (SWIG_arg_fail(2)) SWIG_fail;
10205 }
10206 {
10207 PyThreadState* __tstate = wxPyBeginAllowThreads();
10208 (arg1)->SetEncoding((wxFontEncoding )arg2);
10209
10210 wxPyEndAllowThreads(__tstate);
10211 if (PyErr_Occurred()) SWIG_fail;
10212 }
10213 Py_INCREF(Py_None); resultobj = Py_None;
10214 return resultobj;
10215 fail:
10216 return NULL;
10217 }
10218
10219
10220 static PyObject *_wrap_Font_SetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10221 PyObject *resultobj;
10222 wxFont *arg1 = (wxFont *) 0 ;
10223 wxNativeFontInfo *arg2 = 0 ;
10224 PyObject * obj0 = 0 ;
10225 PyObject * obj1 = 0 ;
10226 char *kwnames[] = {
10227 (char *) "self",(char *) "info", NULL
10228 };
10229
10230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfo",kwnames,&obj0,&obj1)) goto fail;
10231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10232 if (SWIG_arg_fail(1)) SWIG_fail;
10233 {
10234 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
10235 if (SWIG_arg_fail(2)) SWIG_fail;
10236 if (arg2 == NULL) {
10237 SWIG_null_ref("wxNativeFontInfo");
10238 }
10239 if (SWIG_arg_fail(2)) SWIG_fail;
10240 }
10241 {
10242 PyThreadState* __tstate = wxPyBeginAllowThreads();
10243 (arg1)->SetNativeFontInfo((wxNativeFontInfo const &)*arg2);
10244
10245 wxPyEndAllowThreads(__tstate);
10246 if (PyErr_Occurred()) SWIG_fail;
10247 }
10248 Py_INCREF(Py_None); resultobj = Py_None;
10249 return resultobj;
10250 fail:
10251 return NULL;
10252 }
10253
10254
10255 static PyObject *_wrap_Font_SetNativeFontInfoFromString(PyObject *, PyObject *args, PyObject *kwargs) {
10256 PyObject *resultobj;
10257 wxFont *arg1 = (wxFont *) 0 ;
10258 wxString *arg2 = 0 ;
10259 bool temp2 = false ;
10260 PyObject * obj0 = 0 ;
10261 PyObject * obj1 = 0 ;
10262 char *kwnames[] = {
10263 (char *) "self",(char *) "info", NULL
10264 };
10265
10266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoFromString",kwnames,&obj0,&obj1)) goto fail;
10267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10268 if (SWIG_arg_fail(1)) SWIG_fail;
10269 {
10270 arg2 = wxString_in_helper(obj1);
10271 if (arg2 == NULL) SWIG_fail;
10272 temp2 = true;
10273 }
10274 {
10275 PyThreadState* __tstate = wxPyBeginAllowThreads();
10276 (arg1)->SetNativeFontInfo((wxString const &)*arg2);
10277
10278 wxPyEndAllowThreads(__tstate);
10279 if (PyErr_Occurred()) SWIG_fail;
10280 }
10281 Py_INCREF(Py_None); resultobj = Py_None;
10282 {
10283 if (temp2)
10284 delete arg2;
10285 }
10286 return resultobj;
10287 fail:
10288 {
10289 if (temp2)
10290 delete arg2;
10291 }
10292 return NULL;
10293 }
10294
10295
10296 static PyObject *_wrap_Font_SetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10297 PyObject *resultobj;
10298 wxFont *arg1 = (wxFont *) 0 ;
10299 wxString *arg2 = 0 ;
10300 bool temp2 = false ;
10301 PyObject * obj0 = 0 ;
10302 PyObject * obj1 = 0 ;
10303 char *kwnames[] = {
10304 (char *) "self",(char *) "info", NULL
10305 };
10306
10307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoUserDesc",kwnames,&obj0,&obj1)) goto fail;
10308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10309 if (SWIG_arg_fail(1)) SWIG_fail;
10310 {
10311 arg2 = wxString_in_helper(obj1);
10312 if (arg2 == NULL) SWIG_fail;
10313 temp2 = true;
10314 }
10315 {
10316 PyThreadState* __tstate = wxPyBeginAllowThreads();
10317 (arg1)->SetNativeFontInfoUserDesc((wxString const &)*arg2);
10318
10319 wxPyEndAllowThreads(__tstate);
10320 if (PyErr_Occurred()) SWIG_fail;
10321 }
10322 Py_INCREF(Py_None); resultobj = Py_None;
10323 {
10324 if (temp2)
10325 delete arg2;
10326 }
10327 return resultobj;
10328 fail:
10329 {
10330 if (temp2)
10331 delete arg2;
10332 }
10333 return NULL;
10334 }
10335
10336
10337 static PyObject *_wrap_Font_GetFamilyString(PyObject *, PyObject *args, PyObject *kwargs) {
10338 PyObject *resultobj;
10339 wxFont *arg1 = (wxFont *) 0 ;
10340 wxString result;
10341 PyObject * obj0 = 0 ;
10342 char *kwnames[] = {
10343 (char *) "self", NULL
10344 };
10345
10346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamilyString",kwnames,&obj0)) goto fail;
10347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10348 if (SWIG_arg_fail(1)) SWIG_fail;
10349 {
10350 PyThreadState* __tstate = wxPyBeginAllowThreads();
10351 result = ((wxFont const *)arg1)->GetFamilyString();
10352
10353 wxPyEndAllowThreads(__tstate);
10354 if (PyErr_Occurred()) SWIG_fail;
10355 }
10356 {
10357 #if wxUSE_UNICODE
10358 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10359 #else
10360 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10361 #endif
10362 }
10363 return resultobj;
10364 fail:
10365 return NULL;
10366 }
10367
10368
10369 static PyObject *_wrap_Font_GetStyleString(PyObject *, PyObject *args, PyObject *kwargs) {
10370 PyObject *resultobj;
10371 wxFont *arg1 = (wxFont *) 0 ;
10372 wxString result;
10373 PyObject * obj0 = 0 ;
10374 char *kwnames[] = {
10375 (char *) "self", NULL
10376 };
10377
10378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyleString",kwnames,&obj0)) goto fail;
10379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10380 if (SWIG_arg_fail(1)) SWIG_fail;
10381 {
10382 PyThreadState* __tstate = wxPyBeginAllowThreads();
10383 result = ((wxFont const *)arg1)->GetStyleString();
10384
10385 wxPyEndAllowThreads(__tstate);
10386 if (PyErr_Occurred()) SWIG_fail;
10387 }
10388 {
10389 #if wxUSE_UNICODE
10390 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10391 #else
10392 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10393 #endif
10394 }
10395 return resultobj;
10396 fail:
10397 return NULL;
10398 }
10399
10400
10401 static PyObject *_wrap_Font_GetWeightString(PyObject *, PyObject *args, PyObject *kwargs) {
10402 PyObject *resultobj;
10403 wxFont *arg1 = (wxFont *) 0 ;
10404 wxString result;
10405 PyObject * obj0 = 0 ;
10406 char *kwnames[] = {
10407 (char *) "self", NULL
10408 };
10409
10410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeightString",kwnames,&obj0)) goto fail;
10411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10412 if (SWIG_arg_fail(1)) SWIG_fail;
10413 {
10414 PyThreadState* __tstate = wxPyBeginAllowThreads();
10415 result = ((wxFont const *)arg1)->GetWeightString();
10416
10417 wxPyEndAllowThreads(__tstate);
10418 if (PyErr_Occurred()) SWIG_fail;
10419 }
10420 {
10421 #if wxUSE_UNICODE
10422 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10423 #else
10424 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10425 #endif
10426 }
10427 return resultobj;
10428 fail:
10429 return NULL;
10430 }
10431
10432
10433 static PyObject *_wrap_Font_SetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
10434 PyObject *resultobj;
10435 wxFont *arg1 = (wxFont *) 0 ;
10436 bool arg2 = (bool) true ;
10437 PyObject * obj0 = 0 ;
10438 PyObject * obj1 = 0 ;
10439 char *kwnames[] = {
10440 (char *) "self",(char *) "no", NULL
10441 };
10442
10443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Font_SetNoAntiAliasing",kwnames,&obj0,&obj1)) goto fail;
10444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10445 if (SWIG_arg_fail(1)) SWIG_fail;
10446 if (obj1) {
10447 {
10448 arg2 = (bool)(SWIG_As_bool(obj1));
10449 if (SWIG_arg_fail(2)) SWIG_fail;
10450 }
10451 }
10452 {
10453 PyThreadState* __tstate = wxPyBeginAllowThreads();
10454 (arg1)->SetNoAntiAliasing(arg2);
10455
10456 wxPyEndAllowThreads(__tstate);
10457 if (PyErr_Occurred()) SWIG_fail;
10458 }
10459 Py_INCREF(Py_None); resultobj = Py_None;
10460 return resultobj;
10461 fail:
10462 return NULL;
10463 }
10464
10465
10466 static PyObject *_wrap_Font_GetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
10467 PyObject *resultobj;
10468 wxFont *arg1 = (wxFont *) 0 ;
10469 bool result;
10470 PyObject * obj0 = 0 ;
10471 char *kwnames[] = {
10472 (char *) "self", NULL
10473 };
10474
10475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNoAntiAliasing",kwnames,&obj0)) goto fail;
10476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10477 if (SWIG_arg_fail(1)) SWIG_fail;
10478 {
10479 PyThreadState* __tstate = wxPyBeginAllowThreads();
10480 result = (bool)((wxFont const *)arg1)->GetNoAntiAliasing();
10481
10482 wxPyEndAllowThreads(__tstate);
10483 if (PyErr_Occurred()) SWIG_fail;
10484 }
10485 {
10486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10487 }
10488 return resultobj;
10489 fail:
10490 return NULL;
10491 }
10492
10493
10494 static PyObject *_wrap_Font_GetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10495 PyObject *resultobj;
10496 wxFontEncoding result;
10497 char *kwnames[] = {
10498 NULL
10499 };
10500
10501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Font_GetDefaultEncoding",kwnames)) goto fail;
10502 {
10503 if (!wxPyCheckForApp()) SWIG_fail;
10504 PyThreadState* __tstate = wxPyBeginAllowThreads();
10505 result = (wxFontEncoding)wxFont::GetDefaultEncoding();
10506
10507 wxPyEndAllowThreads(__tstate);
10508 if (PyErr_Occurred()) SWIG_fail;
10509 }
10510 resultobj = SWIG_From_int((result));
10511 return resultobj;
10512 fail:
10513 return NULL;
10514 }
10515
10516
10517 static PyObject *_wrap_Font_SetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10518 PyObject *resultobj;
10519 wxFontEncoding arg1 ;
10520 PyObject * obj0 = 0 ;
10521 char *kwnames[] = {
10522 (char *) "encoding", NULL
10523 };
10524
10525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_SetDefaultEncoding",kwnames,&obj0)) goto fail;
10526 {
10527 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
10528 if (SWIG_arg_fail(1)) SWIG_fail;
10529 }
10530 {
10531 if (!wxPyCheckForApp()) SWIG_fail;
10532 PyThreadState* __tstate = wxPyBeginAllowThreads();
10533 wxFont::SetDefaultEncoding((wxFontEncoding )arg1);
10534
10535 wxPyEndAllowThreads(__tstate);
10536 if (PyErr_Occurred()) SWIG_fail;
10537 }
10538 Py_INCREF(Py_None); resultobj = Py_None;
10539 return resultobj;
10540 fail:
10541 return NULL;
10542 }
10543
10544
10545 static PyObject * Font_swigregister(PyObject *, PyObject *args) {
10546 PyObject *obj;
10547 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10548 SWIG_TypeClientData(SWIGTYPE_p_wxFont, obj);
10549 Py_INCREF(obj);
10550 return Py_BuildValue((char *)"");
10551 }
10552 static PyObject *_wrap_new_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
10553 PyObject *resultobj;
10554 wxPyFontEnumerator *result;
10555 char *kwnames[] = {
10556 NULL
10557 };
10558
10559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontEnumerator",kwnames)) goto fail;
10560 {
10561 if (!wxPyCheckForApp()) SWIG_fail;
10562 PyThreadState* __tstate = wxPyBeginAllowThreads();
10563 result = (wxPyFontEnumerator *)new wxPyFontEnumerator();
10564
10565 wxPyEndAllowThreads(__tstate);
10566 if (PyErr_Occurred()) SWIG_fail;
10567 }
10568 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFontEnumerator, 1);
10569 return resultobj;
10570 fail:
10571 return NULL;
10572 }
10573
10574
10575 static PyObject *_wrap_delete_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
10576 PyObject *resultobj;
10577 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10578 PyObject * obj0 = 0 ;
10579 char *kwnames[] = {
10580 (char *) "self", NULL
10581 };
10582
10583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontEnumerator",kwnames,&obj0)) goto fail;
10584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10585 if (SWIG_arg_fail(1)) SWIG_fail;
10586 {
10587 PyThreadState* __tstate = wxPyBeginAllowThreads();
10588 delete arg1;
10589
10590 wxPyEndAllowThreads(__tstate);
10591 if (PyErr_Occurred()) SWIG_fail;
10592 }
10593 Py_INCREF(Py_None); resultobj = Py_None;
10594 return resultobj;
10595 fail:
10596 return NULL;
10597 }
10598
10599
10600 static PyObject *_wrap_FontEnumerator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10601 PyObject *resultobj;
10602 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10603 PyObject *arg2 = (PyObject *) 0 ;
10604 PyObject *arg3 = (PyObject *) 0 ;
10605 bool arg4 ;
10606 PyObject * obj0 = 0 ;
10607 PyObject * obj1 = 0 ;
10608 PyObject * obj2 = 0 ;
10609 PyObject * obj3 = 0 ;
10610 char *kwnames[] = {
10611 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
10612 };
10613
10614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FontEnumerator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10616 if (SWIG_arg_fail(1)) SWIG_fail;
10617 arg2 = obj1;
10618 arg3 = obj2;
10619 {
10620 arg4 = (bool)(SWIG_As_bool(obj3));
10621 if (SWIG_arg_fail(4)) SWIG_fail;
10622 }
10623 {
10624 PyThreadState* __tstate = wxPyBeginAllowThreads();
10625 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
10626
10627 wxPyEndAllowThreads(__tstate);
10628 if (PyErr_Occurred()) SWIG_fail;
10629 }
10630 Py_INCREF(Py_None); resultobj = Py_None;
10631 return resultobj;
10632 fail:
10633 return NULL;
10634 }
10635
10636
10637 static PyObject *_wrap_FontEnumerator_EnumerateFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
10638 PyObject *resultobj;
10639 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10640 wxFontEncoding arg2 = (wxFontEncoding) wxFONTENCODING_SYSTEM ;
10641 bool arg3 = (bool) false ;
10642 bool result;
10643 PyObject * obj0 = 0 ;
10644 PyObject * obj1 = 0 ;
10645 PyObject * obj2 = 0 ;
10646 char *kwnames[] = {
10647 (char *) "self",(char *) "encoding",(char *) "fixedWidthOnly", NULL
10648 };
10649
10650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FontEnumerator_EnumerateFacenames",kwnames,&obj0,&obj1,&obj2)) goto fail;
10651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10652 if (SWIG_arg_fail(1)) SWIG_fail;
10653 if (obj1) {
10654 {
10655 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
10656 if (SWIG_arg_fail(2)) SWIG_fail;
10657 }
10658 }
10659 if (obj2) {
10660 {
10661 arg3 = (bool)(SWIG_As_bool(obj2));
10662 if (SWIG_arg_fail(3)) SWIG_fail;
10663 }
10664 }
10665 {
10666 PyThreadState* __tstate = wxPyBeginAllowThreads();
10667 result = (bool)(arg1)->EnumerateFacenames((wxFontEncoding )arg2,arg3);
10668
10669 wxPyEndAllowThreads(__tstate);
10670 if (PyErr_Occurred()) SWIG_fail;
10671 }
10672 {
10673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10674 }
10675 return resultobj;
10676 fail:
10677 return NULL;
10678 }
10679
10680
10681 static PyObject *_wrap_FontEnumerator_EnumerateEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
10682 PyObject *resultobj;
10683 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10684 wxString const &arg2_defvalue = wxPyEmptyString ;
10685 wxString *arg2 = (wxString *) &arg2_defvalue ;
10686 bool result;
10687 bool temp2 = false ;
10688 PyObject * obj0 = 0 ;
10689 PyObject * obj1 = 0 ;
10690 char *kwnames[] = {
10691 (char *) "self",(char *) "facename", NULL
10692 };
10693
10694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FontEnumerator_EnumerateEncodings",kwnames,&obj0,&obj1)) goto fail;
10695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10696 if (SWIG_arg_fail(1)) SWIG_fail;
10697 if (obj1) {
10698 {
10699 arg2 = wxString_in_helper(obj1);
10700 if (arg2 == NULL) SWIG_fail;
10701 temp2 = true;
10702 }
10703 }
10704 {
10705 PyThreadState* __tstate = wxPyBeginAllowThreads();
10706 result = (bool)(arg1)->EnumerateEncodings((wxString const &)*arg2);
10707
10708 wxPyEndAllowThreads(__tstate);
10709 if (PyErr_Occurred()) SWIG_fail;
10710 }
10711 {
10712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10713 }
10714 {
10715 if (temp2)
10716 delete arg2;
10717 }
10718 return resultobj;
10719 fail:
10720 {
10721 if (temp2)
10722 delete arg2;
10723 }
10724 return NULL;
10725 }
10726
10727
10728 static PyObject *_wrap_FontEnumerator_GetEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
10729 PyObject *resultobj;
10730 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10731 PyObject *result;
10732 PyObject * obj0 = 0 ;
10733 char *kwnames[] = {
10734 (char *) "self", NULL
10735 };
10736
10737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetEncodings",kwnames,&obj0)) goto fail;
10738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10739 if (SWIG_arg_fail(1)) SWIG_fail;
10740 {
10741 PyThreadState* __tstate = wxPyBeginAllowThreads();
10742 result = (PyObject *)wxPyFontEnumerator_GetEncodings(arg1);
10743
10744 wxPyEndAllowThreads(__tstate);
10745 if (PyErr_Occurred()) SWIG_fail;
10746 }
10747 resultobj = result;
10748 return resultobj;
10749 fail:
10750 return NULL;
10751 }
10752
10753
10754 static PyObject *_wrap_FontEnumerator_GetFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
10755 PyObject *resultobj;
10756 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10757 PyObject *result;
10758 PyObject * obj0 = 0 ;
10759 char *kwnames[] = {
10760 (char *) "self", NULL
10761 };
10762
10763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetFacenames",kwnames,&obj0)) goto fail;
10764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10765 if (SWIG_arg_fail(1)) SWIG_fail;
10766 {
10767 PyThreadState* __tstate = wxPyBeginAllowThreads();
10768 result = (PyObject *)wxPyFontEnumerator_GetFacenames(arg1);
10769
10770 wxPyEndAllowThreads(__tstate);
10771 if (PyErr_Occurred()) SWIG_fail;
10772 }
10773 resultobj = result;
10774 return resultobj;
10775 fail:
10776 return NULL;
10777 }
10778
10779
10780 static PyObject * FontEnumerator_swigregister(PyObject *, PyObject *args) {
10781 PyObject *obj;
10782 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10783 SWIG_TypeClientData(SWIGTYPE_p_wxPyFontEnumerator, obj);
10784 Py_INCREF(obj);
10785 return Py_BuildValue((char *)"");
10786 }
10787 static PyObject *_wrap_LanguageInfo_Language_set(PyObject *, PyObject *args, PyObject *kwargs) {
10788 PyObject *resultobj;
10789 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10790 int arg2 ;
10791 PyObject * obj0 = 0 ;
10792 PyObject * obj1 = 0 ;
10793 char *kwnames[] = {
10794 (char *) "self",(char *) "Language", NULL
10795 };
10796
10797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Language_set",kwnames,&obj0,&obj1)) goto fail;
10798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10799 if (SWIG_arg_fail(1)) SWIG_fail;
10800 {
10801 arg2 = (int)(SWIG_As_int(obj1));
10802 if (SWIG_arg_fail(2)) SWIG_fail;
10803 }
10804 if (arg1) (arg1)->Language = arg2;
10805
10806 Py_INCREF(Py_None); resultobj = Py_None;
10807 return resultobj;
10808 fail:
10809 return NULL;
10810 }
10811
10812
10813 static PyObject *_wrap_LanguageInfo_Language_get(PyObject *, PyObject *args, PyObject *kwargs) {
10814 PyObject *resultobj;
10815 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10816 int result;
10817 PyObject * obj0 = 0 ;
10818 char *kwnames[] = {
10819 (char *) "self", NULL
10820 };
10821
10822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Language_get",kwnames,&obj0)) goto fail;
10823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10824 if (SWIG_arg_fail(1)) SWIG_fail;
10825 result = (int) ((arg1)->Language);
10826
10827 {
10828 resultobj = SWIG_From_int((int)(result));
10829 }
10830 return resultobj;
10831 fail:
10832 return NULL;
10833 }
10834
10835
10836 static PyObject *_wrap_LanguageInfo_CanonicalName_set(PyObject *, PyObject *args, PyObject *kwargs) {
10837 PyObject *resultobj;
10838 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10839 wxString *arg2 = (wxString *) 0 ;
10840 bool temp2 = false ;
10841 PyObject * obj0 = 0 ;
10842 PyObject * obj1 = 0 ;
10843 char *kwnames[] = {
10844 (char *) "self",(char *) "CanonicalName", NULL
10845 };
10846
10847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_CanonicalName_set",kwnames,&obj0,&obj1)) goto fail;
10848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10849 if (SWIG_arg_fail(1)) SWIG_fail;
10850 {
10851 arg2 = wxString_in_helper(obj1);
10852 if (arg2 == NULL) SWIG_fail;
10853 temp2 = true;
10854 }
10855 if (arg1) (arg1)->CanonicalName = *arg2;
10856
10857 Py_INCREF(Py_None); resultobj = Py_None;
10858 {
10859 if (temp2)
10860 delete arg2;
10861 }
10862 return resultobj;
10863 fail:
10864 {
10865 if (temp2)
10866 delete arg2;
10867 }
10868 return NULL;
10869 }
10870
10871
10872 static PyObject *_wrap_LanguageInfo_CanonicalName_get(PyObject *, PyObject *args, PyObject *kwargs) {
10873 PyObject *resultobj;
10874 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10875 wxString *result;
10876 PyObject * obj0 = 0 ;
10877 char *kwnames[] = {
10878 (char *) "self", NULL
10879 };
10880
10881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_CanonicalName_get",kwnames,&obj0)) goto fail;
10882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10883 if (SWIG_arg_fail(1)) SWIG_fail;
10884 result = (wxString *)& ((arg1)->CanonicalName);
10885
10886 {
10887 #if wxUSE_UNICODE
10888 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10889 #else
10890 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10891 #endif
10892 }
10893 return resultobj;
10894 fail:
10895 return NULL;
10896 }
10897
10898
10899 static PyObject *_wrap_LanguageInfo_Description_set(PyObject *, PyObject *args, PyObject *kwargs) {
10900 PyObject *resultobj;
10901 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10902 wxString *arg2 = (wxString *) 0 ;
10903 bool temp2 = false ;
10904 PyObject * obj0 = 0 ;
10905 PyObject * obj1 = 0 ;
10906 char *kwnames[] = {
10907 (char *) "self",(char *) "Description", NULL
10908 };
10909
10910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Description_set",kwnames,&obj0,&obj1)) goto fail;
10911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10912 if (SWIG_arg_fail(1)) SWIG_fail;
10913 {
10914 arg2 = wxString_in_helper(obj1);
10915 if (arg2 == NULL) SWIG_fail;
10916 temp2 = true;
10917 }
10918 if (arg1) (arg1)->Description = *arg2;
10919
10920 Py_INCREF(Py_None); resultobj = Py_None;
10921 {
10922 if (temp2)
10923 delete arg2;
10924 }
10925 return resultobj;
10926 fail:
10927 {
10928 if (temp2)
10929 delete arg2;
10930 }
10931 return NULL;
10932 }
10933
10934
10935 static PyObject *_wrap_LanguageInfo_Description_get(PyObject *, PyObject *args, PyObject *kwargs) {
10936 PyObject *resultobj;
10937 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10938 wxString *result;
10939 PyObject * obj0 = 0 ;
10940 char *kwnames[] = {
10941 (char *) "self", NULL
10942 };
10943
10944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Description_get",kwnames,&obj0)) goto fail;
10945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10946 if (SWIG_arg_fail(1)) SWIG_fail;
10947 result = (wxString *)& ((arg1)->Description);
10948
10949 {
10950 #if wxUSE_UNICODE
10951 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10952 #else
10953 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10954 #endif
10955 }
10956 return resultobj;
10957 fail:
10958 return NULL;
10959 }
10960
10961
10962 static PyObject * LanguageInfo_swigregister(PyObject *, PyObject *args) {
10963 PyObject *obj;
10964 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10965 SWIG_TypeClientData(SWIGTYPE_p_wxLanguageInfo, obj);
10966 Py_INCREF(obj);
10967 return Py_BuildValue((char *)"");
10968 }
10969 static PyObject *_wrap_new_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
10970 PyObject *resultobj;
10971 int arg1 = (int) -1 ;
10972 int arg2 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
10973 wxLocale *result;
10974 PyObject * obj0 = 0 ;
10975 PyObject * obj1 = 0 ;
10976 char *kwnames[] = {
10977 (char *) "language",(char *) "flags", NULL
10978 };
10979
10980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Locale",kwnames,&obj0,&obj1)) goto fail;
10981 if (obj0) {
10982 {
10983 arg1 = (int)(SWIG_As_int(obj0));
10984 if (SWIG_arg_fail(1)) SWIG_fail;
10985 }
10986 }
10987 if (obj1) {
10988 {
10989 arg2 = (int)(SWIG_As_int(obj1));
10990 if (SWIG_arg_fail(2)) SWIG_fail;
10991 }
10992 }
10993 {
10994 PyThreadState* __tstate = wxPyBeginAllowThreads();
10995 result = (wxLocale *)new_wxLocale(arg1,arg2);
10996
10997 wxPyEndAllowThreads(__tstate);
10998 if (PyErr_Occurred()) SWIG_fail;
10999 }
11000 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 1);
11001 return resultobj;
11002 fail:
11003 return NULL;
11004 }
11005
11006
11007 static PyObject *_wrap_delete_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
11008 PyObject *resultobj;
11009 wxLocale *arg1 = (wxLocale *) 0 ;
11010 PyObject * obj0 = 0 ;
11011 char *kwnames[] = {
11012 (char *) "self", NULL
11013 };
11014
11015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Locale",kwnames,&obj0)) goto fail;
11016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11017 if (SWIG_arg_fail(1)) SWIG_fail;
11018 {
11019 PyThreadState* __tstate = wxPyBeginAllowThreads();
11020 delete arg1;
11021
11022 wxPyEndAllowThreads(__tstate);
11023 if (PyErr_Occurred()) SWIG_fail;
11024 }
11025 Py_INCREF(Py_None); resultobj = Py_None;
11026 return resultobj;
11027 fail:
11028 return NULL;
11029 }
11030
11031
11032 static PyObject *_wrap_Locale_Init1(PyObject *, PyObject *args, PyObject *kwargs) {
11033 PyObject *resultobj;
11034 wxLocale *arg1 = (wxLocale *) 0 ;
11035 wxString *arg2 = 0 ;
11036 wxString const &arg3_defvalue = wxPyEmptyString ;
11037 wxString *arg3 = (wxString *) &arg3_defvalue ;
11038 wxString const &arg4_defvalue = wxPyEmptyString ;
11039 wxString *arg4 = (wxString *) &arg4_defvalue ;
11040 bool arg5 = (bool) true ;
11041 bool arg6 = (bool) false ;
11042 bool result;
11043 bool temp2 = false ;
11044 bool temp3 = false ;
11045 bool temp4 = false ;
11046 PyObject * obj0 = 0 ;
11047 PyObject * obj1 = 0 ;
11048 PyObject * obj2 = 0 ;
11049 PyObject * obj3 = 0 ;
11050 PyObject * obj4 = 0 ;
11051 PyObject * obj5 = 0 ;
11052 char *kwnames[] = {
11053 (char *) "self",(char *) "szName",(char *) "szShort",(char *) "szLocale",(char *) "bLoadDefault",(char *) "bConvertEncoding", NULL
11054 };
11055
11056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Locale_Init1",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11058 if (SWIG_arg_fail(1)) SWIG_fail;
11059 {
11060 arg2 = wxString_in_helper(obj1);
11061 if (arg2 == NULL) SWIG_fail;
11062 temp2 = true;
11063 }
11064 if (obj2) {
11065 {
11066 arg3 = wxString_in_helper(obj2);
11067 if (arg3 == NULL) SWIG_fail;
11068 temp3 = true;
11069 }
11070 }
11071 if (obj3) {
11072 {
11073 arg4 = wxString_in_helper(obj3);
11074 if (arg4 == NULL) SWIG_fail;
11075 temp4 = true;
11076 }
11077 }
11078 if (obj4) {
11079 {
11080 arg5 = (bool)(SWIG_As_bool(obj4));
11081 if (SWIG_arg_fail(5)) SWIG_fail;
11082 }
11083 }
11084 if (obj5) {
11085 {
11086 arg6 = (bool)(SWIG_As_bool(obj5));
11087 if (SWIG_arg_fail(6)) SWIG_fail;
11088 }
11089 }
11090 {
11091 PyThreadState* __tstate = wxPyBeginAllowThreads();
11092 result = (bool)wxLocale_Init1(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
11093
11094 wxPyEndAllowThreads(__tstate);
11095 if (PyErr_Occurred()) SWIG_fail;
11096 }
11097 {
11098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11099 }
11100 {
11101 if (temp2)
11102 delete arg2;
11103 }
11104 {
11105 if (temp3)
11106 delete arg3;
11107 }
11108 {
11109 if (temp4)
11110 delete arg4;
11111 }
11112 return resultobj;
11113 fail:
11114 {
11115 if (temp2)
11116 delete arg2;
11117 }
11118 {
11119 if (temp3)
11120 delete arg3;
11121 }
11122 {
11123 if (temp4)
11124 delete arg4;
11125 }
11126 return NULL;
11127 }
11128
11129
11130 static PyObject *_wrap_Locale_Init2(PyObject *, PyObject *args, PyObject *kwargs) {
11131 PyObject *resultobj;
11132 wxLocale *arg1 = (wxLocale *) 0 ;
11133 int arg2 = (int) wxLANGUAGE_DEFAULT ;
11134 int arg3 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
11135 bool result;
11136 PyObject * obj0 = 0 ;
11137 PyObject * obj1 = 0 ;
11138 PyObject * obj2 = 0 ;
11139 char *kwnames[] = {
11140 (char *) "self",(char *) "language",(char *) "flags", NULL
11141 };
11142
11143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Locale_Init2",kwnames,&obj0,&obj1,&obj2)) goto fail;
11144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11145 if (SWIG_arg_fail(1)) SWIG_fail;
11146 if (obj1) {
11147 {
11148 arg2 = (int)(SWIG_As_int(obj1));
11149 if (SWIG_arg_fail(2)) SWIG_fail;
11150 }
11151 }
11152 if (obj2) {
11153 {
11154 arg3 = (int)(SWIG_As_int(obj2));
11155 if (SWIG_arg_fail(3)) SWIG_fail;
11156 }
11157 }
11158 {
11159 PyThreadState* __tstate = wxPyBeginAllowThreads();
11160 result = (bool)wxLocale_Init2(arg1,arg2,arg3);
11161
11162 wxPyEndAllowThreads(__tstate);
11163 if (PyErr_Occurred()) SWIG_fail;
11164 }
11165 {
11166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11167 }
11168 return resultobj;
11169 fail:
11170 return NULL;
11171 }
11172
11173
11174 static PyObject *_wrap_Locale_GetSystemLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11175 PyObject *resultobj;
11176 int result;
11177 char *kwnames[] = {
11178 NULL
11179 };
11180
11181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemLanguage",kwnames)) goto fail;
11182 {
11183 PyThreadState* __tstate = wxPyBeginAllowThreads();
11184 result = (int)wxLocale::GetSystemLanguage();
11185
11186 wxPyEndAllowThreads(__tstate);
11187 if (PyErr_Occurred()) SWIG_fail;
11188 }
11189 {
11190 resultobj = SWIG_From_int((int)(result));
11191 }
11192 return resultobj;
11193 fail:
11194 return NULL;
11195 }
11196
11197
11198 static PyObject *_wrap_Locale_GetSystemEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
11199 PyObject *resultobj;
11200 wxFontEncoding result;
11201 char *kwnames[] = {
11202 NULL
11203 };
11204
11205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncoding",kwnames)) goto fail;
11206 {
11207 PyThreadState* __tstate = wxPyBeginAllowThreads();
11208 result = (wxFontEncoding)wxLocale::GetSystemEncoding();
11209
11210 wxPyEndAllowThreads(__tstate);
11211 if (PyErr_Occurred()) SWIG_fail;
11212 }
11213 resultobj = SWIG_From_int((result));
11214 return resultobj;
11215 fail:
11216 return NULL;
11217 }
11218
11219
11220 static PyObject *_wrap_Locale_GetSystemEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
11221 PyObject *resultobj;
11222 wxString result;
11223 char *kwnames[] = {
11224 NULL
11225 };
11226
11227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncodingName",kwnames)) goto fail;
11228 {
11229 PyThreadState* __tstate = wxPyBeginAllowThreads();
11230 result = wxLocale::GetSystemEncodingName();
11231
11232 wxPyEndAllowThreads(__tstate);
11233 if (PyErr_Occurred()) SWIG_fail;
11234 }
11235 {
11236 #if wxUSE_UNICODE
11237 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11238 #else
11239 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11240 #endif
11241 }
11242 return resultobj;
11243 fail:
11244 return NULL;
11245 }
11246
11247
11248 static PyObject *_wrap_Locale_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11249 PyObject *resultobj;
11250 wxLocale *arg1 = (wxLocale *) 0 ;
11251 bool result;
11252 PyObject * obj0 = 0 ;
11253 char *kwnames[] = {
11254 (char *) "self", NULL
11255 };
11256
11257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_IsOk",kwnames,&obj0)) goto fail;
11258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11259 if (SWIG_arg_fail(1)) SWIG_fail;
11260 {
11261 PyThreadState* __tstate = wxPyBeginAllowThreads();
11262 result = (bool)((wxLocale const *)arg1)->IsOk();
11263
11264 wxPyEndAllowThreads(__tstate);
11265 if (PyErr_Occurred()) SWIG_fail;
11266 }
11267 {
11268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11269 }
11270 return resultobj;
11271 fail:
11272 return NULL;
11273 }
11274
11275
11276 static PyObject *_wrap_Locale_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
11277 PyObject *resultobj;
11278 wxLocale *arg1 = (wxLocale *) 0 ;
11279 wxString result;
11280 PyObject * obj0 = 0 ;
11281 char *kwnames[] = {
11282 (char *) "self", NULL
11283 };
11284
11285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLocale",kwnames,&obj0)) goto fail;
11286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11287 if (SWIG_arg_fail(1)) SWIG_fail;
11288 {
11289 PyThreadState* __tstate = wxPyBeginAllowThreads();
11290 result = ((wxLocale const *)arg1)->GetLocale();
11291
11292 wxPyEndAllowThreads(__tstate);
11293 if (PyErr_Occurred()) SWIG_fail;
11294 }
11295 {
11296 #if wxUSE_UNICODE
11297 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11298 #else
11299 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11300 #endif
11301 }
11302 return resultobj;
11303 fail:
11304 return NULL;
11305 }
11306
11307
11308 static PyObject *_wrap_Locale_GetLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11309 PyObject *resultobj;
11310 wxLocale *arg1 = (wxLocale *) 0 ;
11311 int result;
11312 PyObject * obj0 = 0 ;
11313 char *kwnames[] = {
11314 (char *) "self", NULL
11315 };
11316
11317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguage",kwnames,&obj0)) goto fail;
11318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11319 if (SWIG_arg_fail(1)) SWIG_fail;
11320 {
11321 PyThreadState* __tstate = wxPyBeginAllowThreads();
11322 result = (int)((wxLocale const *)arg1)->GetLanguage();
11323
11324 wxPyEndAllowThreads(__tstate);
11325 if (PyErr_Occurred()) SWIG_fail;
11326 }
11327 {
11328 resultobj = SWIG_From_int((int)(result));
11329 }
11330 return resultobj;
11331 fail:
11332 return NULL;
11333 }
11334
11335
11336 static PyObject *_wrap_Locale_GetSysName(PyObject *, PyObject *args, PyObject *kwargs) {
11337 PyObject *resultobj;
11338 wxLocale *arg1 = (wxLocale *) 0 ;
11339 wxString result;
11340 PyObject * obj0 = 0 ;
11341 char *kwnames[] = {
11342 (char *) "self", NULL
11343 };
11344
11345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetSysName",kwnames,&obj0)) goto fail;
11346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11347 if (SWIG_arg_fail(1)) SWIG_fail;
11348 {
11349 PyThreadState* __tstate = wxPyBeginAllowThreads();
11350 result = ((wxLocale const *)arg1)->GetSysName();
11351
11352 wxPyEndAllowThreads(__tstate);
11353 if (PyErr_Occurred()) SWIG_fail;
11354 }
11355 {
11356 #if wxUSE_UNICODE
11357 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11358 #else
11359 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11360 #endif
11361 }
11362 return resultobj;
11363 fail:
11364 return NULL;
11365 }
11366
11367
11368 static PyObject *_wrap_Locale_GetCanonicalName(PyObject *, PyObject *args, PyObject *kwargs) {
11369 PyObject *resultobj;
11370 wxLocale *arg1 = (wxLocale *) 0 ;
11371 wxString result;
11372 PyObject * obj0 = 0 ;
11373 char *kwnames[] = {
11374 (char *) "self", NULL
11375 };
11376
11377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetCanonicalName",kwnames,&obj0)) goto fail;
11378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11379 if (SWIG_arg_fail(1)) SWIG_fail;
11380 {
11381 PyThreadState* __tstate = wxPyBeginAllowThreads();
11382 result = ((wxLocale const *)arg1)->GetCanonicalName();
11383
11384 wxPyEndAllowThreads(__tstate);
11385 if (PyErr_Occurred()) SWIG_fail;
11386 }
11387 {
11388 #if wxUSE_UNICODE
11389 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11390 #else
11391 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11392 #endif
11393 }
11394 return resultobj;
11395 fail:
11396 return NULL;
11397 }
11398
11399
11400 static PyObject *_wrap_Locale_AddCatalogLookupPathPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
11401 PyObject *resultobj;
11402 wxString *arg1 = 0 ;
11403 bool temp1 = false ;
11404 PyObject * obj0 = 0 ;
11405 char *kwnames[] = {
11406 (char *) "prefix", NULL
11407 };
11408
11409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddCatalogLookupPathPrefix",kwnames,&obj0)) goto fail;
11410 {
11411 arg1 = wxString_in_helper(obj0);
11412 if (arg1 == NULL) SWIG_fail;
11413 temp1 = true;
11414 }
11415 {
11416 PyThreadState* __tstate = wxPyBeginAllowThreads();
11417 wxLocale::AddCatalogLookupPathPrefix((wxString const &)*arg1);
11418
11419 wxPyEndAllowThreads(__tstate);
11420 if (PyErr_Occurred()) SWIG_fail;
11421 }
11422 Py_INCREF(Py_None); resultobj = Py_None;
11423 {
11424 if (temp1)
11425 delete arg1;
11426 }
11427 return resultobj;
11428 fail:
11429 {
11430 if (temp1)
11431 delete arg1;
11432 }
11433 return NULL;
11434 }
11435
11436
11437 static PyObject *_wrap_Locale_AddCatalog(PyObject *, PyObject *args, PyObject *kwargs) {
11438 PyObject *resultobj;
11439 wxLocale *arg1 = (wxLocale *) 0 ;
11440 wxString *arg2 = 0 ;
11441 bool result;
11442 bool temp2 = false ;
11443 PyObject * obj0 = 0 ;
11444 PyObject * obj1 = 0 ;
11445 char *kwnames[] = {
11446 (char *) "self",(char *) "szDomain", NULL
11447 };
11448
11449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_AddCatalog",kwnames,&obj0,&obj1)) goto fail;
11450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11451 if (SWIG_arg_fail(1)) SWIG_fail;
11452 {
11453 arg2 = wxString_in_helper(obj1);
11454 if (arg2 == NULL) SWIG_fail;
11455 temp2 = true;
11456 }
11457 {
11458 PyThreadState* __tstate = wxPyBeginAllowThreads();
11459 result = (bool)(arg1)->AddCatalog((wxString const &)*arg2);
11460
11461 wxPyEndAllowThreads(__tstate);
11462 if (PyErr_Occurred()) SWIG_fail;
11463 }
11464 {
11465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11466 }
11467 {
11468 if (temp2)
11469 delete arg2;
11470 }
11471 return resultobj;
11472 fail:
11473 {
11474 if (temp2)
11475 delete arg2;
11476 }
11477 return NULL;
11478 }
11479
11480
11481 static PyObject *_wrap_Locale_IsLoaded(PyObject *, PyObject *args, PyObject *kwargs) {
11482 PyObject *resultobj;
11483 wxLocale *arg1 = (wxLocale *) 0 ;
11484 wxString *arg2 = 0 ;
11485 bool result;
11486 bool temp2 = false ;
11487 PyObject * obj0 = 0 ;
11488 PyObject * obj1 = 0 ;
11489 char *kwnames[] = {
11490 (char *) "self",(char *) "szDomain", NULL
11491 };
11492
11493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_IsLoaded",kwnames,&obj0,&obj1)) goto fail;
11494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11495 if (SWIG_arg_fail(1)) SWIG_fail;
11496 {
11497 arg2 = wxString_in_helper(obj1);
11498 if (arg2 == NULL) SWIG_fail;
11499 temp2 = true;
11500 }
11501 {
11502 PyThreadState* __tstate = wxPyBeginAllowThreads();
11503 result = (bool)((wxLocale const *)arg1)->IsLoaded((wxString const &)*arg2);
11504
11505 wxPyEndAllowThreads(__tstate);
11506 if (PyErr_Occurred()) SWIG_fail;
11507 }
11508 {
11509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11510 }
11511 {
11512 if (temp2)
11513 delete arg2;
11514 }
11515 return resultobj;
11516 fail:
11517 {
11518 if (temp2)
11519 delete arg2;
11520 }
11521 return NULL;
11522 }
11523
11524
11525 static PyObject *_wrap_Locale_GetLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11526 PyObject *resultobj;
11527 int arg1 ;
11528 wxLanguageInfo *result;
11529 PyObject * obj0 = 0 ;
11530 char *kwnames[] = {
11531 (char *) "lang", NULL
11532 };
11533
11534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageInfo",kwnames,&obj0)) goto fail;
11535 {
11536 arg1 = (int)(SWIG_As_int(obj0));
11537 if (SWIG_arg_fail(1)) SWIG_fail;
11538 }
11539 {
11540 PyThreadState* __tstate = wxPyBeginAllowThreads();
11541 result = (wxLanguageInfo *)wxLocale::GetLanguageInfo(arg1);
11542
11543 wxPyEndAllowThreads(__tstate);
11544 if (PyErr_Occurred()) SWIG_fail;
11545 }
11546 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
11547 return resultobj;
11548 fail:
11549 return NULL;
11550 }
11551
11552
11553 static PyObject *_wrap_Locale_GetLanguageName(PyObject *, PyObject *args, PyObject *kwargs) {
11554 PyObject *resultobj;
11555 int arg1 ;
11556 wxString result;
11557 PyObject * obj0 = 0 ;
11558 char *kwnames[] = {
11559 (char *) "lang", NULL
11560 };
11561
11562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageName",kwnames,&obj0)) goto fail;
11563 {
11564 arg1 = (int)(SWIG_As_int(obj0));
11565 if (SWIG_arg_fail(1)) SWIG_fail;
11566 }
11567 {
11568 PyThreadState* __tstate = wxPyBeginAllowThreads();
11569 result = wxLocale::GetLanguageName(arg1);
11570
11571 wxPyEndAllowThreads(__tstate);
11572 if (PyErr_Occurred()) SWIG_fail;
11573 }
11574 {
11575 #if wxUSE_UNICODE
11576 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11577 #else
11578 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11579 #endif
11580 }
11581 return resultobj;
11582 fail:
11583 return NULL;
11584 }
11585
11586
11587 static PyObject *_wrap_Locale_FindLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11588 PyObject *resultobj;
11589 wxString *arg1 = 0 ;
11590 wxLanguageInfo *result;
11591 bool temp1 = false ;
11592 PyObject * obj0 = 0 ;
11593 char *kwnames[] = {
11594 (char *) "locale", NULL
11595 };
11596
11597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_FindLanguageInfo",kwnames,&obj0)) goto fail;
11598 {
11599 arg1 = wxString_in_helper(obj0);
11600 if (arg1 == NULL) SWIG_fail;
11601 temp1 = true;
11602 }
11603 {
11604 PyThreadState* __tstate = wxPyBeginAllowThreads();
11605 result = (wxLanguageInfo *)wxLocale::FindLanguageInfo((wxString const &)*arg1);
11606
11607 wxPyEndAllowThreads(__tstate);
11608 if (PyErr_Occurred()) SWIG_fail;
11609 }
11610 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
11611 {
11612 if (temp1)
11613 delete arg1;
11614 }
11615 return resultobj;
11616 fail:
11617 {
11618 if (temp1)
11619 delete arg1;
11620 }
11621 return NULL;
11622 }
11623
11624
11625 static PyObject *_wrap_Locale_AddLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11626 PyObject *resultobj;
11627 wxLanguageInfo *arg1 = 0 ;
11628 PyObject * obj0 = 0 ;
11629 char *kwnames[] = {
11630 (char *) "info", NULL
11631 };
11632
11633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddLanguage",kwnames,&obj0)) goto fail;
11634 {
11635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11636 if (SWIG_arg_fail(1)) SWIG_fail;
11637 if (arg1 == NULL) {
11638 SWIG_null_ref("wxLanguageInfo");
11639 }
11640 if (SWIG_arg_fail(1)) SWIG_fail;
11641 }
11642 {
11643 PyThreadState* __tstate = wxPyBeginAllowThreads();
11644 wxLocale::AddLanguage((wxLanguageInfo const &)*arg1);
11645
11646 wxPyEndAllowThreads(__tstate);
11647 if (PyErr_Occurred()) SWIG_fail;
11648 }
11649 Py_INCREF(Py_None); resultobj = Py_None;
11650 return resultobj;
11651 fail:
11652 return NULL;
11653 }
11654
11655
11656 static PyObject *_wrap_Locale_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
11657 PyObject *resultobj;
11658 wxLocale *arg1 = (wxLocale *) 0 ;
11659 wxString *arg2 = 0 ;
11660 wxString const &arg3_defvalue = wxPyEmptyString ;
11661 wxString *arg3 = (wxString *) &arg3_defvalue ;
11662 wxString result;
11663 bool temp2 = false ;
11664 bool temp3 = false ;
11665 PyObject * obj0 = 0 ;
11666 PyObject * obj1 = 0 ;
11667 PyObject * obj2 = 0 ;
11668 char *kwnames[] = {
11669 (char *) "self",(char *) "szOrigString",(char *) "szDomain", NULL
11670 };
11671
11672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Locale_GetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
11673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11674 if (SWIG_arg_fail(1)) SWIG_fail;
11675 {
11676 arg2 = wxString_in_helper(obj1);
11677 if (arg2 == NULL) SWIG_fail;
11678 temp2 = true;
11679 }
11680 if (obj2) {
11681 {
11682 arg3 = wxString_in_helper(obj2);
11683 if (arg3 == NULL) SWIG_fail;
11684 temp3 = true;
11685 }
11686 }
11687 {
11688 PyThreadState* __tstate = wxPyBeginAllowThreads();
11689 result = ((wxLocale const *)arg1)->GetString((wxString const &)*arg2,(wxString const &)*arg3);
11690
11691 wxPyEndAllowThreads(__tstate);
11692 if (PyErr_Occurred()) SWIG_fail;
11693 }
11694 {
11695 #if wxUSE_UNICODE
11696 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11697 #else
11698 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11699 #endif
11700 }
11701 {
11702 if (temp2)
11703 delete arg2;
11704 }
11705 {
11706 if (temp3)
11707 delete arg3;
11708 }
11709 return resultobj;
11710 fail:
11711 {
11712 if (temp2)
11713 delete arg2;
11714 }
11715 {
11716 if (temp3)
11717 delete arg3;
11718 }
11719 return NULL;
11720 }
11721
11722
11723 static PyObject *_wrap_Locale_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
11724 PyObject *resultobj;
11725 wxLocale *arg1 = (wxLocale *) 0 ;
11726 wxString *result;
11727 PyObject * obj0 = 0 ;
11728 char *kwnames[] = {
11729 (char *) "self", NULL
11730 };
11731
11732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetName",kwnames,&obj0)) goto fail;
11733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11734 if (SWIG_arg_fail(1)) SWIG_fail;
11735 {
11736 PyThreadState* __tstate = wxPyBeginAllowThreads();
11737 {
11738 wxString const &_result_ref = ((wxLocale const *)arg1)->GetName();
11739 result = (wxString *) &_result_ref;
11740 }
11741
11742 wxPyEndAllowThreads(__tstate);
11743 if (PyErr_Occurred()) SWIG_fail;
11744 }
11745 {
11746 #if wxUSE_UNICODE
11747 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
11748 #else
11749 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
11750 #endif
11751 }
11752 return resultobj;
11753 fail:
11754 return NULL;
11755 }
11756
11757
11758 static PyObject * Locale_swigregister(PyObject *, PyObject *args) {
11759 PyObject *obj;
11760 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11761 SWIG_TypeClientData(SWIGTYPE_p_wxLocale, obj);
11762 Py_INCREF(obj);
11763 return Py_BuildValue((char *)"");
11764 }
11765 static PyObject *_wrap_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
11766 PyObject *resultobj;
11767 wxLocale *result;
11768 char *kwnames[] = {
11769 NULL
11770 };
11771
11772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocale",kwnames)) goto fail;
11773 {
11774 PyThreadState* __tstate = wxPyBeginAllowThreads();
11775 result = (wxLocale *)wxGetLocale();
11776
11777 wxPyEndAllowThreads(__tstate);
11778 if (PyErr_Occurred()) SWIG_fail;
11779 }
11780 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 0);
11781 return resultobj;
11782 fail:
11783 return NULL;
11784 }
11785
11786
11787 static PyObject *_wrap_GetTranslation__SWIG_0(PyObject *, PyObject *args) {
11788 PyObject *resultobj;
11789 wxString *arg1 = 0 ;
11790 wxString result;
11791 bool temp1 = false ;
11792 PyObject * obj0 = 0 ;
11793
11794 if(!PyArg_ParseTuple(args,(char *)"O:GetTranslation",&obj0)) goto fail;
11795 {
11796 arg1 = wxString_in_helper(obj0);
11797 if (arg1 == NULL) SWIG_fail;
11798 temp1 = true;
11799 }
11800 {
11801 PyThreadState* __tstate = wxPyBeginAllowThreads();
11802 result = wxGetTranslation((wxString const &)*arg1);
11803
11804 wxPyEndAllowThreads(__tstate);
11805 if (PyErr_Occurred()) SWIG_fail;
11806 }
11807 {
11808 #if wxUSE_UNICODE
11809 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11810 #else
11811 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11812 #endif
11813 }
11814 {
11815 if (temp1)
11816 delete arg1;
11817 }
11818 return resultobj;
11819 fail:
11820 {
11821 if (temp1)
11822 delete arg1;
11823 }
11824 return NULL;
11825 }
11826
11827
11828 static PyObject *_wrap_GetTranslation__SWIG_1(PyObject *, PyObject *args) {
11829 PyObject *resultobj;
11830 wxString *arg1 = 0 ;
11831 wxString *arg2 = 0 ;
11832 size_t arg3 ;
11833 wxString result;
11834 bool temp1 = false ;
11835 bool temp2 = false ;
11836 PyObject * obj0 = 0 ;
11837 PyObject * obj1 = 0 ;
11838 PyObject * obj2 = 0 ;
11839
11840 if(!PyArg_ParseTuple(args,(char *)"OOO:GetTranslation",&obj0,&obj1,&obj2)) goto fail;
11841 {
11842 arg1 = wxString_in_helper(obj0);
11843 if (arg1 == NULL) SWIG_fail;
11844 temp1 = true;
11845 }
11846 {
11847 arg2 = wxString_in_helper(obj1);
11848 if (arg2 == NULL) SWIG_fail;
11849 temp2 = true;
11850 }
11851 {
11852 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
11853 if (SWIG_arg_fail(3)) SWIG_fail;
11854 }
11855 {
11856 PyThreadState* __tstate = wxPyBeginAllowThreads();
11857 result = wxGetTranslation((wxString const &)*arg1,(wxString const &)*arg2,arg3);
11858
11859 wxPyEndAllowThreads(__tstate);
11860 if (PyErr_Occurred()) SWIG_fail;
11861 }
11862 {
11863 #if wxUSE_UNICODE
11864 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11865 #else
11866 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11867 #endif
11868 }
11869 {
11870 if (temp1)
11871 delete arg1;
11872 }
11873 {
11874 if (temp2)
11875 delete arg2;
11876 }
11877 return resultobj;
11878 fail:
11879 {
11880 if (temp1)
11881 delete arg1;
11882 }
11883 {
11884 if (temp2)
11885 delete arg2;
11886 }
11887 return NULL;
11888 }
11889
11890
11891 static PyObject *_wrap_GetTranslation(PyObject *self, PyObject *args) {
11892 int argc;
11893 PyObject *argv[4];
11894 int ii;
11895
11896 argc = PyObject_Length(args);
11897 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
11898 argv[ii] = PyTuple_GetItem(args,ii);
11899 }
11900 if (argc == 1) {
11901 int _v;
11902 {
11903 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
11904 }
11905 if (_v) {
11906 return _wrap_GetTranslation__SWIG_0(self,args);
11907 }
11908 }
11909 if (argc == 3) {
11910 int _v;
11911 {
11912 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
11913 }
11914 if (_v) {
11915 {
11916 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
11917 }
11918 if (_v) {
11919 _v = SWIG_Check_unsigned_SS_long(argv[2]);
11920 if (_v) {
11921 return _wrap_GetTranslation__SWIG_1(self,args);
11922 }
11923 }
11924 }
11925 }
11926
11927 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GetTranslation'");
11928 return NULL;
11929 }
11930
11931
11932 static PyObject *_wrap_new_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
11933 PyObject *resultobj;
11934 wxEncodingConverter *result;
11935 char *kwnames[] = {
11936 NULL
11937 };
11938
11939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EncodingConverter",kwnames)) goto fail;
11940 {
11941 PyThreadState* __tstate = wxPyBeginAllowThreads();
11942 result = (wxEncodingConverter *)new wxEncodingConverter();
11943
11944 wxPyEndAllowThreads(__tstate);
11945 if (PyErr_Occurred()) SWIG_fail;
11946 }
11947 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEncodingConverter, 1);
11948 return resultobj;
11949 fail:
11950 return NULL;
11951 }
11952
11953
11954 static PyObject *_wrap_delete_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
11955 PyObject *resultobj;
11956 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
11957 PyObject * obj0 = 0 ;
11958 char *kwnames[] = {
11959 (char *) "self", NULL
11960 };
11961
11962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EncodingConverter",kwnames,&obj0)) goto fail;
11963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
11964 if (SWIG_arg_fail(1)) SWIG_fail;
11965 {
11966 PyThreadState* __tstate = wxPyBeginAllowThreads();
11967 delete arg1;
11968
11969 wxPyEndAllowThreads(__tstate);
11970 if (PyErr_Occurred()) SWIG_fail;
11971 }
11972 Py_INCREF(Py_None); resultobj = Py_None;
11973 return resultobj;
11974 fail:
11975 return NULL;
11976 }
11977
11978
11979 static PyObject *_wrap_EncodingConverter_Init(PyObject *, PyObject *args, PyObject *kwargs) {
11980 PyObject *resultobj;
11981 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
11982 wxFontEncoding arg2 ;
11983 wxFontEncoding arg3 ;
11984 int arg4 = (int) wxCONVERT_STRICT ;
11985 bool result;
11986 PyObject * obj0 = 0 ;
11987 PyObject * obj1 = 0 ;
11988 PyObject * obj2 = 0 ;
11989 PyObject * obj3 = 0 ;
11990 char *kwnames[] = {
11991 (char *) "self",(char *) "input_enc",(char *) "output_enc",(char *) "method", NULL
11992 };
11993
11994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:EncodingConverter_Init",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
11996 if (SWIG_arg_fail(1)) SWIG_fail;
11997 {
11998 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
11999 if (SWIG_arg_fail(2)) SWIG_fail;
12000 }
12001 {
12002 arg3 = (wxFontEncoding)(SWIG_As_int(obj2));
12003 if (SWIG_arg_fail(3)) SWIG_fail;
12004 }
12005 if (obj3) {
12006 {
12007 arg4 = (int)(SWIG_As_int(obj3));
12008 if (SWIG_arg_fail(4)) SWIG_fail;
12009 }
12010 }
12011 {
12012 PyThreadState* __tstate = wxPyBeginAllowThreads();
12013 result = (bool)(arg1)->Init((wxFontEncoding )arg2,(wxFontEncoding )arg3,arg4);
12014
12015 wxPyEndAllowThreads(__tstate);
12016 if (PyErr_Occurred()) SWIG_fail;
12017 }
12018 {
12019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12020 }
12021 return resultobj;
12022 fail:
12023 return NULL;
12024 }
12025
12026
12027 static PyObject *_wrap_EncodingConverter_Convert(PyObject *, PyObject *args, PyObject *kwargs) {
12028 PyObject *resultobj;
12029 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12030 wxString *arg2 = 0 ;
12031 wxString result;
12032 bool temp2 = false ;
12033 PyObject * obj0 = 0 ;
12034 PyObject * obj1 = 0 ;
12035 char *kwnames[] = {
12036 (char *) "self",(char *) "input", NULL
12037 };
12038
12039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_Convert",kwnames,&obj0,&obj1)) goto fail;
12040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12041 if (SWIG_arg_fail(1)) SWIG_fail;
12042 {
12043 arg2 = wxString_in_helper(obj1);
12044 if (arg2 == NULL) SWIG_fail;
12045 temp2 = true;
12046 }
12047 {
12048 PyThreadState* __tstate = wxPyBeginAllowThreads();
12049 result = (arg1)->Convert((wxString const &)*arg2);
12050
12051 wxPyEndAllowThreads(__tstate);
12052 if (PyErr_Occurred()) SWIG_fail;
12053 }
12054 {
12055 #if wxUSE_UNICODE
12056 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12057 #else
12058 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12059 #endif
12060 }
12061 {
12062 if (temp2)
12063 delete arg2;
12064 }
12065 return resultobj;
12066 fail:
12067 {
12068 if (temp2)
12069 delete arg2;
12070 }
12071 return NULL;
12072 }
12073
12074
12075 static PyObject *_wrap_EncodingConverter_GetPlatformEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12076 PyObject *resultobj;
12077 wxFontEncoding arg1 ;
12078 int arg2 = (int) wxPLATFORM_CURRENT ;
12079 wxFontEncodingArray result;
12080 PyObject * obj0 = 0 ;
12081 PyObject * obj1 = 0 ;
12082 char *kwnames[] = {
12083 (char *) "enc",(char *) "platform", NULL
12084 };
12085
12086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EncodingConverter_GetPlatformEquivalents",kwnames,&obj0,&obj1)) goto fail;
12087 {
12088 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12089 if (SWIG_arg_fail(1)) SWIG_fail;
12090 }
12091 if (obj1) {
12092 {
12093 arg2 = (int)(SWIG_As_int(obj1));
12094 if (SWIG_arg_fail(2)) SWIG_fail;
12095 }
12096 }
12097 {
12098 PyThreadState* __tstate = wxPyBeginAllowThreads();
12099 result = wxEncodingConverter::GetPlatformEquivalents((wxFontEncoding )arg1,arg2);
12100
12101 wxPyEndAllowThreads(__tstate);
12102 if (PyErr_Occurred()) SWIG_fail;
12103 }
12104 {
12105 resultobj = PyList_New(0);
12106 for (size_t i=0; i < (&result)->GetCount(); i++) {
12107 PyObject* number = PyInt_FromLong((&result)->Item(i));
12108 PyList_Append(resultobj, number);
12109 Py_DECREF(number);
12110 }
12111 }
12112 return resultobj;
12113 fail:
12114 return NULL;
12115 }
12116
12117
12118 static PyObject *_wrap_EncodingConverter_GetAllEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12119 PyObject *resultobj;
12120 wxFontEncoding arg1 ;
12121 wxFontEncodingArray result;
12122 PyObject * obj0 = 0 ;
12123 char *kwnames[] = {
12124 (char *) "enc", NULL
12125 };
12126
12127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EncodingConverter_GetAllEquivalents",kwnames,&obj0)) goto fail;
12128 {
12129 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12130 if (SWIG_arg_fail(1)) SWIG_fail;
12131 }
12132 {
12133 PyThreadState* __tstate = wxPyBeginAllowThreads();
12134 result = wxEncodingConverter::GetAllEquivalents((wxFontEncoding )arg1);
12135
12136 wxPyEndAllowThreads(__tstate);
12137 if (PyErr_Occurred()) SWIG_fail;
12138 }
12139 {
12140 resultobj = PyList_New(0);
12141 for (size_t i=0; i < (&result)->GetCount(); i++) {
12142 PyObject* number = PyInt_FromLong((&result)->Item(i));
12143 PyList_Append(resultobj, number);
12144 Py_DECREF(number);
12145 }
12146 }
12147 return resultobj;
12148 fail:
12149 return NULL;
12150 }
12151
12152
12153 static PyObject *_wrap_EncodingConverter_CanConvert(PyObject *, PyObject *args, PyObject *kwargs) {
12154 PyObject *resultobj;
12155 wxFontEncoding arg1 ;
12156 wxFontEncoding arg2 ;
12157 bool result;
12158 PyObject * obj0 = 0 ;
12159 PyObject * obj1 = 0 ;
12160 char *kwnames[] = {
12161 (char *) "encIn",(char *) "encOut", NULL
12162 };
12163
12164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_CanConvert",kwnames,&obj0,&obj1)) goto fail;
12165 {
12166 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12167 if (SWIG_arg_fail(1)) SWIG_fail;
12168 }
12169 {
12170 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12171 if (SWIG_arg_fail(2)) SWIG_fail;
12172 }
12173 {
12174 PyThreadState* __tstate = wxPyBeginAllowThreads();
12175 result = (bool)wxEncodingConverter::CanConvert((wxFontEncoding )arg1,(wxFontEncoding )arg2);
12176
12177 wxPyEndAllowThreads(__tstate);
12178 if (PyErr_Occurred()) SWIG_fail;
12179 }
12180 {
12181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12182 }
12183 return resultobj;
12184 fail:
12185 return NULL;
12186 }
12187
12188
12189 static PyObject * EncodingConverter_swigregister(PyObject *, PyObject *args) {
12190 PyObject *obj;
12191 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12192 SWIG_TypeClientData(SWIGTYPE_p_wxEncodingConverter, obj);
12193 Py_INCREF(obj);
12194 return Py_BuildValue((char *)"");
12195 }
12196 static PyObject *_wrap_delete_DC(PyObject *, PyObject *args, PyObject *kwargs) {
12197 PyObject *resultobj;
12198 wxDC *arg1 = (wxDC *) 0 ;
12199 PyObject * obj0 = 0 ;
12200 char *kwnames[] = {
12201 (char *) "self", NULL
12202 };
12203
12204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DC",kwnames,&obj0)) goto fail;
12205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12206 if (SWIG_arg_fail(1)) SWIG_fail;
12207 {
12208 PyThreadState* __tstate = wxPyBeginAllowThreads();
12209 delete arg1;
12210
12211 wxPyEndAllowThreads(__tstate);
12212 if (PyErr_Occurred()) SWIG_fail;
12213 }
12214 Py_INCREF(Py_None); resultobj = Py_None;
12215 return resultobj;
12216 fail:
12217 return NULL;
12218 }
12219
12220
12221 static PyObject *_wrap_DC_BeginDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12222 PyObject *resultobj;
12223 wxDC *arg1 = (wxDC *) 0 ;
12224 PyObject * obj0 = 0 ;
12225 char *kwnames[] = {
12226 (char *) "self", NULL
12227 };
12228
12229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_BeginDrawing",kwnames,&obj0)) goto fail;
12230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12231 if (SWIG_arg_fail(1)) SWIG_fail;
12232 {
12233 PyThreadState* __tstate = wxPyBeginAllowThreads();
12234 (arg1)->BeginDrawing();
12235
12236 wxPyEndAllowThreads(__tstate);
12237 if (PyErr_Occurred()) SWIG_fail;
12238 }
12239 Py_INCREF(Py_None); resultobj = Py_None;
12240 return resultobj;
12241 fail:
12242 return NULL;
12243 }
12244
12245
12246 static PyObject *_wrap_DC_EndDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12247 PyObject *resultobj;
12248 wxDC *arg1 = (wxDC *) 0 ;
12249 PyObject * obj0 = 0 ;
12250 char *kwnames[] = {
12251 (char *) "self", NULL
12252 };
12253
12254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDrawing",kwnames,&obj0)) goto fail;
12255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12256 if (SWIG_arg_fail(1)) SWIG_fail;
12257 {
12258 PyThreadState* __tstate = wxPyBeginAllowThreads();
12259 (arg1)->EndDrawing();
12260
12261 wxPyEndAllowThreads(__tstate);
12262 if (PyErr_Occurred()) SWIG_fail;
12263 }
12264 Py_INCREF(Py_None); resultobj = Py_None;
12265 return resultobj;
12266 fail:
12267 return NULL;
12268 }
12269
12270
12271 static PyObject *_wrap_DC_FloodFill(PyObject *, PyObject *args, PyObject *kwargs) {
12272 PyObject *resultobj;
12273 wxDC *arg1 = (wxDC *) 0 ;
12274 int arg2 ;
12275 int arg3 ;
12276 wxColour *arg4 = 0 ;
12277 int arg5 = (int) wxFLOOD_SURFACE ;
12278 bool result;
12279 wxColour temp4 ;
12280 PyObject * obj0 = 0 ;
12281 PyObject * obj1 = 0 ;
12282 PyObject * obj2 = 0 ;
12283 PyObject * obj3 = 0 ;
12284 PyObject * obj4 = 0 ;
12285 char *kwnames[] = {
12286 (char *) "self",(char *) "x",(char *) "y",(char *) "col",(char *) "style", NULL
12287 };
12288
12289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_FloodFill",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12291 if (SWIG_arg_fail(1)) SWIG_fail;
12292 {
12293 arg2 = (int)(SWIG_As_int(obj1));
12294 if (SWIG_arg_fail(2)) SWIG_fail;
12295 }
12296 {
12297 arg3 = (int)(SWIG_As_int(obj2));
12298 if (SWIG_arg_fail(3)) SWIG_fail;
12299 }
12300 {
12301 arg4 = &temp4;
12302 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
12303 }
12304 if (obj4) {
12305 {
12306 arg5 = (int)(SWIG_As_int(obj4));
12307 if (SWIG_arg_fail(5)) SWIG_fail;
12308 }
12309 }
12310 {
12311 PyThreadState* __tstate = wxPyBeginAllowThreads();
12312 result = (bool)(arg1)->FloodFill(arg2,arg3,(wxColour const &)*arg4,arg5);
12313
12314 wxPyEndAllowThreads(__tstate);
12315 if (PyErr_Occurred()) SWIG_fail;
12316 }
12317 {
12318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12319 }
12320 return resultobj;
12321 fail:
12322 return NULL;
12323 }
12324
12325
12326 static PyObject *_wrap_DC_FloodFillPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12327 PyObject *resultobj;
12328 wxDC *arg1 = (wxDC *) 0 ;
12329 wxPoint *arg2 = 0 ;
12330 wxColour *arg3 = 0 ;
12331 int arg4 = (int) wxFLOOD_SURFACE ;
12332 bool result;
12333 wxPoint temp2 ;
12334 wxColour temp3 ;
12335 PyObject * obj0 = 0 ;
12336 PyObject * obj1 = 0 ;
12337 PyObject * obj2 = 0 ;
12338 PyObject * obj3 = 0 ;
12339 char *kwnames[] = {
12340 (char *) "self",(char *) "pt",(char *) "col",(char *) "style", NULL
12341 };
12342
12343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_FloodFillPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12345 if (SWIG_arg_fail(1)) SWIG_fail;
12346 {
12347 arg2 = &temp2;
12348 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12349 }
12350 {
12351 arg3 = &temp3;
12352 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
12353 }
12354 if (obj3) {
12355 {
12356 arg4 = (int)(SWIG_As_int(obj3));
12357 if (SWIG_arg_fail(4)) SWIG_fail;
12358 }
12359 }
12360 {
12361 PyThreadState* __tstate = wxPyBeginAllowThreads();
12362 result = (bool)(arg1)->FloodFill((wxPoint const &)*arg2,(wxColour const &)*arg3,arg4);
12363
12364 wxPyEndAllowThreads(__tstate);
12365 if (PyErr_Occurred()) SWIG_fail;
12366 }
12367 {
12368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12369 }
12370 return resultobj;
12371 fail:
12372 return NULL;
12373 }
12374
12375
12376 static PyObject *_wrap_DC_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
12377 PyObject *resultobj;
12378 wxDC *arg1 = (wxDC *) 0 ;
12379 int arg2 ;
12380 int arg3 ;
12381 wxColour result;
12382 PyObject * obj0 = 0 ;
12383 PyObject * obj1 = 0 ;
12384 PyObject * obj2 = 0 ;
12385 char *kwnames[] = {
12386 (char *) "self",(char *) "x",(char *) "y", NULL
12387 };
12388
12389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_GetPixel",kwnames,&obj0,&obj1,&obj2)) goto fail;
12390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12391 if (SWIG_arg_fail(1)) SWIG_fail;
12392 {
12393 arg2 = (int)(SWIG_As_int(obj1));
12394 if (SWIG_arg_fail(2)) SWIG_fail;
12395 }
12396 {
12397 arg3 = (int)(SWIG_As_int(obj2));
12398 if (SWIG_arg_fail(3)) SWIG_fail;
12399 }
12400 {
12401 PyThreadState* __tstate = wxPyBeginAllowThreads();
12402 result = wxDC_GetPixel(arg1,arg2,arg3);
12403
12404 wxPyEndAllowThreads(__tstate);
12405 if (PyErr_Occurred()) SWIG_fail;
12406 }
12407 {
12408 wxColour * resultptr;
12409 resultptr = new wxColour((wxColour &)(result));
12410 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12411 }
12412 return resultobj;
12413 fail:
12414 return NULL;
12415 }
12416
12417
12418 static PyObject *_wrap_DC_GetPixelPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12419 PyObject *resultobj;
12420 wxDC *arg1 = (wxDC *) 0 ;
12421 wxPoint *arg2 = 0 ;
12422 wxColour result;
12423 wxPoint temp2 ;
12424 PyObject * obj0 = 0 ;
12425 PyObject * obj1 = 0 ;
12426 char *kwnames[] = {
12427 (char *) "self",(char *) "pt", NULL
12428 };
12429
12430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPixelPoint",kwnames,&obj0,&obj1)) goto fail;
12431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12432 if (SWIG_arg_fail(1)) SWIG_fail;
12433 {
12434 arg2 = &temp2;
12435 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12436 }
12437 {
12438 PyThreadState* __tstate = wxPyBeginAllowThreads();
12439 result = wxDC_GetPixelPoint(arg1,(wxPoint const &)*arg2);
12440
12441 wxPyEndAllowThreads(__tstate);
12442 if (PyErr_Occurred()) SWIG_fail;
12443 }
12444 {
12445 wxColour * resultptr;
12446 resultptr = new wxColour((wxColour &)(result));
12447 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12448 }
12449 return resultobj;
12450 fail:
12451 return NULL;
12452 }
12453
12454
12455 static PyObject *_wrap_DC_DrawLine(PyObject *, PyObject *args, PyObject *kwargs) {
12456 PyObject *resultobj;
12457 wxDC *arg1 = (wxDC *) 0 ;
12458 int arg2 ;
12459 int arg3 ;
12460 int arg4 ;
12461 int arg5 ;
12462 PyObject * obj0 = 0 ;
12463 PyObject * obj1 = 0 ;
12464 PyObject * obj2 = 0 ;
12465 PyObject * obj3 = 0 ;
12466 PyObject * obj4 = 0 ;
12467 char *kwnames[] = {
12468 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2", NULL
12469 };
12470
12471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawLine",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12473 if (SWIG_arg_fail(1)) SWIG_fail;
12474 {
12475 arg2 = (int)(SWIG_As_int(obj1));
12476 if (SWIG_arg_fail(2)) SWIG_fail;
12477 }
12478 {
12479 arg3 = (int)(SWIG_As_int(obj2));
12480 if (SWIG_arg_fail(3)) SWIG_fail;
12481 }
12482 {
12483 arg4 = (int)(SWIG_As_int(obj3));
12484 if (SWIG_arg_fail(4)) SWIG_fail;
12485 }
12486 {
12487 arg5 = (int)(SWIG_As_int(obj4));
12488 if (SWIG_arg_fail(5)) SWIG_fail;
12489 }
12490 {
12491 PyThreadState* __tstate = wxPyBeginAllowThreads();
12492 (arg1)->DrawLine(arg2,arg3,arg4,arg5);
12493
12494 wxPyEndAllowThreads(__tstate);
12495 if (PyErr_Occurred()) SWIG_fail;
12496 }
12497 Py_INCREF(Py_None); resultobj = Py_None;
12498 return resultobj;
12499 fail:
12500 return NULL;
12501 }
12502
12503
12504 static PyObject *_wrap_DC_DrawLinePoint(PyObject *, PyObject *args, PyObject *kwargs) {
12505 PyObject *resultobj;
12506 wxDC *arg1 = (wxDC *) 0 ;
12507 wxPoint *arg2 = 0 ;
12508 wxPoint *arg3 = 0 ;
12509 wxPoint temp2 ;
12510 wxPoint temp3 ;
12511 PyObject * obj0 = 0 ;
12512 PyObject * obj1 = 0 ;
12513 PyObject * obj2 = 0 ;
12514 char *kwnames[] = {
12515 (char *) "self",(char *) "pt1",(char *) "pt2", NULL
12516 };
12517
12518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawLinePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
12519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12520 if (SWIG_arg_fail(1)) SWIG_fail;
12521 {
12522 arg2 = &temp2;
12523 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12524 }
12525 {
12526 arg3 = &temp3;
12527 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12528 }
12529 {
12530 PyThreadState* __tstate = wxPyBeginAllowThreads();
12531 (arg1)->DrawLine((wxPoint const &)*arg2,(wxPoint const &)*arg3);
12532
12533 wxPyEndAllowThreads(__tstate);
12534 if (PyErr_Occurred()) SWIG_fail;
12535 }
12536 Py_INCREF(Py_None); resultobj = Py_None;
12537 return resultobj;
12538 fail:
12539 return NULL;
12540 }
12541
12542
12543 static PyObject *_wrap_DC_CrossHair(PyObject *, PyObject *args, PyObject *kwargs) {
12544 PyObject *resultobj;
12545 wxDC *arg1 = (wxDC *) 0 ;
12546 int arg2 ;
12547 int arg3 ;
12548 PyObject * obj0 = 0 ;
12549 PyObject * obj1 = 0 ;
12550 PyObject * obj2 = 0 ;
12551 char *kwnames[] = {
12552 (char *) "self",(char *) "x",(char *) "y", NULL
12553 };
12554
12555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CrossHair",kwnames,&obj0,&obj1,&obj2)) goto fail;
12556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12557 if (SWIG_arg_fail(1)) SWIG_fail;
12558 {
12559 arg2 = (int)(SWIG_As_int(obj1));
12560 if (SWIG_arg_fail(2)) SWIG_fail;
12561 }
12562 {
12563 arg3 = (int)(SWIG_As_int(obj2));
12564 if (SWIG_arg_fail(3)) SWIG_fail;
12565 }
12566 {
12567 PyThreadState* __tstate = wxPyBeginAllowThreads();
12568 (arg1)->CrossHair(arg2,arg3);
12569
12570 wxPyEndAllowThreads(__tstate);
12571 if (PyErr_Occurred()) SWIG_fail;
12572 }
12573 Py_INCREF(Py_None); resultobj = Py_None;
12574 return resultobj;
12575 fail:
12576 return NULL;
12577 }
12578
12579
12580 static PyObject *_wrap_DC_CrossHairPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12581 PyObject *resultobj;
12582 wxDC *arg1 = (wxDC *) 0 ;
12583 wxPoint *arg2 = 0 ;
12584 wxPoint temp2 ;
12585 PyObject * obj0 = 0 ;
12586 PyObject * obj1 = 0 ;
12587 char *kwnames[] = {
12588 (char *) "self",(char *) "pt", NULL
12589 };
12590
12591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CrossHairPoint",kwnames,&obj0,&obj1)) goto fail;
12592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12593 if (SWIG_arg_fail(1)) SWIG_fail;
12594 {
12595 arg2 = &temp2;
12596 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12597 }
12598 {
12599 PyThreadState* __tstate = wxPyBeginAllowThreads();
12600 (arg1)->CrossHair((wxPoint const &)*arg2);
12601
12602 wxPyEndAllowThreads(__tstate);
12603 if (PyErr_Occurred()) SWIG_fail;
12604 }
12605 Py_INCREF(Py_None); resultobj = Py_None;
12606 return resultobj;
12607 fail:
12608 return NULL;
12609 }
12610
12611
12612 static PyObject *_wrap_DC_DrawArc(PyObject *, PyObject *args, PyObject *kwargs) {
12613 PyObject *resultobj;
12614 wxDC *arg1 = (wxDC *) 0 ;
12615 int arg2 ;
12616 int arg3 ;
12617 int arg4 ;
12618 int arg5 ;
12619 int arg6 ;
12620 int arg7 ;
12621 PyObject * obj0 = 0 ;
12622 PyObject * obj1 = 0 ;
12623 PyObject * obj2 = 0 ;
12624 PyObject * obj3 = 0 ;
12625 PyObject * obj4 = 0 ;
12626 PyObject * obj5 = 0 ;
12627 PyObject * obj6 = 0 ;
12628 char *kwnames[] = {
12629 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2",(char *) "xc",(char *) "yc", NULL
12630 };
12631
12632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12634 if (SWIG_arg_fail(1)) SWIG_fail;
12635 {
12636 arg2 = (int)(SWIG_As_int(obj1));
12637 if (SWIG_arg_fail(2)) SWIG_fail;
12638 }
12639 {
12640 arg3 = (int)(SWIG_As_int(obj2));
12641 if (SWIG_arg_fail(3)) SWIG_fail;
12642 }
12643 {
12644 arg4 = (int)(SWIG_As_int(obj3));
12645 if (SWIG_arg_fail(4)) SWIG_fail;
12646 }
12647 {
12648 arg5 = (int)(SWIG_As_int(obj4));
12649 if (SWIG_arg_fail(5)) SWIG_fail;
12650 }
12651 {
12652 arg6 = (int)(SWIG_As_int(obj5));
12653 if (SWIG_arg_fail(6)) SWIG_fail;
12654 }
12655 {
12656 arg7 = (int)(SWIG_As_int(obj6));
12657 if (SWIG_arg_fail(7)) SWIG_fail;
12658 }
12659 {
12660 PyThreadState* __tstate = wxPyBeginAllowThreads();
12661 (arg1)->DrawArc(arg2,arg3,arg4,arg5,arg6,arg7);
12662
12663 wxPyEndAllowThreads(__tstate);
12664 if (PyErr_Occurred()) SWIG_fail;
12665 }
12666 Py_INCREF(Py_None); resultobj = Py_None;
12667 return resultobj;
12668 fail:
12669 return NULL;
12670 }
12671
12672
12673 static PyObject *_wrap_DC_DrawArcPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12674 PyObject *resultobj;
12675 wxDC *arg1 = (wxDC *) 0 ;
12676 wxPoint *arg2 = 0 ;
12677 wxPoint *arg3 = 0 ;
12678 wxPoint *arg4 = 0 ;
12679 wxPoint temp2 ;
12680 wxPoint temp3 ;
12681 wxPoint temp4 ;
12682 PyObject * obj0 = 0 ;
12683 PyObject * obj1 = 0 ;
12684 PyObject * obj2 = 0 ;
12685 PyObject * obj3 = 0 ;
12686 char *kwnames[] = {
12687 (char *) "self",(char *) "pt1",(char *) "pt2",(char *) "center", NULL
12688 };
12689
12690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawArcPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12692 if (SWIG_arg_fail(1)) SWIG_fail;
12693 {
12694 arg2 = &temp2;
12695 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12696 }
12697 {
12698 arg3 = &temp3;
12699 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12700 }
12701 {
12702 arg4 = &temp4;
12703 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
12704 }
12705 {
12706 PyThreadState* __tstate = wxPyBeginAllowThreads();
12707 (arg1)->DrawArc((wxPoint const &)*arg2,(wxPoint const &)*arg3,(wxPoint const &)*arg4);
12708
12709 wxPyEndAllowThreads(__tstate);
12710 if (PyErr_Occurred()) SWIG_fail;
12711 }
12712 Py_INCREF(Py_None); resultobj = Py_None;
12713 return resultobj;
12714 fail:
12715 return NULL;
12716 }
12717
12718
12719 static PyObject *_wrap_DC_DrawCheckMark(PyObject *, PyObject *args, PyObject *kwargs) {
12720 PyObject *resultobj;
12721 wxDC *arg1 = (wxDC *) 0 ;
12722 int arg2 ;
12723 int arg3 ;
12724 int arg4 ;
12725 int arg5 ;
12726 PyObject * obj0 = 0 ;
12727 PyObject * obj1 = 0 ;
12728 PyObject * obj2 = 0 ;
12729 PyObject * obj3 = 0 ;
12730 PyObject * obj4 = 0 ;
12731 char *kwnames[] = {
12732 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
12733 };
12734
12735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawCheckMark",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12737 if (SWIG_arg_fail(1)) SWIG_fail;
12738 {
12739 arg2 = (int)(SWIG_As_int(obj1));
12740 if (SWIG_arg_fail(2)) SWIG_fail;
12741 }
12742 {
12743 arg3 = (int)(SWIG_As_int(obj2));
12744 if (SWIG_arg_fail(3)) SWIG_fail;
12745 }
12746 {
12747 arg4 = (int)(SWIG_As_int(obj3));
12748 if (SWIG_arg_fail(4)) SWIG_fail;
12749 }
12750 {
12751 arg5 = (int)(SWIG_As_int(obj4));
12752 if (SWIG_arg_fail(5)) SWIG_fail;
12753 }
12754 {
12755 PyThreadState* __tstate = wxPyBeginAllowThreads();
12756 (arg1)->DrawCheckMark(arg2,arg3,arg4,arg5);
12757
12758 wxPyEndAllowThreads(__tstate);
12759 if (PyErr_Occurred()) SWIG_fail;
12760 }
12761 Py_INCREF(Py_None); resultobj = Py_None;
12762 return resultobj;
12763 fail:
12764 return NULL;
12765 }
12766
12767
12768 static PyObject *_wrap_DC_DrawCheckMarkRect(PyObject *, PyObject *args, PyObject *kwargs) {
12769 PyObject *resultobj;
12770 wxDC *arg1 = (wxDC *) 0 ;
12771 wxRect *arg2 = 0 ;
12772 wxRect temp2 ;
12773 PyObject * obj0 = 0 ;
12774 PyObject * obj1 = 0 ;
12775 char *kwnames[] = {
12776 (char *) "self",(char *) "rect", NULL
12777 };
12778
12779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawCheckMarkRect",kwnames,&obj0,&obj1)) goto fail;
12780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12781 if (SWIG_arg_fail(1)) SWIG_fail;
12782 {
12783 arg2 = &temp2;
12784 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12785 }
12786 {
12787 PyThreadState* __tstate = wxPyBeginAllowThreads();
12788 (arg1)->DrawCheckMark((wxRect const &)*arg2);
12789
12790 wxPyEndAllowThreads(__tstate);
12791 if (PyErr_Occurred()) SWIG_fail;
12792 }
12793 Py_INCREF(Py_None); resultobj = Py_None;
12794 return resultobj;
12795 fail:
12796 return NULL;
12797 }
12798
12799
12800 static PyObject *_wrap_DC_DrawEllipticArc(PyObject *, PyObject *args, PyObject *kwargs) {
12801 PyObject *resultobj;
12802 wxDC *arg1 = (wxDC *) 0 ;
12803 int arg2 ;
12804 int arg3 ;
12805 int arg4 ;
12806 int arg5 ;
12807 double arg6 ;
12808 double arg7 ;
12809 PyObject * obj0 = 0 ;
12810 PyObject * obj1 = 0 ;
12811 PyObject * obj2 = 0 ;
12812 PyObject * obj3 = 0 ;
12813 PyObject * obj4 = 0 ;
12814 PyObject * obj5 = 0 ;
12815 PyObject * obj6 = 0 ;
12816 char *kwnames[] = {
12817 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h",(char *) "start",(char *) "end", NULL
12818 };
12819
12820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawEllipticArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12822 if (SWIG_arg_fail(1)) SWIG_fail;
12823 {
12824 arg2 = (int)(SWIG_As_int(obj1));
12825 if (SWIG_arg_fail(2)) SWIG_fail;
12826 }
12827 {
12828 arg3 = (int)(SWIG_As_int(obj2));
12829 if (SWIG_arg_fail(3)) SWIG_fail;
12830 }
12831 {
12832 arg4 = (int)(SWIG_As_int(obj3));
12833 if (SWIG_arg_fail(4)) SWIG_fail;
12834 }
12835 {
12836 arg5 = (int)(SWIG_As_int(obj4));
12837 if (SWIG_arg_fail(5)) SWIG_fail;
12838 }
12839 {
12840 arg6 = (double)(SWIG_As_double(obj5));
12841 if (SWIG_arg_fail(6)) SWIG_fail;
12842 }
12843 {
12844 arg7 = (double)(SWIG_As_double(obj6));
12845 if (SWIG_arg_fail(7)) SWIG_fail;
12846 }
12847 {
12848 PyThreadState* __tstate = wxPyBeginAllowThreads();
12849 (arg1)->DrawEllipticArc(arg2,arg3,arg4,arg5,arg6,arg7);
12850
12851 wxPyEndAllowThreads(__tstate);
12852 if (PyErr_Occurred()) SWIG_fail;
12853 }
12854 Py_INCREF(Py_None); resultobj = Py_None;
12855 return resultobj;
12856 fail:
12857 return NULL;
12858 }
12859
12860
12861 static PyObject *_wrap_DC_DrawEllipticArcPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
12862 PyObject *resultobj;
12863 wxDC *arg1 = (wxDC *) 0 ;
12864 wxPoint *arg2 = 0 ;
12865 wxSize *arg3 = 0 ;
12866 double arg4 ;
12867 double arg5 ;
12868 wxPoint temp2 ;
12869 wxSize temp3 ;
12870 PyObject * obj0 = 0 ;
12871 PyObject * obj1 = 0 ;
12872 PyObject * obj2 = 0 ;
12873 PyObject * obj3 = 0 ;
12874 PyObject * obj4 = 0 ;
12875 char *kwnames[] = {
12876 (char *) "self",(char *) "pt",(char *) "sz",(char *) "start",(char *) "end", NULL
12877 };
12878
12879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipticArcPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12881 if (SWIG_arg_fail(1)) SWIG_fail;
12882 {
12883 arg2 = &temp2;
12884 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12885 }
12886 {
12887 arg3 = &temp3;
12888 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
12889 }
12890 {
12891 arg4 = (double)(SWIG_As_double(obj3));
12892 if (SWIG_arg_fail(4)) SWIG_fail;
12893 }
12894 {
12895 arg5 = (double)(SWIG_As_double(obj4));
12896 if (SWIG_arg_fail(5)) SWIG_fail;
12897 }
12898 {
12899 PyThreadState* __tstate = wxPyBeginAllowThreads();
12900 (arg1)->DrawEllipticArc((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,arg5);
12901
12902 wxPyEndAllowThreads(__tstate);
12903 if (PyErr_Occurred()) SWIG_fail;
12904 }
12905 Py_INCREF(Py_None); resultobj = Py_None;
12906 return resultobj;
12907 fail:
12908 return NULL;
12909 }
12910
12911
12912 static PyObject *_wrap_DC_DrawPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12913 PyObject *resultobj;
12914 wxDC *arg1 = (wxDC *) 0 ;
12915 int arg2 ;
12916 int arg3 ;
12917 PyObject * obj0 = 0 ;
12918 PyObject * obj1 = 0 ;
12919 PyObject * obj2 = 0 ;
12920 char *kwnames[] = {
12921 (char *) "self",(char *) "x",(char *) "y", NULL
12922 };
12923
12924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
12925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12926 if (SWIG_arg_fail(1)) SWIG_fail;
12927 {
12928 arg2 = (int)(SWIG_As_int(obj1));
12929 if (SWIG_arg_fail(2)) SWIG_fail;
12930 }
12931 {
12932 arg3 = (int)(SWIG_As_int(obj2));
12933 if (SWIG_arg_fail(3)) SWIG_fail;
12934 }
12935 {
12936 PyThreadState* __tstate = wxPyBeginAllowThreads();
12937 (arg1)->DrawPoint(arg2,arg3);
12938
12939 wxPyEndAllowThreads(__tstate);
12940 if (PyErr_Occurred()) SWIG_fail;
12941 }
12942 Py_INCREF(Py_None); resultobj = Py_None;
12943 return resultobj;
12944 fail:
12945 return NULL;
12946 }
12947
12948
12949 static PyObject *_wrap_DC_DrawPointPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12950 PyObject *resultobj;
12951 wxDC *arg1 = (wxDC *) 0 ;
12952 wxPoint *arg2 = 0 ;
12953 wxPoint temp2 ;
12954 PyObject * obj0 = 0 ;
12955 PyObject * obj1 = 0 ;
12956 char *kwnames[] = {
12957 (char *) "self",(char *) "pt", NULL
12958 };
12959
12960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawPointPoint",kwnames,&obj0,&obj1)) goto fail;
12961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12962 if (SWIG_arg_fail(1)) SWIG_fail;
12963 {
12964 arg2 = &temp2;
12965 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12966 }
12967 {
12968 PyThreadState* __tstate = wxPyBeginAllowThreads();
12969 (arg1)->DrawPoint((wxPoint const &)*arg2);
12970
12971 wxPyEndAllowThreads(__tstate);
12972 if (PyErr_Occurred()) SWIG_fail;
12973 }
12974 Py_INCREF(Py_None); resultobj = Py_None;
12975 return resultobj;
12976 fail:
12977 return NULL;
12978 }
12979
12980
12981 static PyObject *_wrap_DC_DrawRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
12982 PyObject *resultobj;
12983 wxDC *arg1 = (wxDC *) 0 ;
12984 int arg2 ;
12985 int arg3 ;
12986 int arg4 ;
12987 int arg5 ;
12988 PyObject * obj0 = 0 ;
12989 PyObject * obj1 = 0 ;
12990 PyObject * obj2 = 0 ;
12991 PyObject * obj3 = 0 ;
12992 PyObject * obj4 = 0 ;
12993 char *kwnames[] = {
12994 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
12995 };
12996
12997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12999 if (SWIG_arg_fail(1)) SWIG_fail;
13000 {
13001 arg2 = (int)(SWIG_As_int(obj1));
13002 if (SWIG_arg_fail(2)) SWIG_fail;
13003 }
13004 {
13005 arg3 = (int)(SWIG_As_int(obj2));
13006 if (SWIG_arg_fail(3)) SWIG_fail;
13007 }
13008 {
13009 arg4 = (int)(SWIG_As_int(obj3));
13010 if (SWIG_arg_fail(4)) SWIG_fail;
13011 }
13012 {
13013 arg5 = (int)(SWIG_As_int(obj4));
13014 if (SWIG_arg_fail(5)) SWIG_fail;
13015 }
13016 {
13017 PyThreadState* __tstate = wxPyBeginAllowThreads();
13018 (arg1)->DrawRectangle(arg2,arg3,arg4,arg5);
13019
13020 wxPyEndAllowThreads(__tstate);
13021 if (PyErr_Occurred()) SWIG_fail;
13022 }
13023 Py_INCREF(Py_None); resultobj = Py_None;
13024 return resultobj;
13025 fail:
13026 return NULL;
13027 }
13028
13029
13030 static PyObject *_wrap_DC_DrawRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13031 PyObject *resultobj;
13032 wxDC *arg1 = (wxDC *) 0 ;
13033 wxRect *arg2 = 0 ;
13034 wxRect temp2 ;
13035 PyObject * obj0 = 0 ;
13036 PyObject * obj1 = 0 ;
13037 char *kwnames[] = {
13038 (char *) "self",(char *) "rect", NULL
13039 };
13040
13041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawRectangleRect",kwnames,&obj0,&obj1)) goto fail;
13042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13043 if (SWIG_arg_fail(1)) SWIG_fail;
13044 {
13045 arg2 = &temp2;
13046 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13047 }
13048 {
13049 PyThreadState* __tstate = wxPyBeginAllowThreads();
13050 (arg1)->DrawRectangle((wxRect const &)*arg2);
13051
13052 wxPyEndAllowThreads(__tstate);
13053 if (PyErr_Occurred()) SWIG_fail;
13054 }
13055 Py_INCREF(Py_None); resultobj = Py_None;
13056 return resultobj;
13057 fail:
13058 return NULL;
13059 }
13060
13061
13062 static PyObject *_wrap_DC_DrawRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13063 PyObject *resultobj;
13064 wxDC *arg1 = (wxDC *) 0 ;
13065 wxPoint *arg2 = 0 ;
13066 wxSize *arg3 = 0 ;
13067 wxPoint temp2 ;
13068 wxSize temp3 ;
13069 PyObject * obj0 = 0 ;
13070 PyObject * obj1 = 0 ;
13071 PyObject * obj2 = 0 ;
13072 char *kwnames[] = {
13073 (char *) "self",(char *) "pt",(char *) "sz", NULL
13074 };
13075
13076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRectanglePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13078 if (SWIG_arg_fail(1)) SWIG_fail;
13079 {
13080 arg2 = &temp2;
13081 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13082 }
13083 {
13084 arg3 = &temp3;
13085 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13086 }
13087 {
13088 PyThreadState* __tstate = wxPyBeginAllowThreads();
13089 (arg1)->DrawRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3);
13090
13091 wxPyEndAllowThreads(__tstate);
13092 if (PyErr_Occurred()) SWIG_fail;
13093 }
13094 Py_INCREF(Py_None); resultobj = Py_None;
13095 return resultobj;
13096 fail:
13097 return NULL;
13098 }
13099
13100
13101 static PyObject *_wrap_DC_DrawRoundedRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
13102 PyObject *resultobj;
13103 wxDC *arg1 = (wxDC *) 0 ;
13104 int arg2 ;
13105 int arg3 ;
13106 int arg4 ;
13107 int arg5 ;
13108 double arg6 ;
13109 PyObject * obj0 = 0 ;
13110 PyObject * obj1 = 0 ;
13111 PyObject * obj2 = 0 ;
13112 PyObject * obj3 = 0 ;
13113 PyObject * obj4 = 0 ;
13114 PyObject * obj5 = 0 ;
13115 char *kwnames[] = {
13116 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "radius", NULL
13117 };
13118
13119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:DC_DrawRoundedRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
13120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13121 if (SWIG_arg_fail(1)) SWIG_fail;
13122 {
13123 arg2 = (int)(SWIG_As_int(obj1));
13124 if (SWIG_arg_fail(2)) SWIG_fail;
13125 }
13126 {
13127 arg3 = (int)(SWIG_As_int(obj2));
13128 if (SWIG_arg_fail(3)) SWIG_fail;
13129 }
13130 {
13131 arg4 = (int)(SWIG_As_int(obj3));
13132 if (SWIG_arg_fail(4)) SWIG_fail;
13133 }
13134 {
13135 arg5 = (int)(SWIG_As_int(obj4));
13136 if (SWIG_arg_fail(5)) SWIG_fail;
13137 }
13138 {
13139 arg6 = (double)(SWIG_As_double(obj5));
13140 if (SWIG_arg_fail(6)) SWIG_fail;
13141 }
13142 {
13143 PyThreadState* __tstate = wxPyBeginAllowThreads();
13144 (arg1)->DrawRoundedRectangle(arg2,arg3,arg4,arg5,arg6);
13145
13146 wxPyEndAllowThreads(__tstate);
13147 if (PyErr_Occurred()) SWIG_fail;
13148 }
13149 Py_INCREF(Py_None); resultobj = Py_None;
13150 return resultobj;
13151 fail:
13152 return NULL;
13153 }
13154
13155
13156 static PyObject *_wrap_DC_DrawRoundedRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13157 PyObject *resultobj;
13158 wxDC *arg1 = (wxDC *) 0 ;
13159 wxRect *arg2 = 0 ;
13160 double arg3 ;
13161 wxRect temp2 ;
13162 PyObject * obj0 = 0 ;
13163 PyObject * obj1 = 0 ;
13164 PyObject * obj2 = 0 ;
13165 char *kwnames[] = {
13166 (char *) "self",(char *) "r",(char *) "radius", NULL
13167 };
13168
13169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRoundedRectangleRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
13170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13171 if (SWIG_arg_fail(1)) SWIG_fail;
13172 {
13173 arg2 = &temp2;
13174 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13175 }
13176 {
13177 arg3 = (double)(SWIG_As_double(obj2));
13178 if (SWIG_arg_fail(3)) SWIG_fail;
13179 }
13180 {
13181 PyThreadState* __tstate = wxPyBeginAllowThreads();
13182 (arg1)->DrawRoundedRectangle((wxRect const &)*arg2,arg3);
13183
13184 wxPyEndAllowThreads(__tstate);
13185 if (PyErr_Occurred()) SWIG_fail;
13186 }
13187 Py_INCREF(Py_None); resultobj = Py_None;
13188 return resultobj;
13189 fail:
13190 return NULL;
13191 }
13192
13193
13194 static PyObject *_wrap_DC_DrawRoundedRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13195 PyObject *resultobj;
13196 wxDC *arg1 = (wxDC *) 0 ;
13197 wxPoint *arg2 = 0 ;
13198 wxSize *arg3 = 0 ;
13199 double arg4 ;
13200 wxPoint temp2 ;
13201 wxSize temp3 ;
13202 PyObject * obj0 = 0 ;
13203 PyObject * obj1 = 0 ;
13204 PyObject * obj2 = 0 ;
13205 PyObject * obj3 = 0 ;
13206 char *kwnames[] = {
13207 (char *) "self",(char *) "pt",(char *) "sz",(char *) "radius", NULL
13208 };
13209
13210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRoundedRectanglePointSize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13212 if (SWIG_arg_fail(1)) SWIG_fail;
13213 {
13214 arg2 = &temp2;
13215 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13216 }
13217 {
13218 arg3 = &temp3;
13219 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13220 }
13221 {
13222 arg4 = (double)(SWIG_As_double(obj3));
13223 if (SWIG_arg_fail(4)) SWIG_fail;
13224 }
13225 {
13226 PyThreadState* __tstate = wxPyBeginAllowThreads();
13227 (arg1)->DrawRoundedRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4);
13228
13229 wxPyEndAllowThreads(__tstate);
13230 if (PyErr_Occurred()) SWIG_fail;
13231 }
13232 Py_INCREF(Py_None); resultobj = Py_None;
13233 return resultobj;
13234 fail:
13235 return NULL;
13236 }
13237
13238
13239 static PyObject *_wrap_DC_DrawCircle(PyObject *, PyObject *args, PyObject *kwargs) {
13240 PyObject *resultobj;
13241 wxDC *arg1 = (wxDC *) 0 ;
13242 int arg2 ;
13243 int arg3 ;
13244 int arg4 ;
13245 PyObject * obj0 = 0 ;
13246 PyObject * obj1 = 0 ;
13247 PyObject * obj2 = 0 ;
13248 PyObject * obj3 = 0 ;
13249 char *kwnames[] = {
13250 (char *) "self",(char *) "x",(char *) "y",(char *) "radius", NULL
13251 };
13252
13253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawCircle",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13255 if (SWIG_arg_fail(1)) SWIG_fail;
13256 {
13257 arg2 = (int)(SWIG_As_int(obj1));
13258 if (SWIG_arg_fail(2)) SWIG_fail;
13259 }
13260 {
13261 arg3 = (int)(SWIG_As_int(obj2));
13262 if (SWIG_arg_fail(3)) SWIG_fail;
13263 }
13264 {
13265 arg4 = (int)(SWIG_As_int(obj3));
13266 if (SWIG_arg_fail(4)) SWIG_fail;
13267 }
13268 {
13269 PyThreadState* __tstate = wxPyBeginAllowThreads();
13270 (arg1)->DrawCircle(arg2,arg3,arg4);
13271
13272 wxPyEndAllowThreads(__tstate);
13273 if (PyErr_Occurred()) SWIG_fail;
13274 }
13275 Py_INCREF(Py_None); resultobj = Py_None;
13276 return resultobj;
13277 fail:
13278 return NULL;
13279 }
13280
13281
13282 static PyObject *_wrap_DC_DrawCirclePoint(PyObject *, PyObject *args, PyObject *kwargs) {
13283 PyObject *resultobj;
13284 wxDC *arg1 = (wxDC *) 0 ;
13285 wxPoint *arg2 = 0 ;
13286 int arg3 ;
13287 wxPoint temp2 ;
13288 PyObject * obj0 = 0 ;
13289 PyObject * obj1 = 0 ;
13290 PyObject * obj2 = 0 ;
13291 char *kwnames[] = {
13292 (char *) "self",(char *) "pt",(char *) "radius", NULL
13293 };
13294
13295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawCirclePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13297 if (SWIG_arg_fail(1)) SWIG_fail;
13298 {
13299 arg2 = &temp2;
13300 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13301 }
13302 {
13303 arg3 = (int)(SWIG_As_int(obj2));
13304 if (SWIG_arg_fail(3)) SWIG_fail;
13305 }
13306 {
13307 PyThreadState* __tstate = wxPyBeginAllowThreads();
13308 (arg1)->DrawCircle((wxPoint const &)*arg2,arg3);
13309
13310 wxPyEndAllowThreads(__tstate);
13311 if (PyErr_Occurred()) SWIG_fail;
13312 }
13313 Py_INCREF(Py_None); resultobj = Py_None;
13314 return resultobj;
13315 fail:
13316 return NULL;
13317 }
13318
13319
13320 static PyObject *_wrap_DC_DrawEllipse(PyObject *, PyObject *args, PyObject *kwargs) {
13321 PyObject *resultobj;
13322 wxDC *arg1 = (wxDC *) 0 ;
13323 int arg2 ;
13324 int arg3 ;
13325 int arg4 ;
13326 int arg5 ;
13327 PyObject * obj0 = 0 ;
13328 PyObject * obj1 = 0 ;
13329 PyObject * obj2 = 0 ;
13330 PyObject * obj3 = 0 ;
13331 PyObject * obj4 = 0 ;
13332 char *kwnames[] = {
13333 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13334 };
13335
13336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipse",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13338 if (SWIG_arg_fail(1)) SWIG_fail;
13339 {
13340 arg2 = (int)(SWIG_As_int(obj1));
13341 if (SWIG_arg_fail(2)) SWIG_fail;
13342 }
13343 {
13344 arg3 = (int)(SWIG_As_int(obj2));
13345 if (SWIG_arg_fail(3)) SWIG_fail;
13346 }
13347 {
13348 arg4 = (int)(SWIG_As_int(obj3));
13349 if (SWIG_arg_fail(4)) SWIG_fail;
13350 }
13351 {
13352 arg5 = (int)(SWIG_As_int(obj4));
13353 if (SWIG_arg_fail(5)) SWIG_fail;
13354 }
13355 {
13356 PyThreadState* __tstate = wxPyBeginAllowThreads();
13357 (arg1)->DrawEllipse(arg2,arg3,arg4,arg5);
13358
13359 wxPyEndAllowThreads(__tstate);
13360 if (PyErr_Occurred()) SWIG_fail;
13361 }
13362 Py_INCREF(Py_None); resultobj = Py_None;
13363 return resultobj;
13364 fail:
13365 return NULL;
13366 }
13367
13368
13369 static PyObject *_wrap_DC_DrawEllipseRect(PyObject *, PyObject *args, PyObject *kwargs) {
13370 PyObject *resultobj;
13371 wxDC *arg1 = (wxDC *) 0 ;
13372 wxRect *arg2 = 0 ;
13373 wxRect temp2 ;
13374 PyObject * obj0 = 0 ;
13375 PyObject * obj1 = 0 ;
13376 char *kwnames[] = {
13377 (char *) "self",(char *) "rect", NULL
13378 };
13379
13380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawEllipseRect",kwnames,&obj0,&obj1)) goto fail;
13381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13382 if (SWIG_arg_fail(1)) SWIG_fail;
13383 {
13384 arg2 = &temp2;
13385 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13386 }
13387 {
13388 PyThreadState* __tstate = wxPyBeginAllowThreads();
13389 (arg1)->DrawEllipse((wxRect const &)*arg2);
13390
13391 wxPyEndAllowThreads(__tstate);
13392 if (PyErr_Occurred()) SWIG_fail;
13393 }
13394 Py_INCREF(Py_None); resultobj = Py_None;
13395 return resultobj;
13396 fail:
13397 return NULL;
13398 }
13399
13400
13401 static PyObject *_wrap_DC_DrawEllipsePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13402 PyObject *resultobj;
13403 wxDC *arg1 = (wxDC *) 0 ;
13404 wxPoint *arg2 = 0 ;
13405 wxSize *arg3 = 0 ;
13406 wxPoint temp2 ;
13407 wxSize temp3 ;
13408 PyObject * obj0 = 0 ;
13409 PyObject * obj1 = 0 ;
13410 PyObject * obj2 = 0 ;
13411 char *kwnames[] = {
13412 (char *) "self",(char *) "pt",(char *) "sz", NULL
13413 };
13414
13415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawEllipsePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13417 if (SWIG_arg_fail(1)) SWIG_fail;
13418 {
13419 arg2 = &temp2;
13420 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13421 }
13422 {
13423 arg3 = &temp3;
13424 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13425 }
13426 {
13427 PyThreadState* __tstate = wxPyBeginAllowThreads();
13428 (arg1)->DrawEllipse((wxPoint const &)*arg2,(wxSize const &)*arg3);
13429
13430 wxPyEndAllowThreads(__tstate);
13431 if (PyErr_Occurred()) SWIG_fail;
13432 }
13433 Py_INCREF(Py_None); resultobj = Py_None;
13434 return resultobj;
13435 fail:
13436 return NULL;
13437 }
13438
13439
13440 static PyObject *_wrap_DC_DrawIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13441 PyObject *resultobj;
13442 wxDC *arg1 = (wxDC *) 0 ;
13443 wxIcon *arg2 = 0 ;
13444 int arg3 ;
13445 int arg4 ;
13446 PyObject * obj0 = 0 ;
13447 PyObject * obj1 = 0 ;
13448 PyObject * obj2 = 0 ;
13449 PyObject * obj3 = 0 ;
13450 char *kwnames[] = {
13451 (char *) "self",(char *) "icon",(char *) "x",(char *) "y", NULL
13452 };
13453
13454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawIcon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13456 if (SWIG_arg_fail(1)) SWIG_fail;
13457 {
13458 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
13459 if (SWIG_arg_fail(2)) SWIG_fail;
13460 if (arg2 == NULL) {
13461 SWIG_null_ref("wxIcon");
13462 }
13463 if (SWIG_arg_fail(2)) SWIG_fail;
13464 }
13465 {
13466 arg3 = (int)(SWIG_As_int(obj2));
13467 if (SWIG_arg_fail(3)) SWIG_fail;
13468 }
13469 {
13470 arg4 = (int)(SWIG_As_int(obj3));
13471 if (SWIG_arg_fail(4)) SWIG_fail;
13472 }
13473 {
13474 PyThreadState* __tstate = wxPyBeginAllowThreads();
13475 (arg1)->DrawIcon((wxIcon const &)*arg2,arg3,arg4);
13476
13477 wxPyEndAllowThreads(__tstate);
13478 if (PyErr_Occurred()) SWIG_fail;
13479 }
13480 Py_INCREF(Py_None); resultobj = Py_None;
13481 return resultobj;
13482 fail:
13483 return NULL;
13484 }
13485
13486
13487 static PyObject *_wrap_DC_DrawIconPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13488 PyObject *resultobj;
13489 wxDC *arg1 = (wxDC *) 0 ;
13490 wxIcon *arg2 = 0 ;
13491 wxPoint *arg3 = 0 ;
13492 wxPoint temp3 ;
13493 PyObject * obj0 = 0 ;
13494 PyObject * obj1 = 0 ;
13495 PyObject * obj2 = 0 ;
13496 char *kwnames[] = {
13497 (char *) "self",(char *) "icon",(char *) "pt", NULL
13498 };
13499
13500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawIconPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13502 if (SWIG_arg_fail(1)) SWIG_fail;
13503 {
13504 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
13505 if (SWIG_arg_fail(2)) SWIG_fail;
13506 if (arg2 == NULL) {
13507 SWIG_null_ref("wxIcon");
13508 }
13509 if (SWIG_arg_fail(2)) SWIG_fail;
13510 }
13511 {
13512 arg3 = &temp3;
13513 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13514 }
13515 {
13516 PyThreadState* __tstate = wxPyBeginAllowThreads();
13517 (arg1)->DrawIcon((wxIcon const &)*arg2,(wxPoint const &)*arg3);
13518
13519 wxPyEndAllowThreads(__tstate);
13520 if (PyErr_Occurred()) SWIG_fail;
13521 }
13522 Py_INCREF(Py_None); resultobj = Py_None;
13523 return resultobj;
13524 fail:
13525 return NULL;
13526 }
13527
13528
13529 static PyObject *_wrap_DC_DrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13530 PyObject *resultobj;
13531 wxDC *arg1 = (wxDC *) 0 ;
13532 wxBitmap *arg2 = 0 ;
13533 int arg3 ;
13534 int arg4 ;
13535 bool arg5 = (bool) false ;
13536 PyObject * obj0 = 0 ;
13537 PyObject * obj1 = 0 ;
13538 PyObject * obj2 = 0 ;
13539 PyObject * obj3 = 0 ;
13540 PyObject * obj4 = 0 ;
13541 char *kwnames[] = {
13542 (char *) "self",(char *) "bmp",(char *) "x",(char *) "y",(char *) "useMask", NULL
13543 };
13544
13545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_DrawBitmap",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13547 if (SWIG_arg_fail(1)) SWIG_fail;
13548 {
13549 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
13550 if (SWIG_arg_fail(2)) SWIG_fail;
13551 if (arg2 == NULL) {
13552 SWIG_null_ref("wxBitmap");
13553 }
13554 if (SWIG_arg_fail(2)) SWIG_fail;
13555 }
13556 {
13557 arg3 = (int)(SWIG_As_int(obj2));
13558 if (SWIG_arg_fail(3)) SWIG_fail;
13559 }
13560 {
13561 arg4 = (int)(SWIG_As_int(obj3));
13562 if (SWIG_arg_fail(4)) SWIG_fail;
13563 }
13564 if (obj4) {
13565 {
13566 arg5 = (bool)(SWIG_As_bool(obj4));
13567 if (SWIG_arg_fail(5)) SWIG_fail;
13568 }
13569 }
13570 {
13571 PyThreadState* __tstate = wxPyBeginAllowThreads();
13572 (arg1)->DrawBitmap((wxBitmap const &)*arg2,arg3,arg4,arg5);
13573
13574 wxPyEndAllowThreads(__tstate);
13575 if (PyErr_Occurred()) SWIG_fail;
13576 }
13577 Py_INCREF(Py_None); resultobj = Py_None;
13578 return resultobj;
13579 fail:
13580 return NULL;
13581 }
13582
13583
13584 static PyObject *_wrap_DC_DrawBitmapPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13585 PyObject *resultobj;
13586 wxDC *arg1 = (wxDC *) 0 ;
13587 wxBitmap *arg2 = 0 ;
13588 wxPoint *arg3 = 0 ;
13589 bool arg4 = (bool) false ;
13590 wxPoint temp3 ;
13591 PyObject * obj0 = 0 ;
13592 PyObject * obj1 = 0 ;
13593 PyObject * obj2 = 0 ;
13594 PyObject * obj3 = 0 ;
13595 char *kwnames[] = {
13596 (char *) "self",(char *) "bmp",(char *) "pt",(char *) "useMask", NULL
13597 };
13598
13599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_DrawBitmapPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13601 if (SWIG_arg_fail(1)) SWIG_fail;
13602 {
13603 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
13604 if (SWIG_arg_fail(2)) SWIG_fail;
13605 if (arg2 == NULL) {
13606 SWIG_null_ref("wxBitmap");
13607 }
13608 if (SWIG_arg_fail(2)) SWIG_fail;
13609 }
13610 {
13611 arg3 = &temp3;
13612 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13613 }
13614 if (obj3) {
13615 {
13616 arg4 = (bool)(SWIG_As_bool(obj3));
13617 if (SWIG_arg_fail(4)) SWIG_fail;
13618 }
13619 }
13620 {
13621 PyThreadState* __tstate = wxPyBeginAllowThreads();
13622 (arg1)->DrawBitmap((wxBitmap const &)*arg2,(wxPoint const &)*arg3,arg4);
13623
13624 wxPyEndAllowThreads(__tstate);
13625 if (PyErr_Occurred()) SWIG_fail;
13626 }
13627 Py_INCREF(Py_None); resultobj = Py_None;
13628 return resultobj;
13629 fail:
13630 return NULL;
13631 }
13632
13633
13634 static PyObject *_wrap_DC_DrawText(PyObject *, PyObject *args, PyObject *kwargs) {
13635 PyObject *resultobj;
13636 wxDC *arg1 = (wxDC *) 0 ;
13637 wxString *arg2 = 0 ;
13638 int arg3 ;
13639 int arg4 ;
13640 bool temp2 = false ;
13641 PyObject * obj0 = 0 ;
13642 PyObject * obj1 = 0 ;
13643 PyObject * obj2 = 0 ;
13644 PyObject * obj3 = 0 ;
13645 char *kwnames[] = {
13646 (char *) "self",(char *) "text",(char *) "x",(char *) "y", NULL
13647 };
13648
13649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawText",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13651 if (SWIG_arg_fail(1)) SWIG_fail;
13652 {
13653 arg2 = wxString_in_helper(obj1);
13654 if (arg2 == NULL) SWIG_fail;
13655 temp2 = true;
13656 }
13657 {
13658 arg3 = (int)(SWIG_As_int(obj2));
13659 if (SWIG_arg_fail(3)) SWIG_fail;
13660 }
13661 {
13662 arg4 = (int)(SWIG_As_int(obj3));
13663 if (SWIG_arg_fail(4)) SWIG_fail;
13664 }
13665 {
13666 PyThreadState* __tstate = wxPyBeginAllowThreads();
13667 (arg1)->DrawText((wxString const &)*arg2,arg3,arg4);
13668
13669 wxPyEndAllowThreads(__tstate);
13670 if (PyErr_Occurred()) SWIG_fail;
13671 }
13672 Py_INCREF(Py_None); resultobj = Py_None;
13673 {
13674 if (temp2)
13675 delete arg2;
13676 }
13677 return resultobj;
13678 fail:
13679 {
13680 if (temp2)
13681 delete arg2;
13682 }
13683 return NULL;
13684 }
13685
13686
13687 static PyObject *_wrap_DC_DrawTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13688 PyObject *resultobj;
13689 wxDC *arg1 = (wxDC *) 0 ;
13690 wxString *arg2 = 0 ;
13691 wxPoint *arg3 = 0 ;
13692 bool temp2 = false ;
13693 wxPoint temp3 ;
13694 PyObject * obj0 = 0 ;
13695 PyObject * obj1 = 0 ;
13696 PyObject * obj2 = 0 ;
13697 char *kwnames[] = {
13698 (char *) "self",(char *) "text",(char *) "pt", NULL
13699 };
13700
13701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawTextPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13703 if (SWIG_arg_fail(1)) SWIG_fail;
13704 {
13705 arg2 = wxString_in_helper(obj1);
13706 if (arg2 == NULL) SWIG_fail;
13707 temp2 = true;
13708 }
13709 {
13710 arg3 = &temp3;
13711 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13712 }
13713 {
13714 PyThreadState* __tstate = wxPyBeginAllowThreads();
13715 (arg1)->DrawText((wxString const &)*arg2,(wxPoint const &)*arg3);
13716
13717 wxPyEndAllowThreads(__tstate);
13718 if (PyErr_Occurred()) SWIG_fail;
13719 }
13720 Py_INCREF(Py_None); resultobj = Py_None;
13721 {
13722 if (temp2)
13723 delete arg2;
13724 }
13725 return resultobj;
13726 fail:
13727 {
13728 if (temp2)
13729 delete arg2;
13730 }
13731 return NULL;
13732 }
13733
13734
13735 static PyObject *_wrap_DC_DrawRotatedText(PyObject *, PyObject *args, PyObject *kwargs) {
13736 PyObject *resultobj;
13737 wxDC *arg1 = (wxDC *) 0 ;
13738 wxString *arg2 = 0 ;
13739 int arg3 ;
13740 int arg4 ;
13741 double arg5 ;
13742 bool temp2 = false ;
13743 PyObject * obj0 = 0 ;
13744 PyObject * obj1 = 0 ;
13745 PyObject * obj2 = 0 ;
13746 PyObject * obj3 = 0 ;
13747 PyObject * obj4 = 0 ;
13748 char *kwnames[] = {
13749 (char *) "self",(char *) "text",(char *) "x",(char *) "y",(char *) "angle", NULL
13750 };
13751
13752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRotatedText",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13754 if (SWIG_arg_fail(1)) SWIG_fail;
13755 {
13756 arg2 = wxString_in_helper(obj1);
13757 if (arg2 == NULL) SWIG_fail;
13758 temp2 = true;
13759 }
13760 {
13761 arg3 = (int)(SWIG_As_int(obj2));
13762 if (SWIG_arg_fail(3)) SWIG_fail;
13763 }
13764 {
13765 arg4 = (int)(SWIG_As_int(obj3));
13766 if (SWIG_arg_fail(4)) SWIG_fail;
13767 }
13768 {
13769 arg5 = (double)(SWIG_As_double(obj4));
13770 if (SWIG_arg_fail(5)) SWIG_fail;
13771 }
13772 {
13773 PyThreadState* __tstate = wxPyBeginAllowThreads();
13774 (arg1)->DrawRotatedText((wxString const &)*arg2,arg3,arg4,arg5);
13775
13776 wxPyEndAllowThreads(__tstate);
13777 if (PyErr_Occurred()) SWIG_fail;
13778 }
13779 Py_INCREF(Py_None); resultobj = Py_None;
13780 {
13781 if (temp2)
13782 delete arg2;
13783 }
13784 return resultobj;
13785 fail:
13786 {
13787 if (temp2)
13788 delete arg2;
13789 }
13790 return NULL;
13791 }
13792
13793
13794 static PyObject *_wrap_DC_DrawRotatedTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13795 PyObject *resultobj;
13796 wxDC *arg1 = (wxDC *) 0 ;
13797 wxString *arg2 = 0 ;
13798 wxPoint *arg3 = 0 ;
13799 double arg4 ;
13800 bool temp2 = false ;
13801 wxPoint temp3 ;
13802 PyObject * obj0 = 0 ;
13803 PyObject * obj1 = 0 ;
13804 PyObject * obj2 = 0 ;
13805 PyObject * obj3 = 0 ;
13806 char *kwnames[] = {
13807 (char *) "self",(char *) "text",(char *) "pt",(char *) "angle", NULL
13808 };
13809
13810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRotatedTextPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13812 if (SWIG_arg_fail(1)) SWIG_fail;
13813 {
13814 arg2 = wxString_in_helper(obj1);
13815 if (arg2 == NULL) SWIG_fail;
13816 temp2 = true;
13817 }
13818 {
13819 arg3 = &temp3;
13820 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13821 }
13822 {
13823 arg4 = (double)(SWIG_As_double(obj3));
13824 if (SWIG_arg_fail(4)) SWIG_fail;
13825 }
13826 {
13827 PyThreadState* __tstate = wxPyBeginAllowThreads();
13828 (arg1)->DrawRotatedText((wxString const &)*arg2,(wxPoint const &)*arg3,arg4);
13829
13830 wxPyEndAllowThreads(__tstate);
13831 if (PyErr_Occurred()) SWIG_fail;
13832 }
13833 Py_INCREF(Py_None); resultobj = Py_None;
13834 {
13835 if (temp2)
13836 delete arg2;
13837 }
13838 return resultobj;
13839 fail:
13840 {
13841 if (temp2)
13842 delete arg2;
13843 }
13844 return NULL;
13845 }
13846
13847
13848 static PyObject *_wrap_DC_Blit(PyObject *, PyObject *args, PyObject *kwargs) {
13849 PyObject *resultobj;
13850 wxDC *arg1 = (wxDC *) 0 ;
13851 int arg2 ;
13852 int arg3 ;
13853 int arg4 ;
13854 int arg5 ;
13855 wxDC *arg6 = (wxDC *) 0 ;
13856 int arg7 ;
13857 int arg8 ;
13858 int arg9 = (int) wxCOPY ;
13859 bool arg10 = (bool) false ;
13860 int arg11 = (int) -1 ;
13861 int arg12 = (int) -1 ;
13862 bool result;
13863 PyObject * obj0 = 0 ;
13864 PyObject * obj1 = 0 ;
13865 PyObject * obj2 = 0 ;
13866 PyObject * obj3 = 0 ;
13867 PyObject * obj4 = 0 ;
13868 PyObject * obj5 = 0 ;
13869 PyObject * obj6 = 0 ;
13870 PyObject * obj7 = 0 ;
13871 PyObject * obj8 = 0 ;
13872 PyObject * obj9 = 0 ;
13873 PyObject * obj10 = 0 ;
13874 PyObject * obj11 = 0 ;
13875 char *kwnames[] = {
13876 (char *) "self",(char *) "xdest",(char *) "ydest",(char *) "width",(char *) "height",(char *) "source",(char *) "xsrc",(char *) "ysrc",(char *) "rop",(char *) "useMask",(char *) "xsrcMask",(char *) "ysrcMask", NULL
13877 };
13878
13879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOOO|OOOO:DC_Blit",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) goto fail;
13880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13881 if (SWIG_arg_fail(1)) SWIG_fail;
13882 {
13883 arg2 = (int)(SWIG_As_int(obj1));
13884 if (SWIG_arg_fail(2)) SWIG_fail;
13885 }
13886 {
13887 arg3 = (int)(SWIG_As_int(obj2));
13888 if (SWIG_arg_fail(3)) SWIG_fail;
13889 }
13890 {
13891 arg4 = (int)(SWIG_As_int(obj3));
13892 if (SWIG_arg_fail(4)) SWIG_fail;
13893 }
13894 {
13895 arg5 = (int)(SWIG_As_int(obj4));
13896 if (SWIG_arg_fail(5)) SWIG_fail;
13897 }
13898 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13899 if (SWIG_arg_fail(6)) SWIG_fail;
13900 {
13901 arg7 = (int)(SWIG_As_int(obj6));
13902 if (SWIG_arg_fail(7)) SWIG_fail;
13903 }
13904 {
13905 arg8 = (int)(SWIG_As_int(obj7));
13906 if (SWIG_arg_fail(8)) SWIG_fail;
13907 }
13908 if (obj8) {
13909 {
13910 arg9 = (int)(SWIG_As_int(obj8));
13911 if (SWIG_arg_fail(9)) SWIG_fail;
13912 }
13913 }
13914 if (obj9) {
13915 {
13916 arg10 = (bool)(SWIG_As_bool(obj9));
13917 if (SWIG_arg_fail(10)) SWIG_fail;
13918 }
13919 }
13920 if (obj10) {
13921 {
13922 arg11 = (int)(SWIG_As_int(obj10));
13923 if (SWIG_arg_fail(11)) SWIG_fail;
13924 }
13925 }
13926 if (obj11) {
13927 {
13928 arg12 = (int)(SWIG_As_int(obj11));
13929 if (SWIG_arg_fail(12)) SWIG_fail;
13930 }
13931 }
13932 {
13933 PyThreadState* __tstate = wxPyBeginAllowThreads();
13934 result = (bool)(arg1)->Blit(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
13935
13936 wxPyEndAllowThreads(__tstate);
13937 if (PyErr_Occurred()) SWIG_fail;
13938 }
13939 {
13940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13941 }
13942 return resultobj;
13943 fail:
13944 return NULL;
13945 }
13946
13947
13948 static PyObject *_wrap_DC_BlitPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13949 PyObject *resultobj;
13950 wxDC *arg1 = (wxDC *) 0 ;
13951 wxPoint *arg2 = 0 ;
13952 wxSize *arg3 = 0 ;
13953 wxDC *arg4 = (wxDC *) 0 ;
13954 wxPoint *arg5 = 0 ;
13955 int arg6 = (int) wxCOPY ;
13956 bool arg7 = (bool) false ;
13957 wxPoint const &arg8_defvalue = wxDefaultPosition ;
13958 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
13959 bool result;
13960 wxPoint temp2 ;
13961 wxSize temp3 ;
13962 wxPoint temp5 ;
13963 wxPoint temp8 ;
13964 PyObject * obj0 = 0 ;
13965 PyObject * obj1 = 0 ;
13966 PyObject * obj2 = 0 ;
13967 PyObject * obj3 = 0 ;
13968 PyObject * obj4 = 0 ;
13969 PyObject * obj5 = 0 ;
13970 PyObject * obj6 = 0 ;
13971 PyObject * obj7 = 0 ;
13972 char *kwnames[] = {
13973 (char *) "self",(char *) "destPt",(char *) "sz",(char *) "source",(char *) "srcPt",(char *) "rop",(char *) "useMask",(char *) "srcPtMask", NULL
13974 };
13975
13976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:DC_BlitPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
13977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13978 if (SWIG_arg_fail(1)) SWIG_fail;
13979 {
13980 arg2 = &temp2;
13981 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13982 }
13983 {
13984 arg3 = &temp3;
13985 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13986 }
13987 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13988 if (SWIG_arg_fail(4)) SWIG_fail;
13989 {
13990 arg5 = &temp5;
13991 if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
13992 }
13993 if (obj5) {
13994 {
13995 arg6 = (int)(SWIG_As_int(obj5));
13996 if (SWIG_arg_fail(6)) SWIG_fail;
13997 }
13998 }
13999 if (obj6) {
14000 {
14001 arg7 = (bool)(SWIG_As_bool(obj6));
14002 if (SWIG_arg_fail(7)) SWIG_fail;
14003 }
14004 }
14005 if (obj7) {
14006 {
14007 arg8 = &temp8;
14008 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
14009 }
14010 }
14011 {
14012 PyThreadState* __tstate = wxPyBeginAllowThreads();
14013 result = (bool)(arg1)->Blit((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,(wxPoint const &)*arg5,arg6,arg7,(wxPoint const &)*arg8);
14014
14015 wxPyEndAllowThreads(__tstate);
14016 if (PyErr_Occurred()) SWIG_fail;
14017 }
14018 {
14019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14020 }
14021 return resultobj;
14022 fail:
14023 return NULL;
14024 }
14025
14026
14027 static PyObject *_wrap_DC_SetClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14028 PyObject *resultobj;
14029 wxDC *arg1 = (wxDC *) 0 ;
14030 int arg2 ;
14031 int arg3 ;
14032 int arg4 ;
14033 int arg5 ;
14034 PyObject * obj0 = 0 ;
14035 PyObject * obj1 = 0 ;
14036 PyObject * obj2 = 0 ;
14037 PyObject * obj3 = 0 ;
14038 PyObject * obj4 = 0 ;
14039 char *kwnames[] = {
14040 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
14041 };
14042
14043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_SetClippingRegion",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14045 if (SWIG_arg_fail(1)) SWIG_fail;
14046 {
14047 arg2 = (int)(SWIG_As_int(obj1));
14048 if (SWIG_arg_fail(2)) SWIG_fail;
14049 }
14050 {
14051 arg3 = (int)(SWIG_As_int(obj2));
14052 if (SWIG_arg_fail(3)) SWIG_fail;
14053 }
14054 {
14055 arg4 = (int)(SWIG_As_int(obj3));
14056 if (SWIG_arg_fail(4)) SWIG_fail;
14057 }
14058 {
14059 arg5 = (int)(SWIG_As_int(obj4));
14060 if (SWIG_arg_fail(5)) SWIG_fail;
14061 }
14062 {
14063 PyThreadState* __tstate = wxPyBeginAllowThreads();
14064 (arg1)->SetClippingRegion(arg2,arg3,arg4,arg5);
14065
14066 wxPyEndAllowThreads(__tstate);
14067 if (PyErr_Occurred()) SWIG_fail;
14068 }
14069 Py_INCREF(Py_None); resultobj = Py_None;
14070 return resultobj;
14071 fail:
14072 return NULL;
14073 }
14074
14075
14076 static PyObject *_wrap_DC_SetClippingRegionPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14077 PyObject *resultobj;
14078 wxDC *arg1 = (wxDC *) 0 ;
14079 wxPoint *arg2 = 0 ;
14080 wxSize *arg3 = 0 ;
14081 wxPoint temp2 ;
14082 wxSize temp3 ;
14083 PyObject * obj0 = 0 ;
14084 PyObject * obj1 = 0 ;
14085 PyObject * obj2 = 0 ;
14086 char *kwnames[] = {
14087 (char *) "self",(char *) "pt",(char *) "sz", NULL
14088 };
14089
14090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetClippingRegionPointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14092 if (SWIG_arg_fail(1)) SWIG_fail;
14093 {
14094 arg2 = &temp2;
14095 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14096 }
14097 {
14098 arg3 = &temp3;
14099 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14100 }
14101 {
14102 PyThreadState* __tstate = wxPyBeginAllowThreads();
14103 (arg1)->SetClippingRegion((wxPoint const &)*arg2,(wxSize const &)*arg3);
14104
14105 wxPyEndAllowThreads(__tstate);
14106 if (PyErr_Occurred()) SWIG_fail;
14107 }
14108 Py_INCREF(Py_None); resultobj = Py_None;
14109 return resultobj;
14110 fail:
14111 return NULL;
14112 }
14113
14114
14115 static PyObject *_wrap_DC_SetClippingRegionAsRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14116 PyObject *resultobj;
14117 wxDC *arg1 = (wxDC *) 0 ;
14118 wxRegion *arg2 = 0 ;
14119 PyObject * obj0 = 0 ;
14120 PyObject * obj1 = 0 ;
14121 char *kwnames[] = {
14122 (char *) "self",(char *) "region", NULL
14123 };
14124
14125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRegionAsRegion",kwnames,&obj0,&obj1)) goto fail;
14126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14127 if (SWIG_arg_fail(1)) SWIG_fail;
14128 {
14129 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
14130 if (SWIG_arg_fail(2)) SWIG_fail;
14131 if (arg2 == NULL) {
14132 SWIG_null_ref("wxRegion");
14133 }
14134 if (SWIG_arg_fail(2)) SWIG_fail;
14135 }
14136 {
14137 PyThreadState* __tstate = wxPyBeginAllowThreads();
14138 (arg1)->SetClippingRegion((wxRegion const &)*arg2);
14139
14140 wxPyEndAllowThreads(__tstate);
14141 if (PyErr_Occurred()) SWIG_fail;
14142 }
14143 Py_INCREF(Py_None); resultobj = Py_None;
14144 return resultobj;
14145 fail:
14146 return NULL;
14147 }
14148
14149
14150 static PyObject *_wrap_DC_SetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
14151 PyObject *resultobj;
14152 wxDC *arg1 = (wxDC *) 0 ;
14153 wxRect *arg2 = 0 ;
14154 wxRect temp2 ;
14155 PyObject * obj0 = 0 ;
14156 PyObject * obj1 = 0 ;
14157 char *kwnames[] = {
14158 (char *) "self",(char *) "rect", NULL
14159 };
14160
14161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRect",kwnames,&obj0,&obj1)) goto fail;
14162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14163 if (SWIG_arg_fail(1)) SWIG_fail;
14164 {
14165 arg2 = &temp2;
14166 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14167 }
14168 {
14169 PyThreadState* __tstate = wxPyBeginAllowThreads();
14170 (arg1)->SetClippingRegion((wxRect const &)*arg2);
14171
14172 wxPyEndAllowThreads(__tstate);
14173 if (PyErr_Occurred()) SWIG_fail;
14174 }
14175 Py_INCREF(Py_None); resultobj = Py_None;
14176 return resultobj;
14177 fail:
14178 return NULL;
14179 }
14180
14181
14182 static PyObject *_wrap_DC_DrawLines(PyObject *, PyObject *args, PyObject *kwargs) {
14183 PyObject *resultobj;
14184 wxDC *arg1 = (wxDC *) 0 ;
14185 int arg2 ;
14186 wxPoint *arg3 = (wxPoint *) 0 ;
14187 int arg4 = (int) 0 ;
14188 int arg5 = (int) 0 ;
14189 PyObject * obj0 = 0 ;
14190 PyObject * obj1 = 0 ;
14191 PyObject * obj2 = 0 ;
14192 PyObject * obj3 = 0 ;
14193 char *kwnames[] = {
14194 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset", NULL
14195 };
14196
14197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DC_DrawLines",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14199 if (SWIG_arg_fail(1)) SWIG_fail;
14200 {
14201 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14202 if (arg3 == NULL) SWIG_fail;
14203 }
14204 if (obj2) {
14205 {
14206 arg4 = (int)(SWIG_As_int(obj2));
14207 if (SWIG_arg_fail(4)) SWIG_fail;
14208 }
14209 }
14210 if (obj3) {
14211 {
14212 arg5 = (int)(SWIG_As_int(obj3));
14213 if (SWIG_arg_fail(5)) SWIG_fail;
14214 }
14215 }
14216 {
14217 PyThreadState* __tstate = wxPyBeginAllowThreads();
14218 (arg1)->DrawLines(arg2,arg3,arg4,arg5);
14219
14220 wxPyEndAllowThreads(__tstate);
14221 if (PyErr_Occurred()) SWIG_fail;
14222 }
14223 Py_INCREF(Py_None); resultobj = Py_None;
14224 {
14225 if (arg3) delete [] arg3;
14226 }
14227 return resultobj;
14228 fail:
14229 {
14230 if (arg3) delete [] arg3;
14231 }
14232 return NULL;
14233 }
14234
14235
14236 static PyObject *_wrap_DC_DrawPolygon(PyObject *, PyObject *args, PyObject *kwargs) {
14237 PyObject *resultobj;
14238 wxDC *arg1 = (wxDC *) 0 ;
14239 int arg2 ;
14240 wxPoint *arg3 = (wxPoint *) 0 ;
14241 int arg4 = (int) 0 ;
14242 int arg5 = (int) 0 ;
14243 int arg6 = (int) wxODDEVEN_RULE ;
14244 PyObject * obj0 = 0 ;
14245 PyObject * obj1 = 0 ;
14246 PyObject * obj2 = 0 ;
14247 PyObject * obj3 = 0 ;
14248 PyObject * obj4 = 0 ;
14249 char *kwnames[] = {
14250 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset",(char *) "fillStyle", NULL
14251 };
14252
14253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DC_DrawPolygon",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14255 if (SWIG_arg_fail(1)) SWIG_fail;
14256 {
14257 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14258 if (arg3 == NULL) SWIG_fail;
14259 }
14260 if (obj2) {
14261 {
14262 arg4 = (int)(SWIG_As_int(obj2));
14263 if (SWIG_arg_fail(4)) SWIG_fail;
14264 }
14265 }
14266 if (obj3) {
14267 {
14268 arg5 = (int)(SWIG_As_int(obj3));
14269 if (SWIG_arg_fail(5)) SWIG_fail;
14270 }
14271 }
14272 if (obj4) {
14273 {
14274 arg6 = (int)(SWIG_As_int(obj4));
14275 if (SWIG_arg_fail(6)) SWIG_fail;
14276 }
14277 }
14278 {
14279 PyThreadState* __tstate = wxPyBeginAllowThreads();
14280 (arg1)->DrawPolygon(arg2,arg3,arg4,arg5,arg6);
14281
14282 wxPyEndAllowThreads(__tstate);
14283 if (PyErr_Occurred()) SWIG_fail;
14284 }
14285 Py_INCREF(Py_None); resultobj = Py_None;
14286 {
14287 if (arg3) delete [] arg3;
14288 }
14289 return resultobj;
14290 fail:
14291 {
14292 if (arg3) delete [] arg3;
14293 }
14294 return NULL;
14295 }
14296
14297
14298 static PyObject *_wrap_DC_DrawLabel(PyObject *, PyObject *args, PyObject *kwargs) {
14299 PyObject *resultobj;
14300 wxDC *arg1 = (wxDC *) 0 ;
14301 wxString *arg2 = 0 ;
14302 wxRect *arg3 = 0 ;
14303 int arg4 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
14304 int arg5 = (int) -1 ;
14305 bool temp2 = false ;
14306 wxRect temp3 ;
14307 PyObject * obj0 = 0 ;
14308 PyObject * obj1 = 0 ;
14309 PyObject * obj2 = 0 ;
14310 PyObject * obj3 = 0 ;
14311 PyObject * obj4 = 0 ;
14312 char *kwnames[] = {
14313 (char *) "self",(char *) "text",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
14314 };
14315
14316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:DC_DrawLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14318 if (SWIG_arg_fail(1)) SWIG_fail;
14319 {
14320 arg2 = wxString_in_helper(obj1);
14321 if (arg2 == NULL) SWIG_fail;
14322 temp2 = true;
14323 }
14324 {
14325 arg3 = &temp3;
14326 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
14327 }
14328 if (obj3) {
14329 {
14330 arg4 = (int)(SWIG_As_int(obj3));
14331 if (SWIG_arg_fail(4)) SWIG_fail;
14332 }
14333 }
14334 if (obj4) {
14335 {
14336 arg5 = (int)(SWIG_As_int(obj4));
14337 if (SWIG_arg_fail(5)) SWIG_fail;
14338 }
14339 }
14340 {
14341 PyThreadState* __tstate = wxPyBeginAllowThreads();
14342 (arg1)->DrawLabel((wxString const &)*arg2,(wxRect const &)*arg3,arg4,arg5);
14343
14344 wxPyEndAllowThreads(__tstate);
14345 if (PyErr_Occurred()) SWIG_fail;
14346 }
14347 Py_INCREF(Py_None); resultobj = Py_None;
14348 {
14349 if (temp2)
14350 delete arg2;
14351 }
14352 return resultobj;
14353 fail:
14354 {
14355 if (temp2)
14356 delete arg2;
14357 }
14358 return NULL;
14359 }
14360
14361
14362 static PyObject *_wrap_DC_DrawImageLabel(PyObject *, PyObject *args, PyObject *kwargs) {
14363 PyObject *resultobj;
14364 wxDC *arg1 = (wxDC *) 0 ;
14365 wxString *arg2 = 0 ;
14366 wxBitmap *arg3 = 0 ;
14367 wxRect *arg4 = 0 ;
14368 int arg5 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
14369 int arg6 = (int) -1 ;
14370 wxRect result;
14371 bool temp2 = false ;
14372 wxRect temp4 ;
14373 PyObject * obj0 = 0 ;
14374 PyObject * obj1 = 0 ;
14375 PyObject * obj2 = 0 ;
14376 PyObject * obj3 = 0 ;
14377 PyObject * obj4 = 0 ;
14378 PyObject * obj5 = 0 ;
14379 char *kwnames[] = {
14380 (char *) "self",(char *) "text",(char *) "image",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
14381 };
14382
14383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:DC_DrawImageLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
14384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14385 if (SWIG_arg_fail(1)) SWIG_fail;
14386 {
14387 arg2 = wxString_in_helper(obj1);
14388 if (arg2 == NULL) SWIG_fail;
14389 temp2 = true;
14390 }
14391 {
14392 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
14393 if (SWIG_arg_fail(3)) SWIG_fail;
14394 if (arg3 == NULL) {
14395 SWIG_null_ref("wxBitmap");
14396 }
14397 if (SWIG_arg_fail(3)) SWIG_fail;
14398 }
14399 {
14400 arg4 = &temp4;
14401 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
14402 }
14403 if (obj4) {
14404 {
14405 arg5 = (int)(SWIG_As_int(obj4));
14406 if (SWIG_arg_fail(5)) SWIG_fail;
14407 }
14408 }
14409 if (obj5) {
14410 {
14411 arg6 = (int)(SWIG_As_int(obj5));
14412 if (SWIG_arg_fail(6)) SWIG_fail;
14413 }
14414 }
14415 {
14416 PyThreadState* __tstate = wxPyBeginAllowThreads();
14417 result = wxDC_DrawImageLabel(arg1,(wxString const &)*arg2,(wxBitmap const &)*arg3,(wxRect const &)*arg4,arg5,arg6);
14418
14419 wxPyEndAllowThreads(__tstate);
14420 if (PyErr_Occurred()) SWIG_fail;
14421 }
14422 {
14423 wxRect * resultptr;
14424 resultptr = new wxRect((wxRect &)(result));
14425 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
14426 }
14427 {
14428 if (temp2)
14429 delete arg2;
14430 }
14431 return resultobj;
14432 fail:
14433 {
14434 if (temp2)
14435 delete arg2;
14436 }
14437 return NULL;
14438 }
14439
14440
14441 static PyObject *_wrap_DC_DrawSpline(PyObject *, PyObject *args, PyObject *kwargs) {
14442 PyObject *resultobj;
14443 wxDC *arg1 = (wxDC *) 0 ;
14444 int arg2 ;
14445 wxPoint *arg3 = (wxPoint *) 0 ;
14446 PyObject * obj0 = 0 ;
14447 PyObject * obj1 = 0 ;
14448 char *kwnames[] = {
14449 (char *) "self",(char *) "points", NULL
14450 };
14451
14452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawSpline",kwnames,&obj0,&obj1)) goto fail;
14453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14454 if (SWIG_arg_fail(1)) SWIG_fail;
14455 {
14456 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14457 if (arg3 == NULL) SWIG_fail;
14458 }
14459 {
14460 PyThreadState* __tstate = wxPyBeginAllowThreads();
14461 (arg1)->DrawSpline(arg2,arg3);
14462
14463 wxPyEndAllowThreads(__tstate);
14464 if (PyErr_Occurred()) SWIG_fail;
14465 }
14466 Py_INCREF(Py_None); resultobj = Py_None;
14467 {
14468 if (arg3) delete [] arg3;
14469 }
14470 return resultobj;
14471 fail:
14472 {
14473 if (arg3) delete [] arg3;
14474 }
14475 return NULL;
14476 }
14477
14478
14479 static PyObject *_wrap_DC_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
14480 PyObject *resultobj;
14481 wxDC *arg1 = (wxDC *) 0 ;
14482 PyObject * obj0 = 0 ;
14483 char *kwnames[] = {
14484 (char *) "self", NULL
14485 };
14486
14487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Clear",kwnames,&obj0)) goto fail;
14488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14489 if (SWIG_arg_fail(1)) SWIG_fail;
14490 {
14491 PyThreadState* __tstate = wxPyBeginAllowThreads();
14492 (arg1)->Clear();
14493
14494 wxPyEndAllowThreads(__tstate);
14495 if (PyErr_Occurred()) SWIG_fail;
14496 }
14497 Py_INCREF(Py_None); resultobj = Py_None;
14498 return resultobj;
14499 fail:
14500 return NULL;
14501 }
14502
14503
14504 static PyObject *_wrap_DC_StartDoc(PyObject *, PyObject *args, PyObject *kwargs) {
14505 PyObject *resultobj;
14506 wxDC *arg1 = (wxDC *) 0 ;
14507 wxString *arg2 = 0 ;
14508 bool result;
14509 bool temp2 = false ;
14510 PyObject * obj0 = 0 ;
14511 PyObject * obj1 = 0 ;
14512 char *kwnames[] = {
14513 (char *) "self",(char *) "message", NULL
14514 };
14515
14516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_StartDoc",kwnames,&obj0,&obj1)) goto fail;
14517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14518 if (SWIG_arg_fail(1)) SWIG_fail;
14519 {
14520 arg2 = wxString_in_helper(obj1);
14521 if (arg2 == NULL) SWIG_fail;
14522 temp2 = true;
14523 }
14524 {
14525 PyThreadState* __tstate = wxPyBeginAllowThreads();
14526 result = (bool)(arg1)->StartDoc((wxString const &)*arg2);
14527
14528 wxPyEndAllowThreads(__tstate);
14529 if (PyErr_Occurred()) SWIG_fail;
14530 }
14531 {
14532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14533 }
14534 {
14535 if (temp2)
14536 delete arg2;
14537 }
14538 return resultobj;
14539 fail:
14540 {
14541 if (temp2)
14542 delete arg2;
14543 }
14544 return NULL;
14545 }
14546
14547
14548 static PyObject *_wrap_DC_EndDoc(PyObject *, PyObject *args, PyObject *kwargs) {
14549 PyObject *resultobj;
14550 wxDC *arg1 = (wxDC *) 0 ;
14551 PyObject * obj0 = 0 ;
14552 char *kwnames[] = {
14553 (char *) "self", NULL
14554 };
14555
14556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDoc",kwnames,&obj0)) goto fail;
14557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14558 if (SWIG_arg_fail(1)) SWIG_fail;
14559 {
14560 PyThreadState* __tstate = wxPyBeginAllowThreads();
14561 (arg1)->EndDoc();
14562
14563 wxPyEndAllowThreads(__tstate);
14564 if (PyErr_Occurred()) SWIG_fail;
14565 }
14566 Py_INCREF(Py_None); resultobj = Py_None;
14567 return resultobj;
14568 fail:
14569 return NULL;
14570 }
14571
14572
14573 static PyObject *_wrap_DC_StartPage(PyObject *, PyObject *args, PyObject *kwargs) {
14574 PyObject *resultobj;
14575 wxDC *arg1 = (wxDC *) 0 ;
14576 PyObject * obj0 = 0 ;
14577 char *kwnames[] = {
14578 (char *) "self", NULL
14579 };
14580
14581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_StartPage",kwnames,&obj0)) goto fail;
14582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14583 if (SWIG_arg_fail(1)) SWIG_fail;
14584 {
14585 PyThreadState* __tstate = wxPyBeginAllowThreads();
14586 (arg1)->StartPage();
14587
14588 wxPyEndAllowThreads(__tstate);
14589 if (PyErr_Occurred()) SWIG_fail;
14590 }
14591 Py_INCREF(Py_None); resultobj = Py_None;
14592 return resultobj;
14593 fail:
14594 return NULL;
14595 }
14596
14597
14598 static PyObject *_wrap_DC_EndPage(PyObject *, PyObject *args, PyObject *kwargs) {
14599 PyObject *resultobj;
14600 wxDC *arg1 = (wxDC *) 0 ;
14601 PyObject * obj0 = 0 ;
14602 char *kwnames[] = {
14603 (char *) "self", NULL
14604 };
14605
14606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndPage",kwnames,&obj0)) goto fail;
14607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14608 if (SWIG_arg_fail(1)) SWIG_fail;
14609 {
14610 PyThreadState* __tstate = wxPyBeginAllowThreads();
14611 (arg1)->EndPage();
14612
14613 wxPyEndAllowThreads(__tstate);
14614 if (PyErr_Occurred()) SWIG_fail;
14615 }
14616 Py_INCREF(Py_None); resultobj = Py_None;
14617 return resultobj;
14618 fail:
14619 return NULL;
14620 }
14621
14622
14623 static PyObject *_wrap_DC_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
14624 PyObject *resultobj;
14625 wxDC *arg1 = (wxDC *) 0 ;
14626 wxFont *arg2 = 0 ;
14627 PyObject * obj0 = 0 ;
14628 PyObject * obj1 = 0 ;
14629 char *kwnames[] = {
14630 (char *) "self",(char *) "font", NULL
14631 };
14632
14633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetFont",kwnames,&obj0,&obj1)) goto fail;
14634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14635 if (SWIG_arg_fail(1)) SWIG_fail;
14636 {
14637 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
14638 if (SWIG_arg_fail(2)) SWIG_fail;
14639 if (arg2 == NULL) {
14640 SWIG_null_ref("wxFont");
14641 }
14642 if (SWIG_arg_fail(2)) SWIG_fail;
14643 }
14644 {
14645 PyThreadState* __tstate = wxPyBeginAllowThreads();
14646 (arg1)->SetFont((wxFont const &)*arg2);
14647
14648 wxPyEndAllowThreads(__tstate);
14649 if (PyErr_Occurred()) SWIG_fail;
14650 }
14651 Py_INCREF(Py_None); resultobj = Py_None;
14652 return resultobj;
14653 fail:
14654 return NULL;
14655 }
14656
14657
14658 static PyObject *_wrap_DC_SetPen(PyObject *, PyObject *args, PyObject *kwargs) {
14659 PyObject *resultobj;
14660 wxDC *arg1 = (wxDC *) 0 ;
14661 wxPen *arg2 = 0 ;
14662 PyObject * obj0 = 0 ;
14663 PyObject * obj1 = 0 ;
14664 char *kwnames[] = {
14665 (char *) "self",(char *) "pen", NULL
14666 };
14667
14668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPen",kwnames,&obj0,&obj1)) goto fail;
14669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14670 if (SWIG_arg_fail(1)) SWIG_fail;
14671 {
14672 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
14673 if (SWIG_arg_fail(2)) SWIG_fail;
14674 if (arg2 == NULL) {
14675 SWIG_null_ref("wxPen");
14676 }
14677 if (SWIG_arg_fail(2)) SWIG_fail;
14678 }
14679 {
14680 PyThreadState* __tstate = wxPyBeginAllowThreads();
14681 (arg1)->SetPen((wxPen const &)*arg2);
14682
14683 wxPyEndAllowThreads(__tstate);
14684 if (PyErr_Occurred()) SWIG_fail;
14685 }
14686 Py_INCREF(Py_None); resultobj = Py_None;
14687 return resultobj;
14688 fail:
14689 return NULL;
14690 }
14691
14692
14693 static PyObject *_wrap_DC_SetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
14694 PyObject *resultobj;
14695 wxDC *arg1 = (wxDC *) 0 ;
14696 wxBrush *arg2 = 0 ;
14697 PyObject * obj0 = 0 ;
14698 PyObject * obj1 = 0 ;
14699 char *kwnames[] = {
14700 (char *) "self",(char *) "brush", NULL
14701 };
14702
14703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBrush",kwnames,&obj0,&obj1)) goto fail;
14704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14705 if (SWIG_arg_fail(1)) SWIG_fail;
14706 {
14707 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
14708 if (SWIG_arg_fail(2)) SWIG_fail;
14709 if (arg2 == NULL) {
14710 SWIG_null_ref("wxBrush");
14711 }
14712 if (SWIG_arg_fail(2)) SWIG_fail;
14713 }
14714 {
14715 PyThreadState* __tstate = wxPyBeginAllowThreads();
14716 (arg1)->SetBrush((wxBrush const &)*arg2);
14717
14718 wxPyEndAllowThreads(__tstate);
14719 if (PyErr_Occurred()) SWIG_fail;
14720 }
14721 Py_INCREF(Py_None); resultobj = Py_None;
14722 return resultobj;
14723 fail:
14724 return NULL;
14725 }
14726
14727
14728 static PyObject *_wrap_DC_SetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
14729 PyObject *resultobj;
14730 wxDC *arg1 = (wxDC *) 0 ;
14731 wxBrush *arg2 = 0 ;
14732 PyObject * obj0 = 0 ;
14733 PyObject * obj1 = 0 ;
14734 char *kwnames[] = {
14735 (char *) "self",(char *) "brush", NULL
14736 };
14737
14738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackground",kwnames,&obj0,&obj1)) goto fail;
14739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14740 if (SWIG_arg_fail(1)) SWIG_fail;
14741 {
14742 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
14743 if (SWIG_arg_fail(2)) SWIG_fail;
14744 if (arg2 == NULL) {
14745 SWIG_null_ref("wxBrush");
14746 }
14747 if (SWIG_arg_fail(2)) SWIG_fail;
14748 }
14749 {
14750 PyThreadState* __tstate = wxPyBeginAllowThreads();
14751 (arg1)->SetBackground((wxBrush const &)*arg2);
14752
14753 wxPyEndAllowThreads(__tstate);
14754 if (PyErr_Occurred()) SWIG_fail;
14755 }
14756 Py_INCREF(Py_None); resultobj = Py_None;
14757 return resultobj;
14758 fail:
14759 return NULL;
14760 }
14761
14762
14763 static PyObject *_wrap_DC_SetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
14764 PyObject *resultobj;
14765 wxDC *arg1 = (wxDC *) 0 ;
14766 int arg2 ;
14767 PyObject * obj0 = 0 ;
14768 PyObject * obj1 = 0 ;
14769 char *kwnames[] = {
14770 (char *) "self",(char *) "mode", NULL
14771 };
14772
14773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackgroundMode",kwnames,&obj0,&obj1)) goto fail;
14774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14775 if (SWIG_arg_fail(1)) SWIG_fail;
14776 {
14777 arg2 = (int)(SWIG_As_int(obj1));
14778 if (SWIG_arg_fail(2)) SWIG_fail;
14779 }
14780 {
14781 PyThreadState* __tstate = wxPyBeginAllowThreads();
14782 (arg1)->SetBackgroundMode(arg2);
14783
14784 wxPyEndAllowThreads(__tstate);
14785 if (PyErr_Occurred()) SWIG_fail;
14786 }
14787 Py_INCREF(Py_None); resultobj = Py_None;
14788 return resultobj;
14789 fail:
14790 return NULL;
14791 }
14792
14793
14794 static PyObject *_wrap_DC_SetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
14795 PyObject *resultobj;
14796 wxDC *arg1 = (wxDC *) 0 ;
14797 wxPalette *arg2 = 0 ;
14798 PyObject * obj0 = 0 ;
14799 PyObject * obj1 = 0 ;
14800 char *kwnames[] = {
14801 (char *) "self",(char *) "palette", NULL
14802 };
14803
14804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPalette",kwnames,&obj0,&obj1)) goto fail;
14805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14806 if (SWIG_arg_fail(1)) SWIG_fail;
14807 {
14808 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
14809 if (SWIG_arg_fail(2)) SWIG_fail;
14810 if (arg2 == NULL) {
14811 SWIG_null_ref("wxPalette");
14812 }
14813 if (SWIG_arg_fail(2)) SWIG_fail;
14814 }
14815 {
14816 PyThreadState* __tstate = wxPyBeginAllowThreads();
14817 (arg1)->SetPalette((wxPalette const &)*arg2);
14818
14819 wxPyEndAllowThreads(__tstate);
14820 if (PyErr_Occurred()) SWIG_fail;
14821 }
14822 Py_INCREF(Py_None); resultobj = Py_None;
14823 return resultobj;
14824 fail:
14825 return NULL;
14826 }
14827
14828
14829 static PyObject *_wrap_DC_DestroyClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14830 PyObject *resultobj;
14831 wxDC *arg1 = (wxDC *) 0 ;
14832 PyObject * obj0 = 0 ;
14833 char *kwnames[] = {
14834 (char *) "self", NULL
14835 };
14836
14837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_DestroyClippingRegion",kwnames,&obj0)) goto fail;
14838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14839 if (SWIG_arg_fail(1)) SWIG_fail;
14840 {
14841 PyThreadState* __tstate = wxPyBeginAllowThreads();
14842 (arg1)->DestroyClippingRegion();
14843
14844 wxPyEndAllowThreads(__tstate);
14845 if (PyErr_Occurred()) SWIG_fail;
14846 }
14847 Py_INCREF(Py_None); resultobj = Py_None;
14848 return resultobj;
14849 fail:
14850 return NULL;
14851 }
14852
14853
14854 static PyObject *_wrap_DC_GetClippingBox(PyObject *, PyObject *args, PyObject *kwargs) {
14855 PyObject *resultobj;
14856 wxDC *arg1 = (wxDC *) 0 ;
14857 int *arg2 = (int *) 0 ;
14858 int *arg3 = (int *) 0 ;
14859 int *arg4 = (int *) 0 ;
14860 int *arg5 = (int *) 0 ;
14861 int temp2 ;
14862 int res2 = 0 ;
14863 int temp3 ;
14864 int res3 = 0 ;
14865 int temp4 ;
14866 int res4 = 0 ;
14867 int temp5 ;
14868 int res5 = 0 ;
14869 PyObject * obj0 = 0 ;
14870 char *kwnames[] = {
14871 (char *) "self", NULL
14872 };
14873
14874 arg2 = &temp2; res2 = SWIG_NEWOBJ;
14875 arg3 = &temp3; res3 = SWIG_NEWOBJ;
14876 arg4 = &temp4; res4 = SWIG_NEWOBJ;
14877 arg5 = &temp5; res5 = SWIG_NEWOBJ;
14878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingBox",kwnames,&obj0)) goto fail;
14879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14880 if (SWIG_arg_fail(1)) SWIG_fail;
14881 {
14882 PyThreadState* __tstate = wxPyBeginAllowThreads();
14883 ((wxDC const *)arg1)->GetClippingBox(arg2,arg3,arg4,arg5);
14884
14885 wxPyEndAllowThreads(__tstate);
14886 if (PyErr_Occurred()) SWIG_fail;
14887 }
14888 Py_INCREF(Py_None); resultobj = Py_None;
14889 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
14890 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
14891 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
14892 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
14893 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
14894 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
14895 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
14896 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
14897 return resultobj;
14898 fail:
14899 return NULL;
14900 }
14901
14902
14903 static PyObject *_wrap_DC_GetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
14904 PyObject *resultobj;
14905 wxDC *arg1 = (wxDC *) 0 ;
14906 wxRect result;
14907 PyObject * obj0 = 0 ;
14908 char *kwnames[] = {
14909 (char *) "self", NULL
14910 };
14911
14912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingRect",kwnames,&obj0)) goto fail;
14913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14914 if (SWIG_arg_fail(1)) SWIG_fail;
14915 {
14916 PyThreadState* __tstate = wxPyBeginAllowThreads();
14917 result = wxDC_GetClippingRect(arg1);
14918
14919 wxPyEndAllowThreads(__tstate);
14920 if (PyErr_Occurred()) SWIG_fail;
14921 }
14922 {
14923 wxRect * resultptr;
14924 resultptr = new wxRect((wxRect &)(result));
14925 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
14926 }
14927 return resultobj;
14928 fail:
14929 return NULL;
14930 }
14931
14932
14933 static PyObject *_wrap_DC_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
14934 PyObject *resultobj;
14935 wxDC *arg1 = (wxDC *) 0 ;
14936 int result;
14937 PyObject * obj0 = 0 ;
14938 char *kwnames[] = {
14939 (char *) "self", NULL
14940 };
14941
14942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharHeight",kwnames,&obj0)) goto fail;
14943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14944 if (SWIG_arg_fail(1)) SWIG_fail;
14945 {
14946 PyThreadState* __tstate = wxPyBeginAllowThreads();
14947 result = (int)((wxDC const *)arg1)->GetCharHeight();
14948
14949 wxPyEndAllowThreads(__tstate);
14950 if (PyErr_Occurred()) SWIG_fail;
14951 }
14952 {
14953 resultobj = SWIG_From_int((int)(result));
14954 }
14955 return resultobj;
14956 fail:
14957 return NULL;
14958 }
14959
14960
14961 static PyObject *_wrap_DC_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
14962 PyObject *resultobj;
14963 wxDC *arg1 = (wxDC *) 0 ;
14964 int result;
14965 PyObject * obj0 = 0 ;
14966 char *kwnames[] = {
14967 (char *) "self", NULL
14968 };
14969
14970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharWidth",kwnames,&obj0)) goto fail;
14971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14972 if (SWIG_arg_fail(1)) SWIG_fail;
14973 {
14974 PyThreadState* __tstate = wxPyBeginAllowThreads();
14975 result = (int)((wxDC const *)arg1)->GetCharWidth();
14976
14977 wxPyEndAllowThreads(__tstate);
14978 if (PyErr_Occurred()) SWIG_fail;
14979 }
14980 {
14981 resultobj = SWIG_From_int((int)(result));
14982 }
14983 return resultobj;
14984 fail:
14985 return NULL;
14986 }
14987
14988
14989 static PyObject *_wrap_DC_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
14990 PyObject *resultobj;
14991 wxDC *arg1 = (wxDC *) 0 ;
14992 wxString *arg2 = 0 ;
14993 int *arg3 = (int *) 0 ;
14994 int *arg4 = (int *) 0 ;
14995 bool temp2 = false ;
14996 int temp3 ;
14997 int res3 = 0 ;
14998 int temp4 ;
14999 int res4 = 0 ;
15000 PyObject * obj0 = 0 ;
15001 PyObject * obj1 = 0 ;
15002 char *kwnames[] = {
15003 (char *) "self",(char *) "string", NULL
15004 };
15005
15006 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15007 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
15009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15010 if (SWIG_arg_fail(1)) SWIG_fail;
15011 {
15012 arg2 = wxString_in_helper(obj1);
15013 if (arg2 == NULL) SWIG_fail;
15014 temp2 = true;
15015 }
15016 {
15017 PyThreadState* __tstate = wxPyBeginAllowThreads();
15018 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
15019
15020 wxPyEndAllowThreads(__tstate);
15021 if (PyErr_Occurred()) SWIG_fail;
15022 }
15023 Py_INCREF(Py_None); resultobj = Py_None;
15024 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15025 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15026 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15027 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15028 {
15029 if (temp2)
15030 delete arg2;
15031 }
15032 return resultobj;
15033 fail:
15034 {
15035 if (temp2)
15036 delete arg2;
15037 }
15038 return NULL;
15039 }
15040
15041
15042 static PyObject *_wrap_DC_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15043 PyObject *resultobj;
15044 wxDC *arg1 = (wxDC *) 0 ;
15045 wxString *arg2 = 0 ;
15046 int *arg3 = (int *) 0 ;
15047 int *arg4 = (int *) 0 ;
15048 int *arg5 = (int *) 0 ;
15049 int *arg6 = (int *) 0 ;
15050 wxFont *arg7 = (wxFont *) NULL ;
15051 bool temp2 = false ;
15052 int temp3 ;
15053 int res3 = 0 ;
15054 int temp4 ;
15055 int res4 = 0 ;
15056 int temp5 ;
15057 int res5 = 0 ;
15058 int temp6 ;
15059 int res6 = 0 ;
15060 PyObject * obj0 = 0 ;
15061 PyObject * obj1 = 0 ;
15062 PyObject * obj2 = 0 ;
15063 char *kwnames[] = {
15064 (char *) "self",(char *) "string",(char *) "font", NULL
15065 };
15066
15067 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15068 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15069 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15070 arg6 = &temp6; res6 = SWIG_NEWOBJ;
15071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15073 if (SWIG_arg_fail(1)) SWIG_fail;
15074 {
15075 arg2 = wxString_in_helper(obj1);
15076 if (arg2 == NULL) SWIG_fail;
15077 temp2 = true;
15078 }
15079 if (obj2) {
15080 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15081 if (SWIG_arg_fail(7)) SWIG_fail;
15082 }
15083 {
15084 PyThreadState* __tstate = wxPyBeginAllowThreads();
15085 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7);
15086
15087 wxPyEndAllowThreads(__tstate);
15088 if (PyErr_Occurred()) SWIG_fail;
15089 }
15090 Py_INCREF(Py_None); resultobj = Py_None;
15091 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15092 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15093 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15094 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15095 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15096 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15097 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
15098 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
15099 {
15100 if (temp2)
15101 delete arg2;
15102 }
15103 return resultobj;
15104 fail:
15105 {
15106 if (temp2)
15107 delete arg2;
15108 }
15109 return NULL;
15110 }
15111
15112
15113 static PyObject *_wrap_DC_GetMultiLineTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15114 PyObject *resultobj;
15115 wxDC *arg1 = (wxDC *) 0 ;
15116 wxString *arg2 = 0 ;
15117 int *arg3 = (int *) 0 ;
15118 int *arg4 = (int *) 0 ;
15119 int *arg5 = (int *) 0 ;
15120 wxFont *arg6 = (wxFont *) NULL ;
15121 bool temp2 = false ;
15122 int temp3 ;
15123 int res3 = 0 ;
15124 int temp4 ;
15125 int res4 = 0 ;
15126 int temp5 ;
15127 int res5 = 0 ;
15128 PyObject * obj0 = 0 ;
15129 PyObject * obj1 = 0 ;
15130 PyObject * obj2 = 0 ;
15131 char *kwnames[] = {
15132 (char *) "self",(char *) "text",(char *) "font", NULL
15133 };
15134
15135 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15136 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15137 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetMultiLineTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15140 if (SWIG_arg_fail(1)) SWIG_fail;
15141 {
15142 arg2 = wxString_in_helper(obj1);
15143 if (arg2 == NULL) SWIG_fail;
15144 temp2 = true;
15145 }
15146 if (obj2) {
15147 SWIG_Python_ConvertPtr(obj2, (void **)&arg6, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15148 if (SWIG_arg_fail(6)) SWIG_fail;
15149 }
15150 {
15151 PyThreadState* __tstate = wxPyBeginAllowThreads();
15152 (arg1)->GetMultiLineTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6);
15153
15154 wxPyEndAllowThreads(__tstate);
15155 if (PyErr_Occurred()) SWIG_fail;
15156 }
15157 Py_INCREF(Py_None); resultobj = Py_None;
15158 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15159 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15160 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15161 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15162 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15163 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15164 {
15165 if (temp2)
15166 delete arg2;
15167 }
15168 return resultobj;
15169 fail:
15170 {
15171 if (temp2)
15172 delete arg2;
15173 }
15174 return NULL;
15175 }
15176
15177
15178 static PyObject *_wrap_DC_GetPartialTextExtents(PyObject *, PyObject *args, PyObject *kwargs) {
15179 PyObject *resultobj;
15180 wxDC *arg1 = (wxDC *) 0 ;
15181 wxString *arg2 = 0 ;
15182 wxArrayInt result;
15183 bool temp2 = false ;
15184 PyObject * obj0 = 0 ;
15185 PyObject * obj1 = 0 ;
15186 char *kwnames[] = {
15187 (char *) "self",(char *) "text", NULL
15188 };
15189
15190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPartialTextExtents",kwnames,&obj0,&obj1)) goto fail;
15191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15192 if (SWIG_arg_fail(1)) SWIG_fail;
15193 {
15194 arg2 = wxString_in_helper(obj1);
15195 if (arg2 == NULL) SWIG_fail;
15196 temp2 = true;
15197 }
15198 {
15199 PyThreadState* __tstate = wxPyBeginAllowThreads();
15200 result = wxDC_GetPartialTextExtents(arg1,(wxString const &)*arg2);
15201
15202 wxPyEndAllowThreads(__tstate);
15203 if (PyErr_Occurred()) SWIG_fail;
15204 }
15205 {
15206 resultobj = PyList_New(0);
15207 size_t idx;
15208 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
15209 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
15210 PyList_Append(resultobj, val);
15211 Py_DECREF(val);
15212 }
15213 }
15214 {
15215 if (temp2)
15216 delete arg2;
15217 }
15218 return resultobj;
15219 fail:
15220 {
15221 if (temp2)
15222 delete arg2;
15223 }
15224 return NULL;
15225 }
15226
15227
15228 static PyObject *_wrap_DC_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
15229 PyObject *resultobj;
15230 wxDC *arg1 = (wxDC *) 0 ;
15231 wxSize result;
15232 PyObject * obj0 = 0 ;
15233 char *kwnames[] = {
15234 (char *) "self", NULL
15235 };
15236
15237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSize",kwnames,&obj0)) goto fail;
15238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15239 if (SWIG_arg_fail(1)) SWIG_fail;
15240 {
15241 PyThreadState* __tstate = wxPyBeginAllowThreads();
15242 result = (arg1)->GetSize();
15243
15244 wxPyEndAllowThreads(__tstate);
15245 if (PyErr_Occurred()) SWIG_fail;
15246 }
15247 {
15248 wxSize * resultptr;
15249 resultptr = new wxSize((wxSize &)(result));
15250 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15251 }
15252 return resultobj;
15253 fail:
15254 return NULL;
15255 }
15256
15257
15258 static PyObject *_wrap_DC_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
15259 PyObject *resultobj;
15260 wxDC *arg1 = (wxDC *) 0 ;
15261 int *arg2 = (int *) 0 ;
15262 int *arg3 = (int *) 0 ;
15263 int temp2 ;
15264 int res2 = 0 ;
15265 int temp3 ;
15266 int res3 = 0 ;
15267 PyObject * obj0 = 0 ;
15268 char *kwnames[] = {
15269 (char *) "self", NULL
15270 };
15271
15272 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15273 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeTuple",kwnames,&obj0)) goto fail;
15275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15276 if (SWIG_arg_fail(1)) SWIG_fail;
15277 {
15278 PyThreadState* __tstate = wxPyBeginAllowThreads();
15279 (arg1)->GetSize(arg2,arg3);
15280
15281 wxPyEndAllowThreads(__tstate);
15282 if (PyErr_Occurred()) SWIG_fail;
15283 }
15284 Py_INCREF(Py_None); resultobj = Py_None;
15285 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15286 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15287 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15288 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15289 return resultobj;
15290 fail:
15291 return NULL;
15292 }
15293
15294
15295 static PyObject *_wrap_DC_GetSizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
15296 PyObject *resultobj;
15297 wxDC *arg1 = (wxDC *) 0 ;
15298 wxSize result;
15299 PyObject * obj0 = 0 ;
15300 char *kwnames[] = {
15301 (char *) "self", NULL
15302 };
15303
15304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMM",kwnames,&obj0)) goto fail;
15305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15306 if (SWIG_arg_fail(1)) SWIG_fail;
15307 {
15308 PyThreadState* __tstate = wxPyBeginAllowThreads();
15309 result = ((wxDC const *)arg1)->GetSizeMM();
15310
15311 wxPyEndAllowThreads(__tstate);
15312 if (PyErr_Occurred()) SWIG_fail;
15313 }
15314 {
15315 wxSize * resultptr;
15316 resultptr = new wxSize((wxSize &)(result));
15317 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15318 }
15319 return resultobj;
15320 fail:
15321 return NULL;
15322 }
15323
15324
15325 static PyObject *_wrap_DC_GetSizeMMTuple(PyObject *, PyObject *args, PyObject *kwargs) {
15326 PyObject *resultobj;
15327 wxDC *arg1 = (wxDC *) 0 ;
15328 int *arg2 = (int *) 0 ;
15329 int *arg3 = (int *) 0 ;
15330 int temp2 ;
15331 int res2 = 0 ;
15332 int temp3 ;
15333 int res3 = 0 ;
15334 PyObject * obj0 = 0 ;
15335 char *kwnames[] = {
15336 (char *) "self", NULL
15337 };
15338
15339 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15340 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMMTuple",kwnames,&obj0)) goto fail;
15342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15343 if (SWIG_arg_fail(1)) SWIG_fail;
15344 {
15345 PyThreadState* __tstate = wxPyBeginAllowThreads();
15346 ((wxDC const *)arg1)->GetSizeMM(arg2,arg3);
15347
15348 wxPyEndAllowThreads(__tstate);
15349 if (PyErr_Occurred()) SWIG_fail;
15350 }
15351 Py_INCREF(Py_None); resultobj = Py_None;
15352 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15353 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15354 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15355 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15356 return resultobj;
15357 fail:
15358 return NULL;
15359 }
15360
15361
15362 static PyObject *_wrap_DC_DeviceToLogicalX(PyObject *, PyObject *args, PyObject *kwargs) {
15363 PyObject *resultobj;
15364 wxDC *arg1 = (wxDC *) 0 ;
15365 int arg2 ;
15366 int result;
15367 PyObject * obj0 = 0 ;
15368 PyObject * obj1 = 0 ;
15369 char *kwnames[] = {
15370 (char *) "self",(char *) "x", NULL
15371 };
15372
15373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalX",kwnames,&obj0,&obj1)) goto fail;
15374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15375 if (SWIG_arg_fail(1)) SWIG_fail;
15376 {
15377 arg2 = (int)(SWIG_As_int(obj1));
15378 if (SWIG_arg_fail(2)) SWIG_fail;
15379 }
15380 {
15381 PyThreadState* __tstate = wxPyBeginAllowThreads();
15382 result = (int)((wxDC const *)arg1)->DeviceToLogicalX(arg2);
15383
15384 wxPyEndAllowThreads(__tstate);
15385 if (PyErr_Occurred()) SWIG_fail;
15386 }
15387 {
15388 resultobj = SWIG_From_int((int)(result));
15389 }
15390 return resultobj;
15391 fail:
15392 return NULL;
15393 }
15394
15395
15396 static PyObject *_wrap_DC_DeviceToLogicalY(PyObject *, PyObject *args, PyObject *kwargs) {
15397 PyObject *resultobj;
15398 wxDC *arg1 = (wxDC *) 0 ;
15399 int arg2 ;
15400 int result;
15401 PyObject * obj0 = 0 ;
15402 PyObject * obj1 = 0 ;
15403 char *kwnames[] = {
15404 (char *) "self",(char *) "y", NULL
15405 };
15406
15407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalY",kwnames,&obj0,&obj1)) goto fail;
15408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15409 if (SWIG_arg_fail(1)) SWIG_fail;
15410 {
15411 arg2 = (int)(SWIG_As_int(obj1));
15412 if (SWIG_arg_fail(2)) SWIG_fail;
15413 }
15414 {
15415 PyThreadState* __tstate = wxPyBeginAllowThreads();
15416 result = (int)((wxDC const *)arg1)->DeviceToLogicalY(arg2);
15417
15418 wxPyEndAllowThreads(__tstate);
15419 if (PyErr_Occurred()) SWIG_fail;
15420 }
15421 {
15422 resultobj = SWIG_From_int((int)(result));
15423 }
15424 return resultobj;
15425 fail:
15426 return NULL;
15427 }
15428
15429
15430 static PyObject *_wrap_DC_DeviceToLogicalXRel(PyObject *, PyObject *args, PyObject *kwargs) {
15431 PyObject *resultobj;
15432 wxDC *arg1 = (wxDC *) 0 ;
15433 int arg2 ;
15434 int result;
15435 PyObject * obj0 = 0 ;
15436 PyObject * obj1 = 0 ;
15437 char *kwnames[] = {
15438 (char *) "self",(char *) "x", NULL
15439 };
15440
15441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalXRel",kwnames,&obj0,&obj1)) goto fail;
15442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15443 if (SWIG_arg_fail(1)) SWIG_fail;
15444 {
15445 arg2 = (int)(SWIG_As_int(obj1));
15446 if (SWIG_arg_fail(2)) SWIG_fail;
15447 }
15448 {
15449 PyThreadState* __tstate = wxPyBeginAllowThreads();
15450 result = (int)((wxDC const *)arg1)->DeviceToLogicalXRel(arg2);
15451
15452 wxPyEndAllowThreads(__tstate);
15453 if (PyErr_Occurred()) SWIG_fail;
15454 }
15455 {
15456 resultobj = SWIG_From_int((int)(result));
15457 }
15458 return resultobj;
15459 fail:
15460 return NULL;
15461 }
15462
15463
15464 static PyObject *_wrap_DC_DeviceToLogicalYRel(PyObject *, PyObject *args, PyObject *kwargs) {
15465 PyObject *resultobj;
15466 wxDC *arg1 = (wxDC *) 0 ;
15467 int arg2 ;
15468 int result;
15469 PyObject * obj0 = 0 ;
15470 PyObject * obj1 = 0 ;
15471 char *kwnames[] = {
15472 (char *) "self",(char *) "y", NULL
15473 };
15474
15475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalYRel",kwnames,&obj0,&obj1)) goto fail;
15476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15477 if (SWIG_arg_fail(1)) SWIG_fail;
15478 {
15479 arg2 = (int)(SWIG_As_int(obj1));
15480 if (SWIG_arg_fail(2)) SWIG_fail;
15481 }
15482 {
15483 PyThreadState* __tstate = wxPyBeginAllowThreads();
15484 result = (int)((wxDC const *)arg1)->DeviceToLogicalYRel(arg2);
15485
15486 wxPyEndAllowThreads(__tstate);
15487 if (PyErr_Occurred()) SWIG_fail;
15488 }
15489 {
15490 resultobj = SWIG_From_int((int)(result));
15491 }
15492 return resultobj;
15493 fail:
15494 return NULL;
15495 }
15496
15497
15498 static PyObject *_wrap_DC_LogicalToDeviceX(PyObject *, PyObject *args, PyObject *kwargs) {
15499 PyObject *resultobj;
15500 wxDC *arg1 = (wxDC *) 0 ;
15501 int arg2 ;
15502 int result;
15503 PyObject * obj0 = 0 ;
15504 PyObject * obj1 = 0 ;
15505 char *kwnames[] = {
15506 (char *) "self",(char *) "x", NULL
15507 };
15508
15509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceX",kwnames,&obj0,&obj1)) goto fail;
15510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15511 if (SWIG_arg_fail(1)) SWIG_fail;
15512 {
15513 arg2 = (int)(SWIG_As_int(obj1));
15514 if (SWIG_arg_fail(2)) SWIG_fail;
15515 }
15516 {
15517 PyThreadState* __tstate = wxPyBeginAllowThreads();
15518 result = (int)((wxDC const *)arg1)->LogicalToDeviceX(arg2);
15519
15520 wxPyEndAllowThreads(__tstate);
15521 if (PyErr_Occurred()) SWIG_fail;
15522 }
15523 {
15524 resultobj = SWIG_From_int((int)(result));
15525 }
15526 return resultobj;
15527 fail:
15528 return NULL;
15529 }
15530
15531
15532 static PyObject *_wrap_DC_LogicalToDeviceY(PyObject *, PyObject *args, PyObject *kwargs) {
15533 PyObject *resultobj;
15534 wxDC *arg1 = (wxDC *) 0 ;
15535 int arg2 ;
15536 int result;
15537 PyObject * obj0 = 0 ;
15538 PyObject * obj1 = 0 ;
15539 char *kwnames[] = {
15540 (char *) "self",(char *) "y", NULL
15541 };
15542
15543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceY",kwnames,&obj0,&obj1)) goto fail;
15544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15545 if (SWIG_arg_fail(1)) SWIG_fail;
15546 {
15547 arg2 = (int)(SWIG_As_int(obj1));
15548 if (SWIG_arg_fail(2)) SWIG_fail;
15549 }
15550 {
15551 PyThreadState* __tstate = wxPyBeginAllowThreads();
15552 result = (int)((wxDC const *)arg1)->LogicalToDeviceY(arg2);
15553
15554 wxPyEndAllowThreads(__tstate);
15555 if (PyErr_Occurred()) SWIG_fail;
15556 }
15557 {
15558 resultobj = SWIG_From_int((int)(result));
15559 }
15560 return resultobj;
15561 fail:
15562 return NULL;
15563 }
15564
15565
15566 static PyObject *_wrap_DC_LogicalToDeviceXRel(PyObject *, PyObject *args, PyObject *kwargs) {
15567 PyObject *resultobj;
15568 wxDC *arg1 = (wxDC *) 0 ;
15569 int arg2 ;
15570 int result;
15571 PyObject * obj0 = 0 ;
15572 PyObject * obj1 = 0 ;
15573 char *kwnames[] = {
15574 (char *) "self",(char *) "x", NULL
15575 };
15576
15577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceXRel",kwnames,&obj0,&obj1)) goto fail;
15578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15579 if (SWIG_arg_fail(1)) SWIG_fail;
15580 {
15581 arg2 = (int)(SWIG_As_int(obj1));
15582 if (SWIG_arg_fail(2)) SWIG_fail;
15583 }
15584 {
15585 PyThreadState* __tstate = wxPyBeginAllowThreads();
15586 result = (int)((wxDC const *)arg1)->LogicalToDeviceXRel(arg2);
15587
15588 wxPyEndAllowThreads(__tstate);
15589 if (PyErr_Occurred()) SWIG_fail;
15590 }
15591 {
15592 resultobj = SWIG_From_int((int)(result));
15593 }
15594 return resultobj;
15595 fail:
15596 return NULL;
15597 }
15598
15599
15600 static PyObject *_wrap_DC_LogicalToDeviceYRel(PyObject *, PyObject *args, PyObject *kwargs) {
15601 PyObject *resultobj;
15602 wxDC *arg1 = (wxDC *) 0 ;
15603 int arg2 ;
15604 int result;
15605 PyObject * obj0 = 0 ;
15606 PyObject * obj1 = 0 ;
15607 char *kwnames[] = {
15608 (char *) "self",(char *) "y", NULL
15609 };
15610
15611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceYRel",kwnames,&obj0,&obj1)) goto fail;
15612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15613 if (SWIG_arg_fail(1)) SWIG_fail;
15614 {
15615 arg2 = (int)(SWIG_As_int(obj1));
15616 if (SWIG_arg_fail(2)) SWIG_fail;
15617 }
15618 {
15619 PyThreadState* __tstate = wxPyBeginAllowThreads();
15620 result = (int)((wxDC const *)arg1)->LogicalToDeviceYRel(arg2);
15621
15622 wxPyEndAllowThreads(__tstate);
15623 if (PyErr_Occurred()) SWIG_fail;
15624 }
15625 {
15626 resultobj = SWIG_From_int((int)(result));
15627 }
15628 return resultobj;
15629 fail:
15630 return NULL;
15631 }
15632
15633
15634 static PyObject *_wrap_DC_CanDrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
15635 PyObject *resultobj;
15636 wxDC *arg1 = (wxDC *) 0 ;
15637 bool result;
15638 PyObject * obj0 = 0 ;
15639 char *kwnames[] = {
15640 (char *) "self", NULL
15641 };
15642
15643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanDrawBitmap",kwnames,&obj0)) goto fail;
15644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15645 if (SWIG_arg_fail(1)) SWIG_fail;
15646 {
15647 PyThreadState* __tstate = wxPyBeginAllowThreads();
15648 result = (bool)((wxDC const *)arg1)->CanDrawBitmap();
15649
15650 wxPyEndAllowThreads(__tstate);
15651 if (PyErr_Occurred()) SWIG_fail;
15652 }
15653 {
15654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15655 }
15656 return resultobj;
15657 fail:
15658 return NULL;
15659 }
15660
15661
15662 static PyObject *_wrap_DC_CanGetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15663 PyObject *resultobj;
15664 wxDC *arg1 = (wxDC *) 0 ;
15665 bool result;
15666 PyObject * obj0 = 0 ;
15667 char *kwnames[] = {
15668 (char *) "self", NULL
15669 };
15670
15671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanGetTextExtent",kwnames,&obj0)) goto fail;
15672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15673 if (SWIG_arg_fail(1)) SWIG_fail;
15674 {
15675 PyThreadState* __tstate = wxPyBeginAllowThreads();
15676 result = (bool)((wxDC const *)arg1)->CanGetTextExtent();
15677
15678 wxPyEndAllowThreads(__tstate);
15679 if (PyErr_Occurred()) SWIG_fail;
15680 }
15681 {
15682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15683 }
15684 return resultobj;
15685 fail:
15686 return NULL;
15687 }
15688
15689
15690 static PyObject *_wrap_DC_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
15691 PyObject *resultobj;
15692 wxDC *arg1 = (wxDC *) 0 ;
15693 int result;
15694 PyObject * obj0 = 0 ;
15695 char *kwnames[] = {
15696 (char *) "self", NULL
15697 };
15698
15699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDepth",kwnames,&obj0)) goto fail;
15700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15701 if (SWIG_arg_fail(1)) SWIG_fail;
15702 {
15703 PyThreadState* __tstate = wxPyBeginAllowThreads();
15704 result = (int)((wxDC const *)arg1)->GetDepth();
15705
15706 wxPyEndAllowThreads(__tstate);
15707 if (PyErr_Occurred()) SWIG_fail;
15708 }
15709 {
15710 resultobj = SWIG_From_int((int)(result));
15711 }
15712 return resultobj;
15713 fail:
15714 return NULL;
15715 }
15716
15717
15718 static PyObject *_wrap_DC_GetPPI(PyObject *, PyObject *args, PyObject *kwargs) {
15719 PyObject *resultobj;
15720 wxDC *arg1 = (wxDC *) 0 ;
15721 wxSize result;
15722 PyObject * obj0 = 0 ;
15723 char *kwnames[] = {
15724 (char *) "self", NULL
15725 };
15726
15727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPPI",kwnames,&obj0)) goto fail;
15728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15729 if (SWIG_arg_fail(1)) SWIG_fail;
15730 {
15731 PyThreadState* __tstate = wxPyBeginAllowThreads();
15732 result = ((wxDC const *)arg1)->GetPPI();
15733
15734 wxPyEndAllowThreads(__tstate);
15735 if (PyErr_Occurred()) SWIG_fail;
15736 }
15737 {
15738 wxSize * resultptr;
15739 resultptr = new wxSize((wxSize &)(result));
15740 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15741 }
15742 return resultobj;
15743 fail:
15744 return NULL;
15745 }
15746
15747
15748 static PyObject *_wrap_DC_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
15749 PyObject *resultobj;
15750 wxDC *arg1 = (wxDC *) 0 ;
15751 bool result;
15752 PyObject * obj0 = 0 ;
15753 char *kwnames[] = {
15754 (char *) "self", NULL
15755 };
15756
15757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Ok",kwnames,&obj0)) goto fail;
15758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15759 if (SWIG_arg_fail(1)) SWIG_fail;
15760 {
15761 PyThreadState* __tstate = wxPyBeginAllowThreads();
15762 result = (bool)((wxDC const *)arg1)->Ok();
15763
15764 wxPyEndAllowThreads(__tstate);
15765 if (PyErr_Occurred()) SWIG_fail;
15766 }
15767 {
15768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15769 }
15770 return resultobj;
15771 fail:
15772 return NULL;
15773 }
15774
15775
15776 static PyObject *_wrap_DC_GetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
15777 PyObject *resultobj;
15778 wxDC *arg1 = (wxDC *) 0 ;
15779 int result;
15780 PyObject * obj0 = 0 ;
15781 char *kwnames[] = {
15782 (char *) "self", NULL
15783 };
15784
15785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackgroundMode",kwnames,&obj0)) goto fail;
15786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15787 if (SWIG_arg_fail(1)) SWIG_fail;
15788 {
15789 PyThreadState* __tstate = wxPyBeginAllowThreads();
15790 result = (int)((wxDC const *)arg1)->GetBackgroundMode();
15791
15792 wxPyEndAllowThreads(__tstate);
15793 if (PyErr_Occurred()) SWIG_fail;
15794 }
15795 {
15796 resultobj = SWIG_From_int((int)(result));
15797 }
15798 return resultobj;
15799 fail:
15800 return NULL;
15801 }
15802
15803
15804 static PyObject *_wrap_DC_GetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
15805 PyObject *resultobj;
15806 wxDC *arg1 = (wxDC *) 0 ;
15807 wxBrush *result;
15808 PyObject * obj0 = 0 ;
15809 char *kwnames[] = {
15810 (char *) "self", NULL
15811 };
15812
15813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackground",kwnames,&obj0)) goto fail;
15814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15815 if (SWIG_arg_fail(1)) SWIG_fail;
15816 {
15817 PyThreadState* __tstate = wxPyBeginAllowThreads();
15818 {
15819 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBackground();
15820 result = (wxBrush *) &_result_ref;
15821 }
15822
15823 wxPyEndAllowThreads(__tstate);
15824 if (PyErr_Occurred()) SWIG_fail;
15825 }
15826 {
15827 wxBrush* resultptr = new wxBrush(*result);
15828 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
15829 }
15830 return resultobj;
15831 fail:
15832 return NULL;
15833 }
15834
15835
15836 static PyObject *_wrap_DC_GetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
15837 PyObject *resultobj;
15838 wxDC *arg1 = (wxDC *) 0 ;
15839 wxBrush *result;
15840 PyObject * obj0 = 0 ;
15841 char *kwnames[] = {
15842 (char *) "self", NULL
15843 };
15844
15845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBrush",kwnames,&obj0)) goto fail;
15846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15847 if (SWIG_arg_fail(1)) SWIG_fail;
15848 {
15849 PyThreadState* __tstate = wxPyBeginAllowThreads();
15850 {
15851 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBrush();
15852 result = (wxBrush *) &_result_ref;
15853 }
15854
15855 wxPyEndAllowThreads(__tstate);
15856 if (PyErr_Occurred()) SWIG_fail;
15857 }
15858 {
15859 wxBrush* resultptr = new wxBrush(*result);
15860 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
15861 }
15862 return resultobj;
15863 fail:
15864 return NULL;
15865 }
15866
15867
15868 static PyObject *_wrap_DC_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
15869 PyObject *resultobj;
15870 wxDC *arg1 = (wxDC *) 0 ;
15871 wxFont *result;
15872 PyObject * obj0 = 0 ;
15873 char *kwnames[] = {
15874 (char *) "self", NULL
15875 };
15876
15877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetFont",kwnames,&obj0)) goto fail;
15878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15879 if (SWIG_arg_fail(1)) SWIG_fail;
15880 {
15881 PyThreadState* __tstate = wxPyBeginAllowThreads();
15882 {
15883 wxFont const &_result_ref = ((wxDC const *)arg1)->GetFont();
15884 result = (wxFont *) &_result_ref;
15885 }
15886
15887 wxPyEndAllowThreads(__tstate);
15888 if (PyErr_Occurred()) SWIG_fail;
15889 }
15890 {
15891 wxFont* resultptr = new wxFont(*result);
15892 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxFont, 1);
15893 }
15894 return resultobj;
15895 fail:
15896 return NULL;
15897 }
15898
15899
15900 static PyObject *_wrap_DC_GetPen(PyObject *, PyObject *args, PyObject *kwargs) {
15901 PyObject *resultobj;
15902 wxDC *arg1 = (wxDC *) 0 ;
15903 wxPen *result;
15904 PyObject * obj0 = 0 ;
15905 char *kwnames[] = {
15906 (char *) "self", NULL
15907 };
15908
15909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPen",kwnames,&obj0)) goto fail;
15910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15911 if (SWIG_arg_fail(1)) SWIG_fail;
15912 {
15913 PyThreadState* __tstate = wxPyBeginAllowThreads();
15914 {
15915 wxPen const &_result_ref = ((wxDC const *)arg1)->GetPen();
15916 result = (wxPen *) &_result_ref;
15917 }
15918
15919 wxPyEndAllowThreads(__tstate);
15920 if (PyErr_Occurred()) SWIG_fail;
15921 }
15922 {
15923 wxPen* resultptr = new wxPen(*result);
15924 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxPen, 1);
15925 }
15926 return resultobj;
15927 fail:
15928 return NULL;
15929 }
15930
15931
15932 static PyObject *_wrap_DC_GetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
15933 PyObject *resultobj;
15934 wxDC *arg1 = (wxDC *) 0 ;
15935 wxColour *result;
15936 PyObject * obj0 = 0 ;
15937 char *kwnames[] = {
15938 (char *) "self", NULL
15939 };
15940
15941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextBackground",kwnames,&obj0)) goto fail;
15942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15943 if (SWIG_arg_fail(1)) SWIG_fail;
15944 {
15945 PyThreadState* __tstate = wxPyBeginAllowThreads();
15946 {
15947 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextBackground();
15948 result = (wxColour *) &_result_ref;
15949 }
15950
15951 wxPyEndAllowThreads(__tstate);
15952 if (PyErr_Occurred()) SWIG_fail;
15953 }
15954 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
15955 return resultobj;
15956 fail:
15957 return NULL;
15958 }
15959
15960
15961 static PyObject *_wrap_DC_GetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
15962 PyObject *resultobj;
15963 wxDC *arg1 = (wxDC *) 0 ;
15964 wxColour *result;
15965 PyObject * obj0 = 0 ;
15966 char *kwnames[] = {
15967 (char *) "self", NULL
15968 };
15969
15970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextForeground",kwnames,&obj0)) goto fail;
15971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15972 if (SWIG_arg_fail(1)) SWIG_fail;
15973 {
15974 PyThreadState* __tstate = wxPyBeginAllowThreads();
15975 {
15976 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextForeground();
15977 result = (wxColour *) &_result_ref;
15978 }
15979
15980 wxPyEndAllowThreads(__tstate);
15981 if (PyErr_Occurred()) SWIG_fail;
15982 }
15983 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
15984 return resultobj;
15985 fail:
15986 return NULL;
15987 }
15988
15989
15990 static PyObject *_wrap_DC_SetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
15991 PyObject *resultobj;
15992 wxDC *arg1 = (wxDC *) 0 ;
15993 wxColour *arg2 = 0 ;
15994 wxColour temp2 ;
15995 PyObject * obj0 = 0 ;
15996 PyObject * obj1 = 0 ;
15997 char *kwnames[] = {
15998 (char *) "self",(char *) "colour", NULL
15999 };
16000
16001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextForeground",kwnames,&obj0,&obj1)) goto fail;
16002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16003 if (SWIG_arg_fail(1)) SWIG_fail;
16004 {
16005 arg2 = &temp2;
16006 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16007 }
16008 {
16009 PyThreadState* __tstate = wxPyBeginAllowThreads();
16010 (arg1)->SetTextForeground((wxColour const &)*arg2);
16011
16012 wxPyEndAllowThreads(__tstate);
16013 if (PyErr_Occurred()) SWIG_fail;
16014 }
16015 Py_INCREF(Py_None); resultobj = Py_None;
16016 return resultobj;
16017 fail:
16018 return NULL;
16019 }
16020
16021
16022 static PyObject *_wrap_DC_SetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16023 PyObject *resultobj;
16024 wxDC *arg1 = (wxDC *) 0 ;
16025 wxColour *arg2 = 0 ;
16026 wxColour temp2 ;
16027 PyObject * obj0 = 0 ;
16028 PyObject * obj1 = 0 ;
16029 char *kwnames[] = {
16030 (char *) "self",(char *) "colour", NULL
16031 };
16032
16033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextBackground",kwnames,&obj0,&obj1)) goto fail;
16034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16035 if (SWIG_arg_fail(1)) SWIG_fail;
16036 {
16037 arg2 = &temp2;
16038 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16039 }
16040 {
16041 PyThreadState* __tstate = wxPyBeginAllowThreads();
16042 (arg1)->SetTextBackground((wxColour const &)*arg2);
16043
16044 wxPyEndAllowThreads(__tstate);
16045 if (PyErr_Occurred()) SWIG_fail;
16046 }
16047 Py_INCREF(Py_None); resultobj = Py_None;
16048 return resultobj;
16049 fail:
16050 return NULL;
16051 }
16052
16053
16054 static PyObject *_wrap_DC_GetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16055 PyObject *resultobj;
16056 wxDC *arg1 = (wxDC *) 0 ;
16057 int result;
16058 PyObject * obj0 = 0 ;
16059 char *kwnames[] = {
16060 (char *) "self", NULL
16061 };
16062
16063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetMapMode",kwnames,&obj0)) goto fail;
16064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16065 if (SWIG_arg_fail(1)) SWIG_fail;
16066 {
16067 PyThreadState* __tstate = wxPyBeginAllowThreads();
16068 result = (int)((wxDC const *)arg1)->GetMapMode();
16069
16070 wxPyEndAllowThreads(__tstate);
16071 if (PyErr_Occurred()) SWIG_fail;
16072 }
16073 {
16074 resultobj = SWIG_From_int((int)(result));
16075 }
16076 return resultobj;
16077 fail:
16078 return NULL;
16079 }
16080
16081
16082 static PyObject *_wrap_DC_SetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16083 PyObject *resultobj;
16084 wxDC *arg1 = (wxDC *) 0 ;
16085 int arg2 ;
16086 PyObject * obj0 = 0 ;
16087 PyObject * obj1 = 0 ;
16088 char *kwnames[] = {
16089 (char *) "self",(char *) "mode", NULL
16090 };
16091
16092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetMapMode",kwnames,&obj0,&obj1)) goto fail;
16093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16094 if (SWIG_arg_fail(1)) SWIG_fail;
16095 {
16096 arg2 = (int)(SWIG_As_int(obj1));
16097 if (SWIG_arg_fail(2)) SWIG_fail;
16098 }
16099 {
16100 PyThreadState* __tstate = wxPyBeginAllowThreads();
16101 (arg1)->SetMapMode(arg2);
16102
16103 wxPyEndAllowThreads(__tstate);
16104 if (PyErr_Occurred()) SWIG_fail;
16105 }
16106 Py_INCREF(Py_None); resultobj = Py_None;
16107 return resultobj;
16108 fail:
16109 return NULL;
16110 }
16111
16112
16113 static PyObject *_wrap_DC_GetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16114 PyObject *resultobj;
16115 wxDC *arg1 = (wxDC *) 0 ;
16116 double *arg2 = (double *) 0 ;
16117 double *arg3 = (double *) 0 ;
16118 double temp2 ;
16119 int res2 = 0 ;
16120 double temp3 ;
16121 int res3 = 0 ;
16122 PyObject * obj0 = 0 ;
16123 char *kwnames[] = {
16124 (char *) "self", NULL
16125 };
16126
16127 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16128 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetUserScale",kwnames,&obj0)) goto fail;
16130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16131 if (SWIG_arg_fail(1)) SWIG_fail;
16132 {
16133 PyThreadState* __tstate = wxPyBeginAllowThreads();
16134 ((wxDC const *)arg1)->GetUserScale(arg2,arg3);
16135
16136 wxPyEndAllowThreads(__tstate);
16137 if (PyErr_Occurred()) SWIG_fail;
16138 }
16139 Py_INCREF(Py_None); resultobj = Py_None;
16140 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16141 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16142 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16143 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16144 return resultobj;
16145 fail:
16146 return NULL;
16147 }
16148
16149
16150 static PyObject *_wrap_DC_SetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16151 PyObject *resultobj;
16152 wxDC *arg1 = (wxDC *) 0 ;
16153 double arg2 ;
16154 double arg3 ;
16155 PyObject * obj0 = 0 ;
16156 PyObject * obj1 = 0 ;
16157 PyObject * obj2 = 0 ;
16158 char *kwnames[] = {
16159 (char *) "self",(char *) "x",(char *) "y", NULL
16160 };
16161
16162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetUserScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16164 if (SWIG_arg_fail(1)) SWIG_fail;
16165 {
16166 arg2 = (double)(SWIG_As_double(obj1));
16167 if (SWIG_arg_fail(2)) SWIG_fail;
16168 }
16169 {
16170 arg3 = (double)(SWIG_As_double(obj2));
16171 if (SWIG_arg_fail(3)) SWIG_fail;
16172 }
16173 {
16174 PyThreadState* __tstate = wxPyBeginAllowThreads();
16175 (arg1)->SetUserScale(arg2,arg3);
16176
16177 wxPyEndAllowThreads(__tstate);
16178 if (PyErr_Occurred()) SWIG_fail;
16179 }
16180 Py_INCREF(Py_None); resultobj = Py_None;
16181 return resultobj;
16182 fail:
16183 return NULL;
16184 }
16185
16186
16187 static PyObject *_wrap_DC_GetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16188 PyObject *resultobj;
16189 wxDC *arg1 = (wxDC *) 0 ;
16190 double *arg2 = (double *) 0 ;
16191 double *arg3 = (double *) 0 ;
16192 double temp2 ;
16193 int res2 = 0 ;
16194 double temp3 ;
16195 int res3 = 0 ;
16196 PyObject * obj0 = 0 ;
16197 char *kwnames[] = {
16198 (char *) "self", NULL
16199 };
16200
16201 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16202 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalScale",kwnames,&obj0)) goto fail;
16204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16205 if (SWIG_arg_fail(1)) SWIG_fail;
16206 {
16207 PyThreadState* __tstate = wxPyBeginAllowThreads();
16208 (arg1)->GetLogicalScale(arg2,arg3);
16209
16210 wxPyEndAllowThreads(__tstate);
16211 if (PyErr_Occurred()) SWIG_fail;
16212 }
16213 Py_INCREF(Py_None); resultobj = Py_None;
16214 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16215 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16216 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16217 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16218 return resultobj;
16219 fail:
16220 return NULL;
16221 }
16222
16223
16224 static PyObject *_wrap_DC_SetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16225 PyObject *resultobj;
16226 wxDC *arg1 = (wxDC *) 0 ;
16227 double arg2 ;
16228 double arg3 ;
16229 PyObject * obj0 = 0 ;
16230 PyObject * obj1 = 0 ;
16231 PyObject * obj2 = 0 ;
16232 char *kwnames[] = {
16233 (char *) "self",(char *) "x",(char *) "y", NULL
16234 };
16235
16236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16238 if (SWIG_arg_fail(1)) SWIG_fail;
16239 {
16240 arg2 = (double)(SWIG_As_double(obj1));
16241 if (SWIG_arg_fail(2)) SWIG_fail;
16242 }
16243 {
16244 arg3 = (double)(SWIG_As_double(obj2));
16245 if (SWIG_arg_fail(3)) SWIG_fail;
16246 }
16247 {
16248 PyThreadState* __tstate = wxPyBeginAllowThreads();
16249 (arg1)->SetLogicalScale(arg2,arg3);
16250
16251 wxPyEndAllowThreads(__tstate);
16252 if (PyErr_Occurred()) SWIG_fail;
16253 }
16254 Py_INCREF(Py_None); resultobj = Py_None;
16255 return resultobj;
16256 fail:
16257 return NULL;
16258 }
16259
16260
16261 static PyObject *_wrap_DC_GetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16262 PyObject *resultobj;
16263 wxDC *arg1 = (wxDC *) 0 ;
16264 wxPoint result;
16265 PyObject * obj0 = 0 ;
16266 char *kwnames[] = {
16267 (char *) "self", NULL
16268 };
16269
16270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOrigin",kwnames,&obj0)) goto fail;
16271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16272 if (SWIG_arg_fail(1)) SWIG_fail;
16273 {
16274 PyThreadState* __tstate = wxPyBeginAllowThreads();
16275 result = ((wxDC const *)arg1)->GetLogicalOrigin();
16276
16277 wxPyEndAllowThreads(__tstate);
16278 if (PyErr_Occurred()) SWIG_fail;
16279 }
16280 {
16281 wxPoint * resultptr;
16282 resultptr = new wxPoint((wxPoint &)(result));
16283 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16284 }
16285 return resultobj;
16286 fail:
16287 return NULL;
16288 }
16289
16290
16291 static PyObject *_wrap_DC_GetLogicalOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16292 PyObject *resultobj;
16293 wxDC *arg1 = (wxDC *) 0 ;
16294 int *arg2 = (int *) 0 ;
16295 int *arg3 = (int *) 0 ;
16296 int temp2 ;
16297 int res2 = 0 ;
16298 int temp3 ;
16299 int res3 = 0 ;
16300 PyObject * obj0 = 0 ;
16301 char *kwnames[] = {
16302 (char *) "self", NULL
16303 };
16304
16305 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16306 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOriginTuple",kwnames,&obj0)) goto fail;
16308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16309 if (SWIG_arg_fail(1)) SWIG_fail;
16310 {
16311 PyThreadState* __tstate = wxPyBeginAllowThreads();
16312 ((wxDC const *)arg1)->GetLogicalOrigin(arg2,arg3);
16313
16314 wxPyEndAllowThreads(__tstate);
16315 if (PyErr_Occurred()) SWIG_fail;
16316 }
16317 Py_INCREF(Py_None); resultobj = Py_None;
16318 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16319 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16320 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16321 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16322 return resultobj;
16323 fail:
16324 return NULL;
16325 }
16326
16327
16328 static PyObject *_wrap_DC_SetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16329 PyObject *resultobj;
16330 wxDC *arg1 = (wxDC *) 0 ;
16331 int arg2 ;
16332 int arg3 ;
16333 PyObject * obj0 = 0 ;
16334 PyObject * obj1 = 0 ;
16335 PyObject * obj2 = 0 ;
16336 char *kwnames[] = {
16337 (char *) "self",(char *) "x",(char *) "y", NULL
16338 };
16339
16340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
16341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16342 if (SWIG_arg_fail(1)) SWIG_fail;
16343 {
16344 arg2 = (int)(SWIG_As_int(obj1));
16345 if (SWIG_arg_fail(2)) SWIG_fail;
16346 }
16347 {
16348 arg3 = (int)(SWIG_As_int(obj2));
16349 if (SWIG_arg_fail(3)) SWIG_fail;
16350 }
16351 {
16352 PyThreadState* __tstate = wxPyBeginAllowThreads();
16353 (arg1)->SetLogicalOrigin(arg2,arg3);
16354
16355 wxPyEndAllowThreads(__tstate);
16356 if (PyErr_Occurred()) SWIG_fail;
16357 }
16358 Py_INCREF(Py_None); resultobj = Py_None;
16359 return resultobj;
16360 fail:
16361 return NULL;
16362 }
16363
16364
16365 static PyObject *_wrap_DC_SetLogicalOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16366 PyObject *resultobj;
16367 wxDC *arg1 = (wxDC *) 0 ;
16368 wxPoint *arg2 = 0 ;
16369 wxPoint temp2 ;
16370 PyObject * obj0 = 0 ;
16371 PyObject * obj1 = 0 ;
16372 char *kwnames[] = {
16373 (char *) "self",(char *) "point", NULL
16374 };
16375
16376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalOriginPoint",kwnames,&obj0,&obj1)) goto fail;
16377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16378 if (SWIG_arg_fail(1)) SWIG_fail;
16379 {
16380 arg2 = &temp2;
16381 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16382 }
16383 {
16384 PyThreadState* __tstate = wxPyBeginAllowThreads();
16385 wxDC_SetLogicalOriginPoint(arg1,(wxPoint const &)*arg2);
16386
16387 wxPyEndAllowThreads(__tstate);
16388 if (PyErr_Occurred()) SWIG_fail;
16389 }
16390 Py_INCREF(Py_None); resultobj = Py_None;
16391 return resultobj;
16392 fail:
16393 return NULL;
16394 }
16395
16396
16397 static PyObject *_wrap_DC_GetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16398 PyObject *resultobj;
16399 wxDC *arg1 = (wxDC *) 0 ;
16400 wxPoint result;
16401 PyObject * obj0 = 0 ;
16402 char *kwnames[] = {
16403 (char *) "self", NULL
16404 };
16405
16406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOrigin",kwnames,&obj0)) goto fail;
16407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16408 if (SWIG_arg_fail(1)) SWIG_fail;
16409 {
16410 PyThreadState* __tstate = wxPyBeginAllowThreads();
16411 result = ((wxDC const *)arg1)->GetDeviceOrigin();
16412
16413 wxPyEndAllowThreads(__tstate);
16414 if (PyErr_Occurred()) SWIG_fail;
16415 }
16416 {
16417 wxPoint * resultptr;
16418 resultptr = new wxPoint((wxPoint &)(result));
16419 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16420 }
16421 return resultobj;
16422 fail:
16423 return NULL;
16424 }
16425
16426
16427 static PyObject *_wrap_DC_GetDeviceOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16428 PyObject *resultobj;
16429 wxDC *arg1 = (wxDC *) 0 ;
16430 int *arg2 = (int *) 0 ;
16431 int *arg3 = (int *) 0 ;
16432 int temp2 ;
16433 int res2 = 0 ;
16434 int temp3 ;
16435 int res3 = 0 ;
16436 PyObject * obj0 = 0 ;
16437 char *kwnames[] = {
16438 (char *) "self", NULL
16439 };
16440
16441 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16442 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOriginTuple",kwnames,&obj0)) goto fail;
16444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16445 if (SWIG_arg_fail(1)) SWIG_fail;
16446 {
16447 PyThreadState* __tstate = wxPyBeginAllowThreads();
16448 ((wxDC const *)arg1)->GetDeviceOrigin(arg2,arg3);
16449
16450 wxPyEndAllowThreads(__tstate);
16451 if (PyErr_Occurred()) SWIG_fail;
16452 }
16453 Py_INCREF(Py_None); resultobj = Py_None;
16454 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16455 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16456 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16457 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16458 return resultobj;
16459 fail:
16460 return NULL;
16461 }
16462
16463
16464 static PyObject *_wrap_DC_SetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16465 PyObject *resultobj;
16466 wxDC *arg1 = (wxDC *) 0 ;
16467 int arg2 ;
16468 int arg3 ;
16469 PyObject * obj0 = 0 ;
16470 PyObject * obj1 = 0 ;
16471 PyObject * obj2 = 0 ;
16472 char *kwnames[] = {
16473 (char *) "self",(char *) "x",(char *) "y", NULL
16474 };
16475
16476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetDeviceOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
16477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16478 if (SWIG_arg_fail(1)) SWIG_fail;
16479 {
16480 arg2 = (int)(SWIG_As_int(obj1));
16481 if (SWIG_arg_fail(2)) SWIG_fail;
16482 }
16483 {
16484 arg3 = (int)(SWIG_As_int(obj2));
16485 if (SWIG_arg_fail(3)) SWIG_fail;
16486 }
16487 {
16488 PyThreadState* __tstate = wxPyBeginAllowThreads();
16489 (arg1)->SetDeviceOrigin(arg2,arg3);
16490
16491 wxPyEndAllowThreads(__tstate);
16492 if (PyErr_Occurred()) SWIG_fail;
16493 }
16494 Py_INCREF(Py_None); resultobj = Py_None;
16495 return resultobj;
16496 fail:
16497 return NULL;
16498 }
16499
16500
16501 static PyObject *_wrap_DC_SetDeviceOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16502 PyObject *resultobj;
16503 wxDC *arg1 = (wxDC *) 0 ;
16504 wxPoint *arg2 = 0 ;
16505 wxPoint temp2 ;
16506 PyObject * obj0 = 0 ;
16507 PyObject * obj1 = 0 ;
16508 char *kwnames[] = {
16509 (char *) "self",(char *) "point", NULL
16510 };
16511
16512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetDeviceOriginPoint",kwnames,&obj0,&obj1)) goto fail;
16513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16514 if (SWIG_arg_fail(1)) SWIG_fail;
16515 {
16516 arg2 = &temp2;
16517 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16518 }
16519 {
16520 PyThreadState* __tstate = wxPyBeginAllowThreads();
16521 wxDC_SetDeviceOriginPoint(arg1,(wxPoint const &)*arg2);
16522
16523 wxPyEndAllowThreads(__tstate);
16524 if (PyErr_Occurred()) SWIG_fail;
16525 }
16526 Py_INCREF(Py_None); resultobj = Py_None;
16527 return resultobj;
16528 fail:
16529 return NULL;
16530 }
16531
16532
16533 static PyObject *_wrap_DC_SetAxisOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16534 PyObject *resultobj;
16535 wxDC *arg1 = (wxDC *) 0 ;
16536 bool arg2 ;
16537 bool arg3 ;
16538 PyObject * obj0 = 0 ;
16539 PyObject * obj1 = 0 ;
16540 PyObject * obj2 = 0 ;
16541 char *kwnames[] = {
16542 (char *) "self",(char *) "xLeftRight",(char *) "yBottomUp", NULL
16543 };
16544
16545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetAxisOrientation",kwnames,&obj0,&obj1,&obj2)) goto fail;
16546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16547 if (SWIG_arg_fail(1)) SWIG_fail;
16548 {
16549 arg2 = (bool)(SWIG_As_bool(obj1));
16550 if (SWIG_arg_fail(2)) SWIG_fail;
16551 }
16552 {
16553 arg3 = (bool)(SWIG_As_bool(obj2));
16554 if (SWIG_arg_fail(3)) SWIG_fail;
16555 }
16556 {
16557 PyThreadState* __tstate = wxPyBeginAllowThreads();
16558 (arg1)->SetAxisOrientation(arg2,arg3);
16559
16560 wxPyEndAllowThreads(__tstate);
16561 if (PyErr_Occurred()) SWIG_fail;
16562 }
16563 Py_INCREF(Py_None); resultobj = Py_None;
16564 return resultobj;
16565 fail:
16566 return NULL;
16567 }
16568
16569
16570 static PyObject *_wrap_DC_GetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
16571 PyObject *resultobj;
16572 wxDC *arg1 = (wxDC *) 0 ;
16573 int result;
16574 PyObject * obj0 = 0 ;
16575 char *kwnames[] = {
16576 (char *) "self", NULL
16577 };
16578
16579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalFunction",kwnames,&obj0)) goto fail;
16580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16581 if (SWIG_arg_fail(1)) SWIG_fail;
16582 {
16583 PyThreadState* __tstate = wxPyBeginAllowThreads();
16584 result = (int)((wxDC const *)arg1)->GetLogicalFunction();
16585
16586 wxPyEndAllowThreads(__tstate);
16587 if (PyErr_Occurred()) SWIG_fail;
16588 }
16589 {
16590 resultobj = SWIG_From_int((int)(result));
16591 }
16592 return resultobj;
16593 fail:
16594 return NULL;
16595 }
16596
16597
16598 static PyObject *_wrap_DC_SetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
16599 PyObject *resultobj;
16600 wxDC *arg1 = (wxDC *) 0 ;
16601 int arg2 ;
16602 PyObject * obj0 = 0 ;
16603 PyObject * obj1 = 0 ;
16604 char *kwnames[] = {
16605 (char *) "self",(char *) "function", NULL
16606 };
16607
16608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalFunction",kwnames,&obj0,&obj1)) goto fail;
16609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16610 if (SWIG_arg_fail(1)) SWIG_fail;
16611 {
16612 arg2 = (int)(SWIG_As_int(obj1));
16613 if (SWIG_arg_fail(2)) SWIG_fail;
16614 }
16615 {
16616 PyThreadState* __tstate = wxPyBeginAllowThreads();
16617 (arg1)->SetLogicalFunction(arg2);
16618
16619 wxPyEndAllowThreads(__tstate);
16620 if (PyErr_Occurred()) SWIG_fail;
16621 }
16622 Py_INCREF(Py_None); resultobj = Py_None;
16623 return resultobj;
16624 fail:
16625 return NULL;
16626 }
16627
16628
16629 static PyObject *_wrap_DC_ComputeScaleAndOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16630 PyObject *resultobj;
16631 wxDC *arg1 = (wxDC *) 0 ;
16632 PyObject * obj0 = 0 ;
16633 char *kwnames[] = {
16634 (char *) "self", NULL
16635 };
16636
16637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ComputeScaleAndOrigin",kwnames,&obj0)) goto fail;
16638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16639 if (SWIG_arg_fail(1)) SWIG_fail;
16640 {
16641 PyThreadState* __tstate = wxPyBeginAllowThreads();
16642 (arg1)->ComputeScaleAndOrigin();
16643
16644 wxPyEndAllowThreads(__tstate);
16645 if (PyErr_Occurred()) SWIG_fail;
16646 }
16647 Py_INCREF(Py_None); resultobj = Py_None;
16648 return resultobj;
16649 fail:
16650 return NULL;
16651 }
16652
16653
16654 static PyObject *_wrap_DC_CalcBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16655 PyObject *resultobj;
16656 wxDC *arg1 = (wxDC *) 0 ;
16657 int arg2 ;
16658 int arg3 ;
16659 PyObject * obj0 = 0 ;
16660 PyObject * obj1 = 0 ;
16661 PyObject * obj2 = 0 ;
16662 char *kwnames[] = {
16663 (char *) "self",(char *) "x",(char *) "y", NULL
16664 };
16665
16666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CalcBoundingBox",kwnames,&obj0,&obj1,&obj2)) goto fail;
16667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16668 if (SWIG_arg_fail(1)) SWIG_fail;
16669 {
16670 arg2 = (int)(SWIG_As_int(obj1));
16671 if (SWIG_arg_fail(2)) SWIG_fail;
16672 }
16673 {
16674 arg3 = (int)(SWIG_As_int(obj2));
16675 if (SWIG_arg_fail(3)) SWIG_fail;
16676 }
16677 {
16678 PyThreadState* __tstate = wxPyBeginAllowThreads();
16679 (arg1)->CalcBoundingBox(arg2,arg3);
16680
16681 wxPyEndAllowThreads(__tstate);
16682 if (PyErr_Occurred()) SWIG_fail;
16683 }
16684 Py_INCREF(Py_None); resultobj = Py_None;
16685 return resultobj;
16686 fail:
16687 return NULL;
16688 }
16689
16690
16691 static PyObject *_wrap_DC_CalcBoundingBoxPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16692 PyObject *resultobj;
16693 wxDC *arg1 = (wxDC *) 0 ;
16694 wxPoint *arg2 = 0 ;
16695 wxPoint temp2 ;
16696 PyObject * obj0 = 0 ;
16697 PyObject * obj1 = 0 ;
16698 char *kwnames[] = {
16699 (char *) "self",(char *) "point", NULL
16700 };
16701
16702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CalcBoundingBoxPoint",kwnames,&obj0,&obj1)) goto fail;
16703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16704 if (SWIG_arg_fail(1)) SWIG_fail;
16705 {
16706 arg2 = &temp2;
16707 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16708 }
16709 {
16710 PyThreadState* __tstate = wxPyBeginAllowThreads();
16711 wxDC_CalcBoundingBoxPoint(arg1,(wxPoint const &)*arg2);
16712
16713 wxPyEndAllowThreads(__tstate);
16714 if (PyErr_Occurred()) SWIG_fail;
16715 }
16716 Py_INCREF(Py_None); resultobj = Py_None;
16717 return resultobj;
16718 fail:
16719 return NULL;
16720 }
16721
16722
16723 static PyObject *_wrap_DC_ResetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16724 PyObject *resultobj;
16725 wxDC *arg1 = (wxDC *) 0 ;
16726 PyObject * obj0 = 0 ;
16727 char *kwnames[] = {
16728 (char *) "self", NULL
16729 };
16730
16731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ResetBoundingBox",kwnames,&obj0)) goto fail;
16732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16733 if (SWIG_arg_fail(1)) SWIG_fail;
16734 {
16735 PyThreadState* __tstate = wxPyBeginAllowThreads();
16736 (arg1)->ResetBoundingBox();
16737
16738 wxPyEndAllowThreads(__tstate);
16739 if (PyErr_Occurred()) SWIG_fail;
16740 }
16741 Py_INCREF(Py_None); resultobj = Py_None;
16742 return resultobj;
16743 fail:
16744 return NULL;
16745 }
16746
16747
16748 static PyObject *_wrap_DC_MinX(PyObject *, PyObject *args, PyObject *kwargs) {
16749 PyObject *resultobj;
16750 wxDC *arg1 = (wxDC *) 0 ;
16751 int result;
16752 PyObject * obj0 = 0 ;
16753 char *kwnames[] = {
16754 (char *) "self", NULL
16755 };
16756
16757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinX",kwnames,&obj0)) goto fail;
16758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16759 if (SWIG_arg_fail(1)) SWIG_fail;
16760 {
16761 PyThreadState* __tstate = wxPyBeginAllowThreads();
16762 result = (int)((wxDC const *)arg1)->MinX();
16763
16764 wxPyEndAllowThreads(__tstate);
16765 if (PyErr_Occurred()) SWIG_fail;
16766 }
16767 {
16768 resultobj = SWIG_From_int((int)(result));
16769 }
16770 return resultobj;
16771 fail:
16772 return NULL;
16773 }
16774
16775
16776 static PyObject *_wrap_DC_MaxX(PyObject *, PyObject *args, PyObject *kwargs) {
16777 PyObject *resultobj;
16778 wxDC *arg1 = (wxDC *) 0 ;
16779 int result;
16780 PyObject * obj0 = 0 ;
16781 char *kwnames[] = {
16782 (char *) "self", NULL
16783 };
16784
16785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxX",kwnames,&obj0)) goto fail;
16786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16787 if (SWIG_arg_fail(1)) SWIG_fail;
16788 {
16789 PyThreadState* __tstate = wxPyBeginAllowThreads();
16790 result = (int)((wxDC const *)arg1)->MaxX();
16791
16792 wxPyEndAllowThreads(__tstate);
16793 if (PyErr_Occurred()) SWIG_fail;
16794 }
16795 {
16796 resultobj = SWIG_From_int((int)(result));
16797 }
16798 return resultobj;
16799 fail:
16800 return NULL;
16801 }
16802
16803
16804 static PyObject *_wrap_DC_MinY(PyObject *, PyObject *args, PyObject *kwargs) {
16805 PyObject *resultobj;
16806 wxDC *arg1 = (wxDC *) 0 ;
16807 int result;
16808 PyObject * obj0 = 0 ;
16809 char *kwnames[] = {
16810 (char *) "self", NULL
16811 };
16812
16813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinY",kwnames,&obj0)) goto fail;
16814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16815 if (SWIG_arg_fail(1)) SWIG_fail;
16816 {
16817 PyThreadState* __tstate = wxPyBeginAllowThreads();
16818 result = (int)((wxDC const *)arg1)->MinY();
16819
16820 wxPyEndAllowThreads(__tstate);
16821 if (PyErr_Occurred()) SWIG_fail;
16822 }
16823 {
16824 resultobj = SWIG_From_int((int)(result));
16825 }
16826 return resultobj;
16827 fail:
16828 return NULL;
16829 }
16830
16831
16832 static PyObject *_wrap_DC_MaxY(PyObject *, PyObject *args, PyObject *kwargs) {
16833 PyObject *resultobj;
16834 wxDC *arg1 = (wxDC *) 0 ;
16835 int result;
16836 PyObject * obj0 = 0 ;
16837 char *kwnames[] = {
16838 (char *) "self", NULL
16839 };
16840
16841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxY",kwnames,&obj0)) goto fail;
16842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16843 if (SWIG_arg_fail(1)) SWIG_fail;
16844 {
16845 PyThreadState* __tstate = wxPyBeginAllowThreads();
16846 result = (int)((wxDC const *)arg1)->MaxY();
16847
16848 wxPyEndAllowThreads(__tstate);
16849 if (PyErr_Occurred()) SWIG_fail;
16850 }
16851 {
16852 resultobj = SWIG_From_int((int)(result));
16853 }
16854 return resultobj;
16855 fail:
16856 return NULL;
16857 }
16858
16859
16860 static PyObject *_wrap_DC_GetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16861 PyObject *resultobj;
16862 wxDC *arg1 = (wxDC *) 0 ;
16863 int *arg2 = (int *) 0 ;
16864 int *arg3 = (int *) 0 ;
16865 int *arg4 = (int *) 0 ;
16866 int *arg5 = (int *) 0 ;
16867 int temp2 ;
16868 int res2 = 0 ;
16869 int temp3 ;
16870 int res3 = 0 ;
16871 int temp4 ;
16872 int res4 = 0 ;
16873 int temp5 ;
16874 int res5 = 0 ;
16875 PyObject * obj0 = 0 ;
16876 char *kwnames[] = {
16877 (char *) "self", NULL
16878 };
16879
16880 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16881 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16882 arg4 = &temp4; res4 = SWIG_NEWOBJ;
16883 arg5 = &temp5; res5 = SWIG_NEWOBJ;
16884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBoundingBox",kwnames,&obj0)) goto fail;
16885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16886 if (SWIG_arg_fail(1)) SWIG_fail;
16887 {
16888 PyThreadState* __tstate = wxPyBeginAllowThreads();
16889 wxDC_GetBoundingBox(arg1,arg2,arg3,arg4,arg5);
16890
16891 wxPyEndAllowThreads(__tstate);
16892 if (PyErr_Occurred()) SWIG_fail;
16893 }
16894 Py_INCREF(Py_None); resultobj = Py_None;
16895 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16896 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16897 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16898 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16899 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
16900 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
16901 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
16902 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
16903 return resultobj;
16904 fail:
16905 return NULL;
16906 }
16907
16908
16909 static PyObject *_wrap_DC__DrawPointList(PyObject *, PyObject *args, PyObject *kwargs) {
16910 PyObject *resultobj;
16911 wxDC *arg1 = (wxDC *) 0 ;
16912 PyObject *arg2 = (PyObject *) 0 ;
16913 PyObject *arg3 = (PyObject *) 0 ;
16914 PyObject *arg4 = (PyObject *) 0 ;
16915 PyObject *result;
16916 PyObject * obj0 = 0 ;
16917 PyObject * obj1 = 0 ;
16918 PyObject * obj2 = 0 ;
16919 PyObject * obj3 = 0 ;
16920 char *kwnames[] = {
16921 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
16922 };
16923
16924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPointList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16926 if (SWIG_arg_fail(1)) SWIG_fail;
16927 arg2 = obj1;
16928 arg3 = obj2;
16929 arg4 = obj3;
16930 {
16931 PyThreadState* __tstate = wxPyBeginAllowThreads();
16932 result = (PyObject *)wxDC__DrawPointList(arg1,arg2,arg3,arg4);
16933
16934 wxPyEndAllowThreads(__tstate);
16935 if (PyErr_Occurred()) SWIG_fail;
16936 }
16937 resultobj = result;
16938 return resultobj;
16939 fail:
16940 return NULL;
16941 }
16942
16943
16944 static PyObject *_wrap_DC__DrawLineList(PyObject *, PyObject *args, PyObject *kwargs) {
16945 PyObject *resultobj;
16946 wxDC *arg1 = (wxDC *) 0 ;
16947 PyObject *arg2 = (PyObject *) 0 ;
16948 PyObject *arg3 = (PyObject *) 0 ;
16949 PyObject *arg4 = (PyObject *) 0 ;
16950 PyObject *result;
16951 PyObject * obj0 = 0 ;
16952 PyObject * obj1 = 0 ;
16953 PyObject * obj2 = 0 ;
16954 PyObject * obj3 = 0 ;
16955 char *kwnames[] = {
16956 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
16957 };
16958
16959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawLineList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16961 if (SWIG_arg_fail(1)) SWIG_fail;
16962 arg2 = obj1;
16963 arg3 = obj2;
16964 arg4 = obj3;
16965 {
16966 PyThreadState* __tstate = wxPyBeginAllowThreads();
16967 result = (PyObject *)wxDC__DrawLineList(arg1,arg2,arg3,arg4);
16968
16969 wxPyEndAllowThreads(__tstate);
16970 if (PyErr_Occurred()) SWIG_fail;
16971 }
16972 resultobj = result;
16973 return resultobj;
16974 fail:
16975 return NULL;
16976 }
16977
16978
16979 static PyObject *_wrap_DC__DrawRectangleList(PyObject *, PyObject *args, PyObject *kwargs) {
16980 PyObject *resultobj;
16981 wxDC *arg1 = (wxDC *) 0 ;
16982 PyObject *arg2 = (PyObject *) 0 ;
16983 PyObject *arg3 = (PyObject *) 0 ;
16984 PyObject *arg4 = (PyObject *) 0 ;
16985 PyObject *result;
16986 PyObject * obj0 = 0 ;
16987 PyObject * obj1 = 0 ;
16988 PyObject * obj2 = 0 ;
16989 PyObject * obj3 = 0 ;
16990 char *kwnames[] = {
16991 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
16992 };
16993
16994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawRectangleList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16996 if (SWIG_arg_fail(1)) SWIG_fail;
16997 arg2 = obj1;
16998 arg3 = obj2;
16999 arg4 = obj3;
17000 {
17001 PyThreadState* __tstate = wxPyBeginAllowThreads();
17002 result = (PyObject *)wxDC__DrawRectangleList(arg1,arg2,arg3,arg4);
17003
17004 wxPyEndAllowThreads(__tstate);
17005 if (PyErr_Occurred()) SWIG_fail;
17006 }
17007 resultobj = result;
17008 return resultobj;
17009 fail:
17010 return NULL;
17011 }
17012
17013
17014 static PyObject *_wrap_DC__DrawEllipseList(PyObject *, PyObject *args, PyObject *kwargs) {
17015 PyObject *resultobj;
17016 wxDC *arg1 = (wxDC *) 0 ;
17017 PyObject *arg2 = (PyObject *) 0 ;
17018 PyObject *arg3 = (PyObject *) 0 ;
17019 PyObject *arg4 = (PyObject *) 0 ;
17020 PyObject *result;
17021 PyObject * obj0 = 0 ;
17022 PyObject * obj1 = 0 ;
17023 PyObject * obj2 = 0 ;
17024 PyObject * obj3 = 0 ;
17025 char *kwnames[] = {
17026 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17027 };
17028
17029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawEllipseList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17031 if (SWIG_arg_fail(1)) SWIG_fail;
17032 arg2 = obj1;
17033 arg3 = obj2;
17034 arg4 = obj3;
17035 {
17036 PyThreadState* __tstate = wxPyBeginAllowThreads();
17037 result = (PyObject *)wxDC__DrawEllipseList(arg1,arg2,arg3,arg4);
17038
17039 wxPyEndAllowThreads(__tstate);
17040 if (PyErr_Occurred()) SWIG_fail;
17041 }
17042 resultobj = result;
17043 return resultobj;
17044 fail:
17045 return NULL;
17046 }
17047
17048
17049 static PyObject *_wrap_DC__DrawPolygonList(PyObject *, PyObject *args, PyObject *kwargs) {
17050 PyObject *resultobj;
17051 wxDC *arg1 = (wxDC *) 0 ;
17052 PyObject *arg2 = (PyObject *) 0 ;
17053 PyObject *arg3 = (PyObject *) 0 ;
17054 PyObject *arg4 = (PyObject *) 0 ;
17055 PyObject *result;
17056 PyObject * obj0 = 0 ;
17057 PyObject * obj1 = 0 ;
17058 PyObject * obj2 = 0 ;
17059 PyObject * obj3 = 0 ;
17060 char *kwnames[] = {
17061 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17062 };
17063
17064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPolygonList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17066 if (SWIG_arg_fail(1)) SWIG_fail;
17067 arg2 = obj1;
17068 arg3 = obj2;
17069 arg4 = obj3;
17070 {
17071 PyThreadState* __tstate = wxPyBeginAllowThreads();
17072 result = (PyObject *)wxDC__DrawPolygonList(arg1,arg2,arg3,arg4);
17073
17074 wxPyEndAllowThreads(__tstate);
17075 if (PyErr_Occurred()) SWIG_fail;
17076 }
17077 resultobj = result;
17078 return resultobj;
17079 fail:
17080 return NULL;
17081 }
17082
17083
17084 static PyObject *_wrap_DC__DrawTextList(PyObject *, PyObject *args, PyObject *kwargs) {
17085 PyObject *resultobj;
17086 wxDC *arg1 = (wxDC *) 0 ;
17087 PyObject *arg2 = (PyObject *) 0 ;
17088 PyObject *arg3 = (PyObject *) 0 ;
17089 PyObject *arg4 = (PyObject *) 0 ;
17090 PyObject *arg5 = (PyObject *) 0 ;
17091 PyObject *result;
17092 PyObject * obj0 = 0 ;
17093 PyObject * obj1 = 0 ;
17094 PyObject * obj2 = 0 ;
17095 PyObject * obj3 = 0 ;
17096 PyObject * obj4 = 0 ;
17097 char *kwnames[] = {
17098 (char *) "self",(char *) "textList",(char *) "pyPoints",(char *) "foregroundList",(char *) "backgroundList", NULL
17099 };
17100
17101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC__DrawTextList",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
17102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17103 if (SWIG_arg_fail(1)) SWIG_fail;
17104 arg2 = obj1;
17105 arg3 = obj2;
17106 arg4 = obj3;
17107 arg5 = obj4;
17108 {
17109 PyThreadState* __tstate = wxPyBeginAllowThreads();
17110 result = (PyObject *)wxDC__DrawTextList(arg1,arg2,arg3,arg4,arg5);
17111
17112 wxPyEndAllowThreads(__tstate);
17113 if (PyErr_Occurred()) SWIG_fail;
17114 }
17115 resultobj = result;
17116 return resultobj;
17117 fail:
17118 return NULL;
17119 }
17120
17121
17122 static PyObject * DC_swigregister(PyObject *, PyObject *args) {
17123 PyObject *obj;
17124 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17125 SWIG_TypeClientData(SWIGTYPE_p_wxDC, obj);
17126 Py_INCREF(obj);
17127 return Py_BuildValue((char *)"");
17128 }
17129 static PyObject *_wrap_new_MemoryDC(PyObject *, PyObject *args, PyObject *kwargs) {
17130 PyObject *resultobj;
17131 wxMemoryDC *result;
17132 char *kwnames[] = {
17133 NULL
17134 };
17135
17136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryDC",kwnames)) goto fail;
17137 {
17138 if (!wxPyCheckForApp()) SWIG_fail;
17139 PyThreadState* __tstate = wxPyBeginAllowThreads();
17140 result = (wxMemoryDC *)new wxMemoryDC();
17141
17142 wxPyEndAllowThreads(__tstate);
17143 if (PyErr_Occurred()) SWIG_fail;
17144 }
17145 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17146 return resultobj;
17147 fail:
17148 return NULL;
17149 }
17150
17151
17152 static PyObject *_wrap_new_MemoryDCFromDC(PyObject *, PyObject *args, PyObject *kwargs) {
17153 PyObject *resultobj;
17154 wxDC *arg1 = (wxDC *) 0 ;
17155 wxMemoryDC *result;
17156 PyObject * obj0 = 0 ;
17157 char *kwnames[] = {
17158 (char *) "oldDC", NULL
17159 };
17160
17161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_MemoryDCFromDC",kwnames,&obj0)) goto fail;
17162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17163 if (SWIG_arg_fail(1)) SWIG_fail;
17164 {
17165 if (!wxPyCheckForApp()) SWIG_fail;
17166 PyThreadState* __tstate = wxPyBeginAllowThreads();
17167 result = (wxMemoryDC *)new wxMemoryDC(arg1);
17168
17169 wxPyEndAllowThreads(__tstate);
17170 if (PyErr_Occurred()) SWIG_fail;
17171 }
17172 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17173 return resultobj;
17174 fail:
17175 return NULL;
17176 }
17177
17178
17179 static PyObject *_wrap_MemoryDC_SelectObject(PyObject *, PyObject *args, PyObject *kwargs) {
17180 PyObject *resultobj;
17181 wxMemoryDC *arg1 = (wxMemoryDC *) 0 ;
17182 wxBitmap *arg2 = 0 ;
17183 PyObject * obj0 = 0 ;
17184 PyObject * obj1 = 0 ;
17185 char *kwnames[] = {
17186 (char *) "self",(char *) "bitmap", NULL
17187 };
17188
17189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryDC_SelectObject",kwnames,&obj0,&obj1)) goto fail;
17190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryDC, SWIG_POINTER_EXCEPTION | 0);
17191 if (SWIG_arg_fail(1)) SWIG_fail;
17192 {
17193 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17194 if (SWIG_arg_fail(2)) SWIG_fail;
17195 if (arg2 == NULL) {
17196 SWIG_null_ref("wxBitmap");
17197 }
17198 if (SWIG_arg_fail(2)) SWIG_fail;
17199 }
17200 {
17201 PyThreadState* __tstate = wxPyBeginAllowThreads();
17202 (arg1)->SelectObject((wxBitmap const &)*arg2);
17203
17204 wxPyEndAllowThreads(__tstate);
17205 if (PyErr_Occurred()) SWIG_fail;
17206 }
17207 Py_INCREF(Py_None); resultobj = Py_None;
17208 return resultobj;
17209 fail:
17210 return NULL;
17211 }
17212
17213
17214 static PyObject * MemoryDC_swigregister(PyObject *, PyObject *args) {
17215 PyObject *obj;
17216 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17217 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryDC, obj);
17218 Py_INCREF(obj);
17219 return Py_BuildValue((char *)"");
17220 }
17221 static PyObject *_wrap_new_BufferedDC__SWIG_0(PyObject *, PyObject *args) {
17222 PyObject *resultobj;
17223 wxDC *arg1 = (wxDC *) 0 ;
17224 wxBitmap *arg2 = 0 ;
17225 wxBufferedDC *result;
17226 PyObject * obj0 = 0 ;
17227 PyObject * obj1 = 0 ;
17228
17229 if(!PyArg_ParseTuple(args,(char *)"OO:new_BufferedDC",&obj0,&obj1)) goto fail;
17230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17231 if (SWIG_arg_fail(1)) SWIG_fail;
17232 {
17233 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17234 if (SWIG_arg_fail(2)) SWIG_fail;
17235 if (arg2 == NULL) {
17236 SWIG_null_ref("wxBitmap");
17237 }
17238 if (SWIG_arg_fail(2)) SWIG_fail;
17239 }
17240 {
17241 if (!wxPyCheckForApp()) SWIG_fail;
17242 PyThreadState* __tstate = wxPyBeginAllowThreads();
17243 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxBitmap const &)*arg2);
17244
17245 wxPyEndAllowThreads(__tstate);
17246 if (PyErr_Occurred()) SWIG_fail;
17247 }
17248 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
17249 return resultobj;
17250 fail:
17251 return NULL;
17252 }
17253
17254
17255 static PyObject *_wrap_new_BufferedDC__SWIG_1(PyObject *, PyObject *args) {
17256 PyObject *resultobj;
17257 wxDC *arg1 = (wxDC *) 0 ;
17258 wxSize *arg2 = 0 ;
17259 wxBufferedDC *result;
17260 wxSize temp2 ;
17261 PyObject * obj0 = 0 ;
17262 PyObject * obj1 = 0 ;
17263
17264 if(!PyArg_ParseTuple(args,(char *)"OO:new_BufferedDC",&obj0,&obj1)) goto fail;
17265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17266 if (SWIG_arg_fail(1)) SWIG_fail;
17267 {
17268 arg2 = &temp2;
17269 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
17270 }
17271 {
17272 if (!wxPyCheckForApp()) SWIG_fail;
17273 PyThreadState* __tstate = wxPyBeginAllowThreads();
17274 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxSize const &)*arg2);
17275
17276 wxPyEndAllowThreads(__tstate);
17277 if (PyErr_Occurred()) SWIG_fail;
17278 }
17279 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
17280 return resultobj;
17281 fail:
17282 return NULL;
17283 }
17284
17285
17286 static PyObject *_wrap_new_BufferedDC(PyObject *self, PyObject *args) {
17287 int argc;
17288 PyObject *argv[3];
17289 int ii;
17290
17291 argc = PyObject_Length(args);
17292 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
17293 argv[ii] = PyTuple_GetItem(args,ii);
17294 }
17295 if (argc == 2) {
17296 int _v;
17297 {
17298 void *ptr;
17299 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
17300 _v = 0;
17301 PyErr_Clear();
17302 } else {
17303 _v = 1;
17304 }
17305 }
17306 if (_v) {
17307 {
17308 void *ptr = 0;
17309 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxBitmap, 0) == -1) {
17310 _v = 0;
17311 PyErr_Clear();
17312 } else {
17313 _v = (ptr != 0);
17314 }
17315 }
17316 if (_v) {
17317 return _wrap_new_BufferedDC__SWIG_0(self,args);
17318 }
17319 }
17320 }
17321 if (argc == 2) {
17322 int _v;
17323 {
17324 void *ptr;
17325 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
17326 _v = 0;
17327 PyErr_Clear();
17328 } else {
17329 _v = 1;
17330 }
17331 }
17332 if (_v) {
17333 {
17334 _v = wxPySimple_typecheck(argv[1], wxT("wxSize"), 2);
17335 }
17336 if (_v) {
17337 return _wrap_new_BufferedDC__SWIG_1(self,args);
17338 }
17339 }
17340 }
17341
17342 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_BufferedDC'");
17343 return NULL;
17344 }
17345
17346
17347 static PyObject *_wrap_delete_BufferedDC(PyObject *, PyObject *args, PyObject *kwargs) {
17348 PyObject *resultobj;
17349 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
17350 PyObject * obj0 = 0 ;
17351 char *kwnames[] = {
17352 (char *) "self", NULL
17353 };
17354
17355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BufferedDC",kwnames,&obj0)) goto fail;
17356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
17357 if (SWIG_arg_fail(1)) SWIG_fail;
17358 {
17359 PyThreadState* __tstate = wxPyBeginAllowThreads();
17360 delete arg1;
17361
17362 wxPyEndAllowThreads(__tstate);
17363 if (PyErr_Occurred()) SWIG_fail;
17364 }
17365 Py_INCREF(Py_None); resultobj = Py_None;
17366 return resultobj;
17367 fail:
17368 return NULL;
17369 }
17370
17371
17372 static PyObject *_wrap_BufferedDC_UnMask(PyObject *, PyObject *args, PyObject *kwargs) {
17373 PyObject *resultobj;
17374 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
17375 PyObject * obj0 = 0 ;
17376 char *kwnames[] = {
17377 (char *) "self", NULL
17378 };
17379
17380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BufferedDC_UnMask",kwnames,&obj0)) goto fail;
17381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
17382 if (SWIG_arg_fail(1)) SWIG_fail;
17383 {
17384 PyThreadState* __tstate = wxPyBeginAllowThreads();
17385 (arg1)->UnMask();
17386
17387 wxPyEndAllowThreads(__tstate);
17388 if (PyErr_Occurred()) SWIG_fail;
17389 }
17390 Py_INCREF(Py_None); resultobj = Py_None;
17391 return resultobj;
17392 fail:
17393 return NULL;
17394 }
17395
17396
17397 static PyObject * BufferedDC_swigregister(PyObject *, PyObject *args) {
17398 PyObject *obj;
17399 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17400 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedDC, obj);
17401 Py_INCREF(obj);
17402 return Py_BuildValue((char *)"");
17403 }
17404 static PyObject *_wrap_new_BufferedPaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
17405 PyObject *resultobj;
17406 wxWindow *arg1 = (wxWindow *) 0 ;
17407 wxBitmap const &arg2_defvalue = wxNullBitmap ;
17408 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
17409 wxBufferedPaintDC *result;
17410 PyObject * obj0 = 0 ;
17411 PyObject * obj1 = 0 ;
17412 char *kwnames[] = {
17413 (char *) "window",(char *) "buffer", NULL
17414 };
17415
17416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BufferedPaintDC",kwnames,&obj0,&obj1)) goto fail;
17417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17418 if (SWIG_arg_fail(1)) SWIG_fail;
17419 if (obj1) {
17420 {
17421 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17422 if (SWIG_arg_fail(2)) SWIG_fail;
17423 if (arg2 == NULL) {
17424 SWIG_null_ref("wxBitmap");
17425 }
17426 if (SWIG_arg_fail(2)) SWIG_fail;
17427 }
17428 }
17429 {
17430 if (!wxPyCheckForApp()) SWIG_fail;
17431 PyThreadState* __tstate = wxPyBeginAllowThreads();
17432 result = (wxBufferedPaintDC *)new wxBufferedPaintDC(arg1,(wxBitmap const &)*arg2);
17433
17434 wxPyEndAllowThreads(__tstate);
17435 if (PyErr_Occurred()) SWIG_fail;
17436 }
17437 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedPaintDC, 1);
17438 return resultobj;
17439 fail:
17440 return NULL;
17441 }
17442
17443
17444 static PyObject * BufferedPaintDC_swigregister(PyObject *, PyObject *args) {
17445 PyObject *obj;
17446 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17447 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedPaintDC, obj);
17448 Py_INCREF(obj);
17449 return Py_BuildValue((char *)"");
17450 }
17451 static PyObject *_wrap_new_ScreenDC(PyObject *, PyObject *args, PyObject *kwargs) {
17452 PyObject *resultobj;
17453 wxScreenDC *result;
17454 char *kwnames[] = {
17455 NULL
17456 };
17457
17458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ScreenDC",kwnames)) goto fail;
17459 {
17460 if (!wxPyCheckForApp()) SWIG_fail;
17461 PyThreadState* __tstate = wxPyBeginAllowThreads();
17462 result = (wxScreenDC *)new wxScreenDC();
17463
17464 wxPyEndAllowThreads(__tstate);
17465 if (PyErr_Occurred()) SWIG_fail;
17466 }
17467 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScreenDC, 1);
17468 return resultobj;
17469 fail:
17470 return NULL;
17471 }
17472
17473
17474 static PyObject *_wrap_ScreenDC_StartDrawingOnTopWin(PyObject *, PyObject *args, PyObject *kwargs) {
17475 PyObject *resultobj;
17476 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17477 wxWindow *arg2 = (wxWindow *) 0 ;
17478 bool result;
17479 PyObject * obj0 = 0 ;
17480 PyObject * obj1 = 0 ;
17481 char *kwnames[] = {
17482 (char *) "self",(char *) "window", NULL
17483 };
17484
17485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScreenDC_StartDrawingOnTopWin",kwnames,&obj0,&obj1)) goto fail;
17486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17487 if (SWIG_arg_fail(1)) SWIG_fail;
17488 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17489 if (SWIG_arg_fail(2)) SWIG_fail;
17490 {
17491 PyThreadState* __tstate = wxPyBeginAllowThreads();
17492 result = (bool)(arg1)->StartDrawingOnTop(arg2);
17493
17494 wxPyEndAllowThreads(__tstate);
17495 if (PyErr_Occurred()) SWIG_fail;
17496 }
17497 {
17498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17499 }
17500 return resultobj;
17501 fail:
17502 return NULL;
17503 }
17504
17505
17506 static PyObject *_wrap_ScreenDC_StartDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
17507 PyObject *resultobj;
17508 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17509 wxRect *arg2 = (wxRect *) NULL ;
17510 bool result;
17511 PyObject * obj0 = 0 ;
17512 PyObject * obj1 = 0 ;
17513 char *kwnames[] = {
17514 (char *) "self",(char *) "rect", NULL
17515 };
17516
17517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ScreenDC_StartDrawingOnTop",kwnames,&obj0,&obj1)) goto fail;
17518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17519 if (SWIG_arg_fail(1)) SWIG_fail;
17520 if (obj1) {
17521 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
17522 if (SWIG_arg_fail(2)) SWIG_fail;
17523 }
17524 {
17525 PyThreadState* __tstate = wxPyBeginAllowThreads();
17526 result = (bool)(arg1)->StartDrawingOnTop(arg2);
17527
17528 wxPyEndAllowThreads(__tstate);
17529 if (PyErr_Occurred()) SWIG_fail;
17530 }
17531 {
17532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17533 }
17534 return resultobj;
17535 fail:
17536 return NULL;
17537 }
17538
17539
17540 static PyObject *_wrap_ScreenDC_EndDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
17541 PyObject *resultobj;
17542 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17543 bool result;
17544 PyObject * obj0 = 0 ;
17545 char *kwnames[] = {
17546 (char *) "self", NULL
17547 };
17548
17549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScreenDC_EndDrawingOnTop",kwnames,&obj0)) goto fail;
17550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17551 if (SWIG_arg_fail(1)) SWIG_fail;
17552 {
17553 PyThreadState* __tstate = wxPyBeginAllowThreads();
17554 result = (bool)(arg1)->EndDrawingOnTop();
17555
17556 wxPyEndAllowThreads(__tstate);
17557 if (PyErr_Occurred()) SWIG_fail;
17558 }
17559 {
17560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17561 }
17562 return resultobj;
17563 fail:
17564 return NULL;
17565 }
17566
17567
17568 static PyObject * ScreenDC_swigregister(PyObject *, PyObject *args) {
17569 PyObject *obj;
17570 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17571 SWIG_TypeClientData(SWIGTYPE_p_wxScreenDC, obj);
17572 Py_INCREF(obj);
17573 return Py_BuildValue((char *)"");
17574 }
17575 static PyObject *_wrap_new_ClientDC(PyObject *, PyObject *args, PyObject *kwargs) {
17576 PyObject *resultobj;
17577 wxWindow *arg1 = (wxWindow *) 0 ;
17578 wxClientDC *result;
17579 PyObject * obj0 = 0 ;
17580 char *kwnames[] = {
17581 (char *) "win", NULL
17582 };
17583
17584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ClientDC",kwnames,&obj0)) goto fail;
17585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17586 if (SWIG_arg_fail(1)) SWIG_fail;
17587 {
17588 if (!wxPyCheckForApp()) SWIG_fail;
17589 PyThreadState* __tstate = wxPyBeginAllowThreads();
17590 result = (wxClientDC *)new wxClientDC(arg1);
17591
17592 wxPyEndAllowThreads(__tstate);
17593 if (PyErr_Occurred()) SWIG_fail;
17594 }
17595 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClientDC, 1);
17596 return resultobj;
17597 fail:
17598 return NULL;
17599 }
17600
17601
17602 static PyObject * ClientDC_swigregister(PyObject *, PyObject *args) {
17603 PyObject *obj;
17604 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17605 SWIG_TypeClientData(SWIGTYPE_p_wxClientDC, obj);
17606 Py_INCREF(obj);
17607 return Py_BuildValue((char *)"");
17608 }
17609 static PyObject *_wrap_new_PaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
17610 PyObject *resultobj;
17611 wxWindow *arg1 = (wxWindow *) 0 ;
17612 wxPaintDC *result;
17613 PyObject * obj0 = 0 ;
17614 char *kwnames[] = {
17615 (char *) "win", NULL
17616 };
17617
17618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PaintDC",kwnames,&obj0)) goto fail;
17619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17620 if (SWIG_arg_fail(1)) SWIG_fail;
17621 {
17622 if (!wxPyCheckForApp()) SWIG_fail;
17623 PyThreadState* __tstate = wxPyBeginAllowThreads();
17624 result = (wxPaintDC *)new wxPaintDC(arg1);
17625
17626 wxPyEndAllowThreads(__tstate);
17627 if (PyErr_Occurred()) SWIG_fail;
17628 }
17629 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintDC, 1);
17630 return resultobj;
17631 fail:
17632 return NULL;
17633 }
17634
17635
17636 static PyObject * PaintDC_swigregister(PyObject *, PyObject *args) {
17637 PyObject *obj;
17638 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17639 SWIG_TypeClientData(SWIGTYPE_p_wxPaintDC, obj);
17640 Py_INCREF(obj);
17641 return Py_BuildValue((char *)"");
17642 }
17643 static PyObject *_wrap_new_WindowDC(PyObject *, PyObject *args, PyObject *kwargs) {
17644 PyObject *resultobj;
17645 wxWindow *arg1 = (wxWindow *) 0 ;
17646 wxWindowDC *result;
17647 PyObject * obj0 = 0 ;
17648 char *kwnames[] = {
17649 (char *) "win", NULL
17650 };
17651
17652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_WindowDC",kwnames,&obj0)) goto fail;
17653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17654 if (SWIG_arg_fail(1)) SWIG_fail;
17655 {
17656 if (!wxPyCheckForApp()) SWIG_fail;
17657 PyThreadState* __tstate = wxPyBeginAllowThreads();
17658 result = (wxWindowDC *)new wxWindowDC(arg1);
17659
17660 wxPyEndAllowThreads(__tstate);
17661 if (PyErr_Occurred()) SWIG_fail;
17662 }
17663 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDC, 1);
17664 return resultobj;
17665 fail:
17666 return NULL;
17667 }
17668
17669
17670 static PyObject * WindowDC_swigregister(PyObject *, PyObject *args) {
17671 PyObject *obj;
17672 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17673 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDC, obj);
17674 Py_INCREF(obj);
17675 return Py_BuildValue((char *)"");
17676 }
17677 static PyObject *_wrap_new_MirrorDC(PyObject *, PyObject *args, PyObject *kwargs) {
17678 PyObject *resultobj;
17679 wxDC *arg1 = 0 ;
17680 bool arg2 ;
17681 wxMirrorDC *result;
17682 PyObject * obj0 = 0 ;
17683 PyObject * obj1 = 0 ;
17684 char *kwnames[] = {
17685 (char *) "dc",(char *) "mirror", NULL
17686 };
17687
17688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_MirrorDC",kwnames,&obj0,&obj1)) goto fail;
17689 {
17690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17691 if (SWIG_arg_fail(1)) SWIG_fail;
17692 if (arg1 == NULL) {
17693 SWIG_null_ref("wxDC");
17694 }
17695 if (SWIG_arg_fail(1)) SWIG_fail;
17696 }
17697 {
17698 arg2 = (bool)(SWIG_As_bool(obj1));
17699 if (SWIG_arg_fail(2)) SWIG_fail;
17700 }
17701 {
17702 if (!wxPyCheckForApp()) SWIG_fail;
17703 PyThreadState* __tstate = wxPyBeginAllowThreads();
17704 result = (wxMirrorDC *)new wxMirrorDC(*arg1,arg2);
17705
17706 wxPyEndAllowThreads(__tstate);
17707 if (PyErr_Occurred()) SWIG_fail;
17708 }
17709 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMirrorDC, 1);
17710 return resultobj;
17711 fail:
17712 return NULL;
17713 }
17714
17715
17716 static PyObject * MirrorDC_swigregister(PyObject *, PyObject *args) {
17717 PyObject *obj;
17718 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17719 SWIG_TypeClientData(SWIGTYPE_p_wxMirrorDC, obj);
17720 Py_INCREF(obj);
17721 return Py_BuildValue((char *)"");
17722 }
17723 static PyObject *_wrap_new_PostScriptDC(PyObject *, PyObject *args, PyObject *kwargs) {
17724 PyObject *resultobj;
17725 wxPrintData *arg1 = 0 ;
17726 wxPostScriptDC *result;
17727 PyObject * obj0 = 0 ;
17728 char *kwnames[] = {
17729 (char *) "printData", NULL
17730 };
17731
17732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PostScriptDC",kwnames,&obj0)) goto fail;
17733 {
17734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
17735 if (SWIG_arg_fail(1)) SWIG_fail;
17736 if (arg1 == NULL) {
17737 SWIG_null_ref("wxPrintData");
17738 }
17739 if (SWIG_arg_fail(1)) SWIG_fail;
17740 }
17741 {
17742 if (!wxPyCheckForApp()) SWIG_fail;
17743 PyThreadState* __tstate = wxPyBeginAllowThreads();
17744 result = (wxPostScriptDC *)new wxPostScriptDC((wxPrintData const &)*arg1);
17745
17746 wxPyEndAllowThreads(__tstate);
17747 if (PyErr_Occurred()) SWIG_fail;
17748 }
17749 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPostScriptDC, 1);
17750 return resultobj;
17751 fail:
17752 return NULL;
17753 }
17754
17755
17756 static PyObject *_wrap_PostScriptDC_GetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
17757 PyObject *resultobj;
17758 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
17759 wxPrintData *result;
17760 PyObject * obj0 = 0 ;
17761 char *kwnames[] = {
17762 (char *) "self", NULL
17763 };
17764
17765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_GetPrintData",kwnames,&obj0)) goto fail;
17766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
17767 if (SWIG_arg_fail(1)) SWIG_fail;
17768 {
17769 PyThreadState* __tstate = wxPyBeginAllowThreads();
17770 {
17771 wxPrintData &_result_ref = (arg1)->GetPrintData();
17772 result = (wxPrintData *) &_result_ref;
17773 }
17774
17775 wxPyEndAllowThreads(__tstate);
17776 if (PyErr_Occurred()) SWIG_fail;
17777 }
17778 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 0);
17779 return resultobj;
17780 fail:
17781 return NULL;
17782 }
17783
17784
17785 static PyObject *_wrap_PostScriptDC_SetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
17786 PyObject *resultobj;
17787 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
17788 wxPrintData *arg2 = 0 ;
17789 PyObject * obj0 = 0 ;
17790 PyObject * obj1 = 0 ;
17791 char *kwnames[] = {
17792 (char *) "self",(char *) "data", NULL
17793 };
17794
17795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostScriptDC_SetPrintData",kwnames,&obj0,&obj1)) goto fail;
17796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
17797 if (SWIG_arg_fail(1)) SWIG_fail;
17798 {
17799 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
17800 if (SWIG_arg_fail(2)) SWIG_fail;
17801 if (arg2 == NULL) {
17802 SWIG_null_ref("wxPrintData");
17803 }
17804 if (SWIG_arg_fail(2)) SWIG_fail;
17805 }
17806 {
17807 PyThreadState* __tstate = wxPyBeginAllowThreads();
17808 (arg1)->SetPrintData((wxPrintData const &)*arg2);
17809
17810 wxPyEndAllowThreads(__tstate);
17811 if (PyErr_Occurred()) SWIG_fail;
17812 }
17813 Py_INCREF(Py_None); resultobj = Py_None;
17814 return resultobj;
17815 fail:
17816 return NULL;
17817 }
17818
17819
17820 static PyObject *_wrap_PostScriptDC_SetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
17821 PyObject *resultobj;
17822 int arg1 ;
17823 PyObject * obj0 = 0 ;
17824 char *kwnames[] = {
17825 (char *) "ppi", NULL
17826 };
17827
17828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_SetResolution",kwnames,&obj0)) goto fail;
17829 {
17830 arg1 = (int)(SWIG_As_int(obj0));
17831 if (SWIG_arg_fail(1)) SWIG_fail;
17832 }
17833 {
17834 PyThreadState* __tstate = wxPyBeginAllowThreads();
17835 wxPostScriptDC::SetResolution(arg1);
17836
17837 wxPyEndAllowThreads(__tstate);
17838 if (PyErr_Occurred()) SWIG_fail;
17839 }
17840 Py_INCREF(Py_None); resultobj = Py_None;
17841 return resultobj;
17842 fail:
17843 return NULL;
17844 }
17845
17846
17847 static PyObject *_wrap_PostScriptDC_GetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
17848 PyObject *resultobj;
17849 int result;
17850 char *kwnames[] = {
17851 NULL
17852 };
17853
17854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PostScriptDC_GetResolution",kwnames)) goto fail;
17855 {
17856 PyThreadState* __tstate = wxPyBeginAllowThreads();
17857 result = (int)wxPostScriptDC::GetResolution();
17858
17859 wxPyEndAllowThreads(__tstate);
17860 if (PyErr_Occurred()) SWIG_fail;
17861 }
17862 {
17863 resultobj = SWIG_From_int((int)(result));
17864 }
17865 return resultobj;
17866 fail:
17867 return NULL;
17868 }
17869
17870
17871 static PyObject * PostScriptDC_swigregister(PyObject *, PyObject *args) {
17872 PyObject *obj;
17873 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17874 SWIG_TypeClientData(SWIGTYPE_p_wxPostScriptDC, obj);
17875 Py_INCREF(obj);
17876 return Py_BuildValue((char *)"");
17877 }
17878 static PyObject *_wrap_new_MetaFile(PyObject *, PyObject *args, PyObject *kwargs) {
17879 PyObject *resultobj;
17880 wxString const &arg1_defvalue = wxPyEmptyString ;
17881 wxString *arg1 = (wxString *) &arg1_defvalue ;
17882 wxMetaFile *result;
17883 bool temp1 = false ;
17884 PyObject * obj0 = 0 ;
17885 char *kwnames[] = {
17886 (char *) "filename", NULL
17887 };
17888
17889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MetaFile",kwnames,&obj0)) goto fail;
17890 if (obj0) {
17891 {
17892 arg1 = wxString_in_helper(obj0);
17893 if (arg1 == NULL) SWIG_fail;
17894 temp1 = true;
17895 }
17896 }
17897 {
17898 if (!wxPyCheckForApp()) SWIG_fail;
17899 PyThreadState* __tstate = wxPyBeginAllowThreads();
17900 result = (wxMetaFile *)new wxMetaFile((wxString const &)*arg1);
17901
17902 wxPyEndAllowThreads(__tstate);
17903 if (PyErr_Occurred()) SWIG_fail;
17904 }
17905 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFile, 1);
17906 {
17907 if (temp1)
17908 delete arg1;
17909 }
17910 return resultobj;
17911 fail:
17912 {
17913 if (temp1)
17914 delete arg1;
17915 }
17916 return NULL;
17917 }
17918
17919
17920 static PyObject * MetaFile_swigregister(PyObject *, PyObject *args) {
17921 PyObject *obj;
17922 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17923 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFile, obj);
17924 Py_INCREF(obj);
17925 return Py_BuildValue((char *)"");
17926 }
17927 static PyObject *_wrap_new_MetaFileDC(PyObject *, PyObject *args, PyObject *kwargs) {
17928 PyObject *resultobj;
17929 wxString const &arg1_defvalue = wxPyEmptyString ;
17930 wxString *arg1 = (wxString *) &arg1_defvalue ;
17931 int arg2 = (int) 0 ;
17932 int arg3 = (int) 0 ;
17933 wxString const &arg4_defvalue = wxPyEmptyString ;
17934 wxString *arg4 = (wxString *) &arg4_defvalue ;
17935 wxMetaFileDC *result;
17936 bool temp1 = false ;
17937 bool temp4 = false ;
17938 PyObject * obj0 = 0 ;
17939 PyObject * obj1 = 0 ;
17940 PyObject * obj2 = 0 ;
17941 PyObject * obj3 = 0 ;
17942 char *kwnames[] = {
17943 (char *) "filename",(char *) "width",(char *) "height",(char *) "description", NULL
17944 };
17945
17946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_MetaFileDC",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17947 if (obj0) {
17948 {
17949 arg1 = wxString_in_helper(obj0);
17950 if (arg1 == NULL) SWIG_fail;
17951 temp1 = true;
17952 }
17953 }
17954 if (obj1) {
17955 {
17956 arg2 = (int)(SWIG_As_int(obj1));
17957 if (SWIG_arg_fail(2)) SWIG_fail;
17958 }
17959 }
17960 if (obj2) {
17961 {
17962 arg3 = (int)(SWIG_As_int(obj2));
17963 if (SWIG_arg_fail(3)) SWIG_fail;
17964 }
17965 }
17966 if (obj3) {
17967 {
17968 arg4 = wxString_in_helper(obj3);
17969 if (arg4 == NULL) SWIG_fail;
17970 temp4 = true;
17971 }
17972 }
17973 {
17974 if (!wxPyCheckForApp()) SWIG_fail;
17975 PyThreadState* __tstate = wxPyBeginAllowThreads();
17976 result = (wxMetaFileDC *)new wxMetaFileDC((wxString const &)*arg1,arg2,arg3,(wxString const &)*arg4);
17977
17978 wxPyEndAllowThreads(__tstate);
17979 if (PyErr_Occurred()) SWIG_fail;
17980 }
17981 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFileDC, 1);
17982 {
17983 if (temp1)
17984 delete arg1;
17985 }
17986 {
17987 if (temp4)
17988 delete arg4;
17989 }
17990 return resultobj;
17991 fail:
17992 {
17993 if (temp1)
17994 delete arg1;
17995 }
17996 {
17997 if (temp4)
17998 delete arg4;
17999 }
18000 return NULL;
18001 }
18002
18003
18004 static PyObject * MetaFileDC_swigregister(PyObject *, PyObject *args) {
18005 PyObject *obj;
18006 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18007 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFileDC, obj);
18008 Py_INCREF(obj);
18009 return Py_BuildValue((char *)"");
18010 }
18011 static PyObject *_wrap_new_PrinterDC(PyObject *, PyObject *args, PyObject *kwargs) {
18012 PyObject *resultobj;
18013 wxPrintData *arg1 = 0 ;
18014 wxPrinterDC *result;
18015 PyObject * obj0 = 0 ;
18016 char *kwnames[] = {
18017 (char *) "printData", NULL
18018 };
18019
18020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PrinterDC",kwnames,&obj0)) goto fail;
18021 {
18022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
18023 if (SWIG_arg_fail(1)) SWIG_fail;
18024 if (arg1 == NULL) {
18025 SWIG_null_ref("wxPrintData");
18026 }
18027 if (SWIG_arg_fail(1)) SWIG_fail;
18028 }
18029 {
18030 if (!wxPyCheckForApp()) SWIG_fail;
18031 PyThreadState* __tstate = wxPyBeginAllowThreads();
18032 result = (wxPrinterDC *)new wxPrinterDC((wxPrintData const &)*arg1);
18033
18034 wxPyEndAllowThreads(__tstate);
18035 if (PyErr_Occurred()) SWIG_fail;
18036 }
18037 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrinterDC, 1);
18038 return resultobj;
18039 fail:
18040 return NULL;
18041 }
18042
18043
18044 static PyObject * PrinterDC_swigregister(PyObject *, PyObject *args) {
18045 PyObject *obj;
18046 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18047 SWIG_TypeClientData(SWIGTYPE_p_wxPrinterDC, obj);
18048 Py_INCREF(obj);
18049 return Py_BuildValue((char *)"");
18050 }
18051 static PyObject *_wrap_new_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
18052 PyObject *resultobj;
18053 int arg1 ;
18054 int arg2 ;
18055 int arg3 = (int) true ;
18056 int arg4 = (int) 1 ;
18057 wxImageList *result;
18058 PyObject * obj0 = 0 ;
18059 PyObject * obj1 = 0 ;
18060 PyObject * obj2 = 0 ;
18061 PyObject * obj3 = 0 ;
18062 char *kwnames[] = {
18063 (char *) "width",(char *) "height",(char *) "mask",(char *) "initialCount", NULL
18064 };
18065
18066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_ImageList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
18067 {
18068 arg1 = (int)(SWIG_As_int(obj0));
18069 if (SWIG_arg_fail(1)) SWIG_fail;
18070 }
18071 {
18072 arg2 = (int)(SWIG_As_int(obj1));
18073 if (SWIG_arg_fail(2)) SWIG_fail;
18074 }
18075 if (obj2) {
18076 {
18077 arg3 = (int)(SWIG_As_int(obj2));
18078 if (SWIG_arg_fail(3)) SWIG_fail;
18079 }
18080 }
18081 if (obj3) {
18082 {
18083 arg4 = (int)(SWIG_As_int(obj3));
18084 if (SWIG_arg_fail(4)) SWIG_fail;
18085 }
18086 }
18087 {
18088 if (!wxPyCheckForApp()) SWIG_fail;
18089 PyThreadState* __tstate = wxPyBeginAllowThreads();
18090 result = (wxImageList *)new wxImageList(arg1,arg2,arg3,arg4);
18091
18092 wxPyEndAllowThreads(__tstate);
18093 if (PyErr_Occurred()) SWIG_fail;
18094 }
18095 {
18096 resultobj = wxPyMake_wxObject(result, 1);
18097 }
18098 return resultobj;
18099 fail:
18100 return NULL;
18101 }
18102
18103
18104 static PyObject *_wrap_delete_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
18105 PyObject *resultobj;
18106 wxImageList *arg1 = (wxImageList *) 0 ;
18107 PyObject * obj0 = 0 ;
18108 char *kwnames[] = {
18109 (char *) "self", NULL
18110 };
18111
18112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ImageList",kwnames,&obj0)) goto fail;
18113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18114 if (SWIG_arg_fail(1)) SWIG_fail;
18115 {
18116 PyThreadState* __tstate = wxPyBeginAllowThreads();
18117 delete arg1;
18118
18119 wxPyEndAllowThreads(__tstate);
18120 if (PyErr_Occurred()) SWIG_fail;
18121 }
18122 Py_INCREF(Py_None); resultobj = Py_None;
18123 return resultobj;
18124 fail:
18125 return NULL;
18126 }
18127
18128
18129 static PyObject *_wrap_ImageList_Add(PyObject *, PyObject *args, PyObject *kwargs) {
18130 PyObject *resultobj;
18131 wxImageList *arg1 = (wxImageList *) 0 ;
18132 wxBitmap *arg2 = 0 ;
18133 wxBitmap const &arg3_defvalue = wxNullBitmap ;
18134 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
18135 int result;
18136 PyObject * obj0 = 0 ;
18137 PyObject * obj1 = 0 ;
18138 PyObject * obj2 = 0 ;
18139 char *kwnames[] = {
18140 (char *) "self",(char *) "bitmap",(char *) "mask", NULL
18141 };
18142
18143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ImageList_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
18144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18145 if (SWIG_arg_fail(1)) SWIG_fail;
18146 {
18147 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18148 if (SWIG_arg_fail(2)) SWIG_fail;
18149 if (arg2 == NULL) {
18150 SWIG_null_ref("wxBitmap");
18151 }
18152 if (SWIG_arg_fail(2)) SWIG_fail;
18153 }
18154 if (obj2) {
18155 {
18156 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18157 if (SWIG_arg_fail(3)) SWIG_fail;
18158 if (arg3 == NULL) {
18159 SWIG_null_ref("wxBitmap");
18160 }
18161 if (SWIG_arg_fail(3)) SWIG_fail;
18162 }
18163 }
18164 {
18165 PyThreadState* __tstate = wxPyBeginAllowThreads();
18166 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
18167
18168 wxPyEndAllowThreads(__tstate);
18169 if (PyErr_Occurred()) SWIG_fail;
18170 }
18171 {
18172 resultobj = SWIG_From_int((int)(result));
18173 }
18174 return resultobj;
18175 fail:
18176 return NULL;
18177 }
18178
18179
18180 static PyObject *_wrap_ImageList_AddWithColourMask(PyObject *, PyObject *args, PyObject *kwargs) {
18181 PyObject *resultobj;
18182 wxImageList *arg1 = (wxImageList *) 0 ;
18183 wxBitmap *arg2 = 0 ;
18184 wxColour *arg3 = 0 ;
18185 int result;
18186 wxColour temp3 ;
18187 PyObject * obj0 = 0 ;
18188 PyObject * obj1 = 0 ;
18189 PyObject * obj2 = 0 ;
18190 char *kwnames[] = {
18191 (char *) "self",(char *) "bitmap",(char *) "maskColour", NULL
18192 };
18193
18194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_AddWithColourMask",kwnames,&obj0,&obj1,&obj2)) goto fail;
18195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18196 if (SWIG_arg_fail(1)) SWIG_fail;
18197 {
18198 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18199 if (SWIG_arg_fail(2)) SWIG_fail;
18200 if (arg2 == NULL) {
18201 SWIG_null_ref("wxBitmap");
18202 }
18203 if (SWIG_arg_fail(2)) SWIG_fail;
18204 }
18205 {
18206 arg3 = &temp3;
18207 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
18208 }
18209 {
18210 PyThreadState* __tstate = wxPyBeginAllowThreads();
18211 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxColour const &)*arg3);
18212
18213 wxPyEndAllowThreads(__tstate);
18214 if (PyErr_Occurred()) SWIG_fail;
18215 }
18216 {
18217 resultobj = SWIG_From_int((int)(result));
18218 }
18219 return resultobj;
18220 fail:
18221 return NULL;
18222 }
18223
18224
18225 static PyObject *_wrap_ImageList_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
18226 PyObject *resultobj;
18227 wxImageList *arg1 = (wxImageList *) 0 ;
18228 wxIcon *arg2 = 0 ;
18229 int result;
18230 PyObject * obj0 = 0 ;
18231 PyObject * obj1 = 0 ;
18232 char *kwnames[] = {
18233 (char *) "self",(char *) "icon", NULL
18234 };
18235
18236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_AddIcon",kwnames,&obj0,&obj1)) goto fail;
18237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18238 if (SWIG_arg_fail(1)) SWIG_fail;
18239 {
18240 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
18241 if (SWIG_arg_fail(2)) SWIG_fail;
18242 if (arg2 == NULL) {
18243 SWIG_null_ref("wxIcon");
18244 }
18245 if (SWIG_arg_fail(2)) SWIG_fail;
18246 }
18247 {
18248 PyThreadState* __tstate = wxPyBeginAllowThreads();
18249 result = (int)(arg1)->Add((wxIcon const &)*arg2);
18250
18251 wxPyEndAllowThreads(__tstate);
18252 if (PyErr_Occurred()) SWIG_fail;
18253 }
18254 {
18255 resultobj = SWIG_From_int((int)(result));
18256 }
18257 return resultobj;
18258 fail:
18259 return NULL;
18260 }
18261
18262
18263 static PyObject *_wrap_ImageList_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
18264 PyObject *resultobj;
18265 wxImageList *arg1 = (wxImageList *) 0 ;
18266 int arg2 ;
18267 SwigValueWrapper<wxBitmap > result;
18268 PyObject * obj0 = 0 ;
18269 PyObject * obj1 = 0 ;
18270 char *kwnames[] = {
18271 (char *) "self",(char *) "index", NULL
18272 };
18273
18274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetBitmap",kwnames,&obj0,&obj1)) goto fail;
18275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18276 if (SWIG_arg_fail(1)) SWIG_fail;
18277 {
18278 arg2 = (int)(SWIG_As_int(obj1));
18279 if (SWIG_arg_fail(2)) SWIG_fail;
18280 }
18281 {
18282 PyThreadState* __tstate = wxPyBeginAllowThreads();
18283 result = ((wxImageList const *)arg1)->GetBitmap(arg2);
18284
18285 wxPyEndAllowThreads(__tstate);
18286 if (PyErr_Occurred()) SWIG_fail;
18287 }
18288 {
18289 wxBitmap * resultptr;
18290 resultptr = new wxBitmap((wxBitmap &)(result));
18291 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
18292 }
18293 return resultobj;
18294 fail:
18295 return NULL;
18296 }
18297
18298
18299 static PyObject *_wrap_ImageList_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
18300 PyObject *resultobj;
18301 wxImageList *arg1 = (wxImageList *) 0 ;
18302 int arg2 ;
18303 wxIcon result;
18304 PyObject * obj0 = 0 ;
18305 PyObject * obj1 = 0 ;
18306 char *kwnames[] = {
18307 (char *) "self",(char *) "index", NULL
18308 };
18309
18310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetIcon",kwnames,&obj0,&obj1)) goto fail;
18311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18312 if (SWIG_arg_fail(1)) SWIG_fail;
18313 {
18314 arg2 = (int)(SWIG_As_int(obj1));
18315 if (SWIG_arg_fail(2)) SWIG_fail;
18316 }
18317 {
18318 PyThreadState* __tstate = wxPyBeginAllowThreads();
18319 result = ((wxImageList const *)arg1)->GetIcon(arg2);
18320
18321 wxPyEndAllowThreads(__tstate);
18322 if (PyErr_Occurred()) SWIG_fail;
18323 }
18324 {
18325 wxIcon * resultptr;
18326 resultptr = new wxIcon((wxIcon &)(result));
18327 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
18328 }
18329 return resultobj;
18330 fail:
18331 return NULL;
18332 }
18333
18334
18335 static PyObject *_wrap_ImageList_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
18336 PyObject *resultobj;
18337 wxImageList *arg1 = (wxImageList *) 0 ;
18338 int arg2 ;
18339 wxBitmap *arg3 = 0 ;
18340 bool result;
18341 PyObject * obj0 = 0 ;
18342 PyObject * obj1 = 0 ;
18343 PyObject * obj2 = 0 ;
18344 char *kwnames[] = {
18345 (char *) "self",(char *) "index",(char *) "bitmap", NULL
18346 };
18347
18348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_Replace",kwnames,&obj0,&obj1,&obj2)) goto fail;
18349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18350 if (SWIG_arg_fail(1)) SWIG_fail;
18351 {
18352 arg2 = (int)(SWIG_As_int(obj1));
18353 if (SWIG_arg_fail(2)) SWIG_fail;
18354 }
18355 {
18356 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18357 if (SWIG_arg_fail(3)) SWIG_fail;
18358 if (arg3 == NULL) {
18359 SWIG_null_ref("wxBitmap");
18360 }
18361 if (SWIG_arg_fail(3)) SWIG_fail;
18362 }
18363 {
18364 PyThreadState* __tstate = wxPyBeginAllowThreads();
18365 result = (bool)(arg1)->Replace(arg2,(wxBitmap const &)*arg3);
18366
18367 wxPyEndAllowThreads(__tstate);
18368 if (PyErr_Occurred()) SWIG_fail;
18369 }
18370 {
18371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18372 }
18373 return resultobj;
18374 fail:
18375 return NULL;
18376 }
18377
18378
18379 static PyObject *_wrap_ImageList_Draw(PyObject *, PyObject *args, PyObject *kwargs) {
18380 PyObject *resultobj;
18381 wxImageList *arg1 = (wxImageList *) 0 ;
18382 int arg2 ;
18383 wxDC *arg3 = 0 ;
18384 int arg4 ;
18385 int arg5 ;
18386 int arg6 = (int) wxIMAGELIST_DRAW_NORMAL ;
18387 bool arg7 = (bool) (bool)false ;
18388 bool result;
18389 PyObject * obj0 = 0 ;
18390 PyObject * obj1 = 0 ;
18391 PyObject * obj2 = 0 ;
18392 PyObject * obj3 = 0 ;
18393 PyObject * obj4 = 0 ;
18394 PyObject * obj5 = 0 ;
18395 PyObject * obj6 = 0 ;
18396 char *kwnames[] = {
18397 (char *) "self",(char *) "index",(char *) "dc",(char *) "x",(char *) "x",(char *) "flags",(char *) "solidBackground", NULL
18398 };
18399
18400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OO:ImageList_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
18401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18402 if (SWIG_arg_fail(1)) SWIG_fail;
18403 {
18404 arg2 = (int)(SWIG_As_int(obj1));
18405 if (SWIG_arg_fail(2)) SWIG_fail;
18406 }
18407 {
18408 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
18409 if (SWIG_arg_fail(3)) SWIG_fail;
18410 if (arg3 == NULL) {
18411 SWIG_null_ref("wxDC");
18412 }
18413 if (SWIG_arg_fail(3)) SWIG_fail;
18414 }
18415 {
18416 arg4 = (int)(SWIG_As_int(obj3));
18417 if (SWIG_arg_fail(4)) SWIG_fail;
18418 }
18419 {
18420 arg5 = (int)(SWIG_As_int(obj4));
18421 if (SWIG_arg_fail(5)) SWIG_fail;
18422 }
18423 if (obj5) {
18424 {
18425 arg6 = (int)(SWIG_As_int(obj5));
18426 if (SWIG_arg_fail(6)) SWIG_fail;
18427 }
18428 }
18429 if (obj6) {
18430 {
18431 arg7 = (bool const)(SWIG_As_bool(obj6));
18432 if (SWIG_arg_fail(7)) SWIG_fail;
18433 }
18434 }
18435 {
18436 PyThreadState* __tstate = wxPyBeginAllowThreads();
18437 result = (bool)(arg1)->Draw(arg2,*arg3,arg4,arg5,arg6,arg7);
18438
18439 wxPyEndAllowThreads(__tstate);
18440 if (PyErr_Occurred()) SWIG_fail;
18441 }
18442 {
18443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18444 }
18445 return resultobj;
18446 fail:
18447 return NULL;
18448 }
18449
18450
18451 static PyObject *_wrap_ImageList_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
18452 PyObject *resultobj;
18453 wxImageList *arg1 = (wxImageList *) 0 ;
18454 int result;
18455 PyObject * obj0 = 0 ;
18456 char *kwnames[] = {
18457 (char *) "self", NULL
18458 };
18459
18460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_GetImageCount",kwnames,&obj0)) goto fail;
18461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18462 if (SWIG_arg_fail(1)) SWIG_fail;
18463 {
18464 PyThreadState* __tstate = wxPyBeginAllowThreads();
18465 result = (int)(arg1)->GetImageCount();
18466
18467 wxPyEndAllowThreads(__tstate);
18468 if (PyErr_Occurred()) SWIG_fail;
18469 }
18470 {
18471 resultobj = SWIG_From_int((int)(result));
18472 }
18473 return resultobj;
18474 fail:
18475 return NULL;
18476 }
18477
18478
18479 static PyObject *_wrap_ImageList_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
18480 PyObject *resultobj;
18481 wxImageList *arg1 = (wxImageList *) 0 ;
18482 int arg2 ;
18483 bool result;
18484 PyObject * obj0 = 0 ;
18485 PyObject * obj1 = 0 ;
18486 char *kwnames[] = {
18487 (char *) "self",(char *) "index", NULL
18488 };
18489
18490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_Remove",kwnames,&obj0,&obj1)) goto fail;
18491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18492 if (SWIG_arg_fail(1)) SWIG_fail;
18493 {
18494 arg2 = (int)(SWIG_As_int(obj1));
18495 if (SWIG_arg_fail(2)) SWIG_fail;
18496 }
18497 {
18498 PyThreadState* __tstate = wxPyBeginAllowThreads();
18499 result = (bool)(arg1)->Remove(arg2);
18500
18501 wxPyEndAllowThreads(__tstate);
18502 if (PyErr_Occurred()) SWIG_fail;
18503 }
18504 {
18505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18506 }
18507 return resultobj;
18508 fail:
18509 return NULL;
18510 }
18511
18512
18513 static PyObject *_wrap_ImageList_RemoveAll(PyObject *, PyObject *args, PyObject *kwargs) {
18514 PyObject *resultobj;
18515 wxImageList *arg1 = (wxImageList *) 0 ;
18516 bool result;
18517 PyObject * obj0 = 0 ;
18518 char *kwnames[] = {
18519 (char *) "self", NULL
18520 };
18521
18522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_RemoveAll",kwnames,&obj0)) goto fail;
18523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18524 if (SWIG_arg_fail(1)) SWIG_fail;
18525 {
18526 PyThreadState* __tstate = wxPyBeginAllowThreads();
18527 result = (bool)(arg1)->RemoveAll();
18528
18529 wxPyEndAllowThreads(__tstate);
18530 if (PyErr_Occurred()) SWIG_fail;
18531 }
18532 {
18533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18534 }
18535 return resultobj;
18536 fail:
18537 return NULL;
18538 }
18539
18540
18541 static PyObject *_wrap_ImageList_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18542 PyObject *resultobj;
18543 wxImageList *arg1 = (wxImageList *) 0 ;
18544 int arg2 ;
18545 int *arg3 = 0 ;
18546 int *arg4 = 0 ;
18547 int temp3 ;
18548 int res3 = 0 ;
18549 int temp4 ;
18550 int res4 = 0 ;
18551 PyObject * obj0 = 0 ;
18552 PyObject * obj1 = 0 ;
18553 char *kwnames[] = {
18554 (char *) "self",(char *) "index", NULL
18555 };
18556
18557 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18558 arg4 = &temp4; res4 = SWIG_NEWOBJ;
18559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetSize",kwnames,&obj0,&obj1)) goto fail;
18560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18561 if (SWIG_arg_fail(1)) SWIG_fail;
18562 {
18563 arg2 = (int)(SWIG_As_int(obj1));
18564 if (SWIG_arg_fail(2)) SWIG_fail;
18565 }
18566 {
18567 PyThreadState* __tstate = wxPyBeginAllowThreads();
18568 (arg1)->GetSize(arg2,*arg3,*arg4);
18569
18570 wxPyEndAllowThreads(__tstate);
18571 if (PyErr_Occurred()) SWIG_fail;
18572 }
18573 Py_INCREF(Py_None); resultobj = Py_None;
18574 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18575 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
18576 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
18577 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
18578 return resultobj;
18579 fail:
18580 return NULL;
18581 }
18582
18583
18584 static PyObject * ImageList_swigregister(PyObject *, PyObject *args) {
18585 PyObject *obj;
18586 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18587 SWIG_TypeClientData(SWIGTYPE_p_wxImageList, obj);
18588 Py_INCREF(obj);
18589 return Py_BuildValue((char *)"");
18590 }
18591 static int _wrap_NORMAL_FONT_set(PyObject *) {
18592 PyErr_SetString(PyExc_TypeError,"Variable NORMAL_FONT is read-only.");
18593 return 1;
18594 }
18595
18596
18597 static PyObject *_wrap_NORMAL_FONT_get(void) {
18598 PyObject *pyobj;
18599
18600 pyobj = SWIG_NewPointerObj((void *)(wxNORMAL_FONT), SWIGTYPE_p_wxFont, 0);
18601 return pyobj;
18602 }
18603
18604
18605 static int _wrap_SMALL_FONT_set(PyObject *) {
18606 PyErr_SetString(PyExc_TypeError,"Variable SMALL_FONT is read-only.");
18607 return 1;
18608 }
18609
18610
18611 static PyObject *_wrap_SMALL_FONT_get(void) {
18612 PyObject *pyobj;
18613
18614 pyobj = SWIG_NewPointerObj((void *)(wxSMALL_FONT), SWIGTYPE_p_wxFont, 0);
18615 return pyobj;
18616 }
18617
18618
18619 static int _wrap_ITALIC_FONT_set(PyObject *) {
18620 PyErr_SetString(PyExc_TypeError,"Variable ITALIC_FONT is read-only.");
18621 return 1;
18622 }
18623
18624
18625 static PyObject *_wrap_ITALIC_FONT_get(void) {
18626 PyObject *pyobj;
18627
18628 pyobj = SWIG_NewPointerObj((void *)(wxITALIC_FONT), SWIGTYPE_p_wxFont, 0);
18629 return pyobj;
18630 }
18631
18632
18633 static int _wrap_SWISS_FONT_set(PyObject *) {
18634 PyErr_SetString(PyExc_TypeError,"Variable SWISS_FONT is read-only.");
18635 return 1;
18636 }
18637
18638
18639 static PyObject *_wrap_SWISS_FONT_get(void) {
18640 PyObject *pyobj;
18641
18642 pyobj = SWIG_NewPointerObj((void *)(wxSWISS_FONT), SWIGTYPE_p_wxFont, 0);
18643 return pyobj;
18644 }
18645
18646
18647 static int _wrap_RED_PEN_set(PyObject *) {
18648 PyErr_SetString(PyExc_TypeError,"Variable RED_PEN is read-only.");
18649 return 1;
18650 }
18651
18652
18653 static PyObject *_wrap_RED_PEN_get(void) {
18654 PyObject *pyobj;
18655
18656 pyobj = SWIG_NewPointerObj((void *)(wxRED_PEN), SWIGTYPE_p_wxPen, 0);
18657 return pyobj;
18658 }
18659
18660
18661 static int _wrap_CYAN_PEN_set(PyObject *) {
18662 PyErr_SetString(PyExc_TypeError,"Variable CYAN_PEN is read-only.");
18663 return 1;
18664 }
18665
18666
18667 static PyObject *_wrap_CYAN_PEN_get(void) {
18668 PyObject *pyobj;
18669
18670 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_PEN), SWIGTYPE_p_wxPen, 0);
18671 return pyobj;
18672 }
18673
18674
18675 static int _wrap_GREEN_PEN_set(PyObject *) {
18676 PyErr_SetString(PyExc_TypeError,"Variable GREEN_PEN is read-only.");
18677 return 1;
18678 }
18679
18680
18681 static PyObject *_wrap_GREEN_PEN_get(void) {
18682 PyObject *pyobj;
18683
18684 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_PEN), SWIGTYPE_p_wxPen, 0);
18685 return pyobj;
18686 }
18687
18688
18689 static int _wrap_BLACK_PEN_set(PyObject *) {
18690 PyErr_SetString(PyExc_TypeError,"Variable BLACK_PEN is read-only.");
18691 return 1;
18692 }
18693
18694
18695 static PyObject *_wrap_BLACK_PEN_get(void) {
18696 PyObject *pyobj;
18697
18698 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_PEN), SWIGTYPE_p_wxPen, 0);
18699 return pyobj;
18700 }
18701
18702
18703 static int _wrap_WHITE_PEN_set(PyObject *) {
18704 PyErr_SetString(PyExc_TypeError,"Variable WHITE_PEN is read-only.");
18705 return 1;
18706 }
18707
18708
18709 static PyObject *_wrap_WHITE_PEN_get(void) {
18710 PyObject *pyobj;
18711
18712 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_PEN), SWIGTYPE_p_wxPen, 0);
18713 return pyobj;
18714 }
18715
18716
18717 static int _wrap_TRANSPARENT_PEN_set(PyObject *) {
18718 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_PEN is read-only.");
18719 return 1;
18720 }
18721
18722
18723 static PyObject *_wrap_TRANSPARENT_PEN_get(void) {
18724 PyObject *pyobj;
18725
18726 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_PEN), SWIGTYPE_p_wxPen, 0);
18727 return pyobj;
18728 }
18729
18730
18731 static int _wrap_BLACK_DASHED_PEN_set(PyObject *) {
18732 PyErr_SetString(PyExc_TypeError,"Variable BLACK_DASHED_PEN is read-only.");
18733 return 1;
18734 }
18735
18736
18737 static PyObject *_wrap_BLACK_DASHED_PEN_get(void) {
18738 PyObject *pyobj;
18739
18740 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_DASHED_PEN), SWIGTYPE_p_wxPen, 0);
18741 return pyobj;
18742 }
18743
18744
18745 static int _wrap_GREY_PEN_set(PyObject *) {
18746 PyErr_SetString(PyExc_TypeError,"Variable GREY_PEN is read-only.");
18747 return 1;
18748 }
18749
18750
18751 static PyObject *_wrap_GREY_PEN_get(void) {
18752 PyObject *pyobj;
18753
18754 pyobj = SWIG_NewPointerObj((void *)(wxGREY_PEN), SWIGTYPE_p_wxPen, 0);
18755 return pyobj;
18756 }
18757
18758
18759 static int _wrap_MEDIUM_GREY_PEN_set(PyObject *) {
18760 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_PEN is read-only.");
18761 return 1;
18762 }
18763
18764
18765 static PyObject *_wrap_MEDIUM_GREY_PEN_get(void) {
18766 PyObject *pyobj;
18767
18768 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_PEN), SWIGTYPE_p_wxPen, 0);
18769 return pyobj;
18770 }
18771
18772
18773 static int _wrap_LIGHT_GREY_PEN_set(PyObject *) {
18774 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_PEN is read-only.");
18775 return 1;
18776 }
18777
18778
18779 static PyObject *_wrap_LIGHT_GREY_PEN_get(void) {
18780 PyObject *pyobj;
18781
18782 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_PEN), SWIGTYPE_p_wxPen, 0);
18783 return pyobj;
18784 }
18785
18786
18787 static int _wrap_BLUE_BRUSH_set(PyObject *) {
18788 PyErr_SetString(PyExc_TypeError,"Variable BLUE_BRUSH is read-only.");
18789 return 1;
18790 }
18791
18792
18793 static PyObject *_wrap_BLUE_BRUSH_get(void) {
18794 PyObject *pyobj;
18795
18796 pyobj = SWIG_NewPointerObj((void *)(wxBLUE_BRUSH), SWIGTYPE_p_wxBrush, 0);
18797 return pyobj;
18798 }
18799
18800
18801 static int _wrap_GREEN_BRUSH_set(PyObject *) {
18802 PyErr_SetString(PyExc_TypeError,"Variable GREEN_BRUSH is read-only.");
18803 return 1;
18804 }
18805
18806
18807 static PyObject *_wrap_GREEN_BRUSH_get(void) {
18808 PyObject *pyobj;
18809
18810 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_BRUSH), SWIGTYPE_p_wxBrush, 0);
18811 return pyobj;
18812 }
18813
18814
18815 static int _wrap_WHITE_BRUSH_set(PyObject *) {
18816 PyErr_SetString(PyExc_TypeError,"Variable WHITE_BRUSH is read-only.");
18817 return 1;
18818 }
18819
18820
18821 static PyObject *_wrap_WHITE_BRUSH_get(void) {
18822 PyObject *pyobj;
18823
18824 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_BRUSH), SWIGTYPE_p_wxBrush, 0);
18825 return pyobj;
18826 }
18827
18828
18829 static int _wrap_BLACK_BRUSH_set(PyObject *) {
18830 PyErr_SetString(PyExc_TypeError,"Variable BLACK_BRUSH is read-only.");
18831 return 1;
18832 }
18833
18834
18835 static PyObject *_wrap_BLACK_BRUSH_get(void) {
18836 PyObject *pyobj;
18837
18838 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_BRUSH), SWIGTYPE_p_wxBrush, 0);
18839 return pyobj;
18840 }
18841
18842
18843 static int _wrap_TRANSPARENT_BRUSH_set(PyObject *) {
18844 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_BRUSH is read-only.");
18845 return 1;
18846 }
18847
18848
18849 static PyObject *_wrap_TRANSPARENT_BRUSH_get(void) {
18850 PyObject *pyobj;
18851
18852 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_BRUSH), SWIGTYPE_p_wxBrush, 0);
18853 return pyobj;
18854 }
18855
18856
18857 static int _wrap_CYAN_BRUSH_set(PyObject *) {
18858 PyErr_SetString(PyExc_TypeError,"Variable CYAN_BRUSH is read-only.");
18859 return 1;
18860 }
18861
18862
18863 static PyObject *_wrap_CYAN_BRUSH_get(void) {
18864 PyObject *pyobj;
18865
18866 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_BRUSH), SWIGTYPE_p_wxBrush, 0);
18867 return pyobj;
18868 }
18869
18870
18871 static int _wrap_RED_BRUSH_set(PyObject *) {
18872 PyErr_SetString(PyExc_TypeError,"Variable RED_BRUSH is read-only.");
18873 return 1;
18874 }
18875
18876
18877 static PyObject *_wrap_RED_BRUSH_get(void) {
18878 PyObject *pyobj;
18879
18880 pyobj = SWIG_NewPointerObj((void *)(wxRED_BRUSH), SWIGTYPE_p_wxBrush, 0);
18881 return pyobj;
18882 }
18883
18884
18885 static int _wrap_GREY_BRUSH_set(PyObject *) {
18886 PyErr_SetString(PyExc_TypeError,"Variable GREY_BRUSH is read-only.");
18887 return 1;
18888 }
18889
18890
18891 static PyObject *_wrap_GREY_BRUSH_get(void) {
18892 PyObject *pyobj;
18893
18894 pyobj = SWIG_NewPointerObj((void *)(wxGREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
18895 return pyobj;
18896 }
18897
18898
18899 static int _wrap_MEDIUM_GREY_BRUSH_set(PyObject *) {
18900 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_BRUSH is read-only.");
18901 return 1;
18902 }
18903
18904
18905 static PyObject *_wrap_MEDIUM_GREY_BRUSH_get(void) {
18906 PyObject *pyobj;
18907
18908 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
18909 return pyobj;
18910 }
18911
18912
18913 static int _wrap_LIGHT_GREY_BRUSH_set(PyObject *) {
18914 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_BRUSH is read-only.");
18915 return 1;
18916 }
18917
18918
18919 static PyObject *_wrap_LIGHT_GREY_BRUSH_get(void) {
18920 PyObject *pyobj;
18921
18922 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
18923 return pyobj;
18924 }
18925
18926
18927 static int _wrap_BLACK_set(PyObject *) {
18928 PyErr_SetString(PyExc_TypeError,"Variable BLACK is read-only.");
18929 return 1;
18930 }
18931
18932
18933 static PyObject *_wrap_BLACK_get(void) {
18934 PyObject *pyobj;
18935
18936 pyobj = SWIG_NewPointerObj((void *)(wxBLACK), SWIGTYPE_p_wxColour, 0);
18937 return pyobj;
18938 }
18939
18940
18941 static int _wrap_WHITE_set(PyObject *) {
18942 PyErr_SetString(PyExc_TypeError,"Variable WHITE is read-only.");
18943 return 1;
18944 }
18945
18946
18947 static PyObject *_wrap_WHITE_get(void) {
18948 PyObject *pyobj;
18949
18950 pyobj = SWIG_NewPointerObj((void *)(wxWHITE), SWIGTYPE_p_wxColour, 0);
18951 return pyobj;
18952 }
18953
18954
18955 static int _wrap_RED_set(PyObject *) {
18956 PyErr_SetString(PyExc_TypeError,"Variable RED is read-only.");
18957 return 1;
18958 }
18959
18960
18961 static PyObject *_wrap_RED_get(void) {
18962 PyObject *pyobj;
18963
18964 pyobj = SWIG_NewPointerObj((void *)(wxRED), SWIGTYPE_p_wxColour, 0);
18965 return pyobj;
18966 }
18967
18968
18969 static int _wrap_BLUE_set(PyObject *) {
18970 PyErr_SetString(PyExc_TypeError,"Variable BLUE is read-only.");
18971 return 1;
18972 }
18973
18974
18975 static PyObject *_wrap_BLUE_get(void) {
18976 PyObject *pyobj;
18977
18978 pyobj = SWIG_NewPointerObj((void *)(wxBLUE), SWIGTYPE_p_wxColour, 0);
18979 return pyobj;
18980 }
18981
18982
18983 static int _wrap_GREEN_set(PyObject *) {
18984 PyErr_SetString(PyExc_TypeError,"Variable GREEN is read-only.");
18985 return 1;
18986 }
18987
18988
18989 static PyObject *_wrap_GREEN_get(void) {
18990 PyObject *pyobj;
18991
18992 pyobj = SWIG_NewPointerObj((void *)(wxGREEN), SWIGTYPE_p_wxColour, 0);
18993 return pyobj;
18994 }
18995
18996
18997 static int _wrap_CYAN_set(PyObject *) {
18998 PyErr_SetString(PyExc_TypeError,"Variable CYAN is read-only.");
18999 return 1;
19000 }
19001
19002
19003 static PyObject *_wrap_CYAN_get(void) {
19004 PyObject *pyobj;
19005
19006 pyobj = SWIG_NewPointerObj((void *)(wxCYAN), SWIGTYPE_p_wxColour, 0);
19007 return pyobj;
19008 }
19009
19010
19011 static int _wrap_LIGHT_GREY_set(PyObject *) {
19012 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY is read-only.");
19013 return 1;
19014 }
19015
19016
19017 static PyObject *_wrap_LIGHT_GREY_get(void) {
19018 PyObject *pyobj;
19019
19020 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY), SWIGTYPE_p_wxColour, 0);
19021 return pyobj;
19022 }
19023
19024
19025 static int _wrap_STANDARD_CURSOR_set(PyObject *) {
19026 PyErr_SetString(PyExc_TypeError,"Variable STANDARD_CURSOR is read-only.");
19027 return 1;
19028 }
19029
19030
19031 static PyObject *_wrap_STANDARD_CURSOR_get(void) {
19032 PyObject *pyobj;
19033
19034 pyobj = SWIG_NewPointerObj((void *)(wxSTANDARD_CURSOR), SWIGTYPE_p_wxCursor, 0);
19035 return pyobj;
19036 }
19037
19038
19039 static int _wrap_HOURGLASS_CURSOR_set(PyObject *) {
19040 PyErr_SetString(PyExc_TypeError,"Variable HOURGLASS_CURSOR is read-only.");
19041 return 1;
19042 }
19043
19044
19045 static PyObject *_wrap_HOURGLASS_CURSOR_get(void) {
19046 PyObject *pyobj;
19047
19048 pyobj = SWIG_NewPointerObj((void *)(wxHOURGLASS_CURSOR), SWIGTYPE_p_wxCursor, 0);
19049 return pyobj;
19050 }
19051
19052
19053 static int _wrap_CROSS_CURSOR_set(PyObject *) {
19054 PyErr_SetString(PyExc_TypeError,"Variable CROSS_CURSOR is read-only.");
19055 return 1;
19056 }
19057
19058
19059 static PyObject *_wrap_CROSS_CURSOR_get(void) {
19060 PyObject *pyobj;
19061
19062 pyobj = SWIG_NewPointerObj((void *)(wxCROSS_CURSOR), SWIGTYPE_p_wxCursor, 0);
19063 return pyobj;
19064 }
19065
19066
19067 static int _wrap_NullBitmap_set(PyObject *) {
19068 PyErr_SetString(PyExc_TypeError,"Variable NullBitmap is read-only.");
19069 return 1;
19070 }
19071
19072
19073 static PyObject *_wrap_NullBitmap_get(void) {
19074 PyObject *pyobj;
19075
19076 pyobj = SWIG_NewPointerObj((void *)(&wxNullBitmap), SWIGTYPE_p_wxBitmap, 0);
19077 return pyobj;
19078 }
19079
19080
19081 static int _wrap_NullIcon_set(PyObject *) {
19082 PyErr_SetString(PyExc_TypeError,"Variable NullIcon is read-only.");
19083 return 1;
19084 }
19085
19086
19087 static PyObject *_wrap_NullIcon_get(void) {
19088 PyObject *pyobj;
19089
19090 pyobj = SWIG_NewPointerObj((void *)(&wxNullIcon), SWIGTYPE_p_wxIcon, 0);
19091 return pyobj;
19092 }
19093
19094
19095 static int _wrap_NullCursor_set(PyObject *) {
19096 PyErr_SetString(PyExc_TypeError,"Variable NullCursor is read-only.");
19097 return 1;
19098 }
19099
19100
19101 static PyObject *_wrap_NullCursor_get(void) {
19102 PyObject *pyobj;
19103
19104 pyobj = SWIG_NewPointerObj((void *)(&wxNullCursor), SWIGTYPE_p_wxCursor, 0);
19105 return pyobj;
19106 }
19107
19108
19109 static int _wrap_NullPen_set(PyObject *) {
19110 PyErr_SetString(PyExc_TypeError,"Variable NullPen is read-only.");
19111 return 1;
19112 }
19113
19114
19115 static PyObject *_wrap_NullPen_get(void) {
19116 PyObject *pyobj;
19117
19118 pyobj = SWIG_NewPointerObj((void *)(&wxNullPen), SWIGTYPE_p_wxPen, 0);
19119 return pyobj;
19120 }
19121
19122
19123 static int _wrap_NullBrush_set(PyObject *) {
19124 PyErr_SetString(PyExc_TypeError,"Variable NullBrush is read-only.");
19125 return 1;
19126 }
19127
19128
19129 static PyObject *_wrap_NullBrush_get(void) {
19130 PyObject *pyobj;
19131
19132 pyobj = SWIG_NewPointerObj((void *)(&wxNullBrush), SWIGTYPE_p_wxBrush, 0);
19133 return pyobj;
19134 }
19135
19136
19137 static int _wrap_NullPalette_set(PyObject *) {
19138 PyErr_SetString(PyExc_TypeError,"Variable NullPalette is read-only.");
19139 return 1;
19140 }
19141
19142
19143 static PyObject *_wrap_NullPalette_get(void) {
19144 PyObject *pyobj;
19145
19146 pyobj = SWIG_NewPointerObj((void *)(&wxNullPalette), SWIGTYPE_p_wxPalette, 0);
19147 return pyobj;
19148 }
19149
19150
19151 static int _wrap_NullFont_set(PyObject *) {
19152 PyErr_SetString(PyExc_TypeError,"Variable NullFont is read-only.");
19153 return 1;
19154 }
19155
19156
19157 static PyObject *_wrap_NullFont_get(void) {
19158 PyObject *pyobj;
19159
19160 pyobj = SWIG_NewPointerObj((void *)(&wxNullFont), SWIGTYPE_p_wxFont, 0);
19161 return pyobj;
19162 }
19163
19164
19165 static int _wrap_NullColour_set(PyObject *) {
19166 PyErr_SetString(PyExc_TypeError,"Variable NullColour is read-only.");
19167 return 1;
19168 }
19169
19170
19171 static PyObject *_wrap_NullColour_get(void) {
19172 PyObject *pyobj;
19173
19174 pyobj = SWIG_NewPointerObj((void *)(&wxNullColour), SWIGTYPE_p_wxColour, 0);
19175 return pyobj;
19176 }
19177
19178
19179 static PyObject *_wrap_PenList_AddPen(PyObject *, PyObject *args, PyObject *kwargs) {
19180 PyObject *resultobj;
19181 wxPenList *arg1 = (wxPenList *) 0 ;
19182 wxPen *arg2 = (wxPen *) 0 ;
19183 PyObject * obj0 = 0 ;
19184 PyObject * obj1 = 0 ;
19185 char *kwnames[] = {
19186 (char *) "self",(char *) "pen", NULL
19187 };
19188
19189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_AddPen",kwnames,&obj0,&obj1)) goto fail;
19190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19191 if (SWIG_arg_fail(1)) SWIG_fail;
19192 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
19193 if (SWIG_arg_fail(2)) SWIG_fail;
19194 {
19195 PyThreadState* __tstate = wxPyBeginAllowThreads();
19196 (arg1)->AddPen(arg2);
19197
19198 wxPyEndAllowThreads(__tstate);
19199 if (PyErr_Occurred()) SWIG_fail;
19200 }
19201 Py_INCREF(Py_None); resultobj = Py_None;
19202 return resultobj;
19203 fail:
19204 return NULL;
19205 }
19206
19207
19208 static PyObject *_wrap_PenList_FindOrCreatePen(PyObject *, PyObject *args, PyObject *kwargs) {
19209 PyObject *resultobj;
19210 wxPenList *arg1 = (wxPenList *) 0 ;
19211 wxColour *arg2 = 0 ;
19212 int arg3 ;
19213 int arg4 ;
19214 wxPen *result;
19215 wxColour temp2 ;
19216 PyObject * obj0 = 0 ;
19217 PyObject * obj1 = 0 ;
19218 PyObject * obj2 = 0 ;
19219 PyObject * obj3 = 0 ;
19220 char *kwnames[] = {
19221 (char *) "self",(char *) "colour",(char *) "width",(char *) "style", NULL
19222 };
19223
19224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PenList_FindOrCreatePen",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19226 if (SWIG_arg_fail(1)) SWIG_fail;
19227 {
19228 arg2 = &temp2;
19229 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19230 }
19231 {
19232 arg3 = (int)(SWIG_As_int(obj2));
19233 if (SWIG_arg_fail(3)) SWIG_fail;
19234 }
19235 {
19236 arg4 = (int)(SWIG_As_int(obj3));
19237 if (SWIG_arg_fail(4)) SWIG_fail;
19238 }
19239 {
19240 PyThreadState* __tstate = wxPyBeginAllowThreads();
19241 result = (wxPen *)(arg1)->FindOrCreatePen((wxColour const &)*arg2,arg3,arg4);
19242
19243 wxPyEndAllowThreads(__tstate);
19244 if (PyErr_Occurred()) SWIG_fail;
19245 }
19246 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 0);
19247 return resultobj;
19248 fail:
19249 return NULL;
19250 }
19251
19252
19253 static PyObject *_wrap_PenList_RemovePen(PyObject *, PyObject *args, PyObject *kwargs) {
19254 PyObject *resultobj;
19255 wxPenList *arg1 = (wxPenList *) 0 ;
19256 wxPen *arg2 = (wxPen *) 0 ;
19257 PyObject * obj0 = 0 ;
19258 PyObject * obj1 = 0 ;
19259 char *kwnames[] = {
19260 (char *) "self",(char *) "pen", NULL
19261 };
19262
19263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_RemovePen",kwnames,&obj0,&obj1)) goto fail;
19264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19265 if (SWIG_arg_fail(1)) SWIG_fail;
19266 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
19267 if (SWIG_arg_fail(2)) SWIG_fail;
19268 {
19269 PyThreadState* __tstate = wxPyBeginAllowThreads();
19270 (arg1)->RemovePen(arg2);
19271
19272 wxPyEndAllowThreads(__tstate);
19273 if (PyErr_Occurred()) SWIG_fail;
19274 }
19275 Py_INCREF(Py_None); resultobj = Py_None;
19276 return resultobj;
19277 fail:
19278 return NULL;
19279 }
19280
19281
19282 static PyObject *_wrap_PenList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
19283 PyObject *resultobj;
19284 wxPenList *arg1 = (wxPenList *) 0 ;
19285 int result;
19286 PyObject * obj0 = 0 ;
19287 char *kwnames[] = {
19288 (char *) "self", NULL
19289 };
19290
19291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PenList_GetCount",kwnames,&obj0)) goto fail;
19292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19293 if (SWIG_arg_fail(1)) SWIG_fail;
19294 {
19295 PyThreadState* __tstate = wxPyBeginAllowThreads();
19296 result = (int)(arg1)->GetCount();
19297
19298 wxPyEndAllowThreads(__tstate);
19299 if (PyErr_Occurred()) SWIG_fail;
19300 }
19301 {
19302 resultobj = SWIG_From_int((int)(result));
19303 }
19304 return resultobj;
19305 fail:
19306 return NULL;
19307 }
19308
19309
19310 static PyObject * PenList_swigregister(PyObject *, PyObject *args) {
19311 PyObject *obj;
19312 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19313 SWIG_TypeClientData(SWIGTYPE_p_wxPenList, obj);
19314 Py_INCREF(obj);
19315 return Py_BuildValue((char *)"");
19316 }
19317 static PyObject *_wrap_BrushList_AddBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19318 PyObject *resultobj;
19319 wxBrushList *arg1 = (wxBrushList *) 0 ;
19320 wxBrush *arg2 = (wxBrush *) 0 ;
19321 PyObject * obj0 = 0 ;
19322 PyObject * obj1 = 0 ;
19323 char *kwnames[] = {
19324 (char *) "self",(char *) "brush", NULL
19325 };
19326
19327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_AddBrush",kwnames,&obj0,&obj1)) goto fail;
19328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19329 if (SWIG_arg_fail(1)) SWIG_fail;
19330 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
19331 if (SWIG_arg_fail(2)) SWIG_fail;
19332 {
19333 PyThreadState* __tstate = wxPyBeginAllowThreads();
19334 (arg1)->AddBrush(arg2);
19335
19336 wxPyEndAllowThreads(__tstate);
19337 if (PyErr_Occurred()) SWIG_fail;
19338 }
19339 Py_INCREF(Py_None); resultobj = Py_None;
19340 return resultobj;
19341 fail:
19342 return NULL;
19343 }
19344
19345
19346 static PyObject *_wrap_BrushList_FindOrCreateBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19347 PyObject *resultobj;
19348 wxBrushList *arg1 = (wxBrushList *) 0 ;
19349 wxColour *arg2 = 0 ;
19350 int arg3 ;
19351 wxBrush *result;
19352 wxColour temp2 ;
19353 PyObject * obj0 = 0 ;
19354 PyObject * obj1 = 0 ;
19355 PyObject * obj2 = 0 ;
19356 char *kwnames[] = {
19357 (char *) "self",(char *) "colour",(char *) "style", NULL
19358 };
19359
19360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:BrushList_FindOrCreateBrush",kwnames,&obj0,&obj1,&obj2)) goto fail;
19361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19362 if (SWIG_arg_fail(1)) SWIG_fail;
19363 {
19364 arg2 = &temp2;
19365 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19366 }
19367 {
19368 arg3 = (int)(SWIG_As_int(obj2));
19369 if (SWIG_arg_fail(3)) SWIG_fail;
19370 }
19371 {
19372 PyThreadState* __tstate = wxPyBeginAllowThreads();
19373 result = (wxBrush *)(arg1)->FindOrCreateBrush((wxColour const &)*arg2,arg3);
19374
19375 wxPyEndAllowThreads(__tstate);
19376 if (PyErr_Occurred()) SWIG_fail;
19377 }
19378 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 0);
19379 return resultobj;
19380 fail:
19381 return NULL;
19382 }
19383
19384
19385 static PyObject *_wrap_BrushList_RemoveBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19386 PyObject *resultobj;
19387 wxBrushList *arg1 = (wxBrushList *) 0 ;
19388 wxBrush *arg2 = (wxBrush *) 0 ;
19389 PyObject * obj0 = 0 ;
19390 PyObject * obj1 = 0 ;
19391 char *kwnames[] = {
19392 (char *) "self",(char *) "brush", NULL
19393 };
19394
19395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_RemoveBrush",kwnames,&obj0,&obj1)) goto fail;
19396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19397 if (SWIG_arg_fail(1)) SWIG_fail;
19398 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
19399 if (SWIG_arg_fail(2)) SWIG_fail;
19400 {
19401 PyThreadState* __tstate = wxPyBeginAllowThreads();
19402 (arg1)->RemoveBrush(arg2);
19403
19404 wxPyEndAllowThreads(__tstate);
19405 if (PyErr_Occurred()) SWIG_fail;
19406 }
19407 Py_INCREF(Py_None); resultobj = Py_None;
19408 return resultobj;
19409 fail:
19410 return NULL;
19411 }
19412
19413
19414 static PyObject *_wrap_BrushList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
19415 PyObject *resultobj;
19416 wxBrushList *arg1 = (wxBrushList *) 0 ;
19417 int result;
19418 PyObject * obj0 = 0 ;
19419 char *kwnames[] = {
19420 (char *) "self", NULL
19421 };
19422
19423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BrushList_GetCount",kwnames,&obj0)) goto fail;
19424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19425 if (SWIG_arg_fail(1)) SWIG_fail;
19426 {
19427 PyThreadState* __tstate = wxPyBeginAllowThreads();
19428 result = (int)(arg1)->GetCount();
19429
19430 wxPyEndAllowThreads(__tstate);
19431 if (PyErr_Occurred()) SWIG_fail;
19432 }
19433 {
19434 resultobj = SWIG_From_int((int)(result));
19435 }
19436 return resultobj;
19437 fail:
19438 return NULL;
19439 }
19440
19441
19442 static PyObject * BrushList_swigregister(PyObject *, PyObject *args) {
19443 PyObject *obj;
19444 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19445 SWIG_TypeClientData(SWIGTYPE_p_wxBrushList, obj);
19446 Py_INCREF(obj);
19447 return Py_BuildValue((char *)"");
19448 }
19449 static PyObject *_wrap_new_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
19450 PyObject *resultobj;
19451 wxColourDatabase *result;
19452 char *kwnames[] = {
19453 NULL
19454 };
19455
19456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ColourDatabase",kwnames)) goto fail;
19457 {
19458 if (!wxPyCheckForApp()) SWIG_fail;
19459 PyThreadState* __tstate = wxPyBeginAllowThreads();
19460 result = (wxColourDatabase *)new wxColourDatabase();
19461
19462 wxPyEndAllowThreads(__tstate);
19463 if (PyErr_Occurred()) SWIG_fail;
19464 }
19465 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColourDatabase, 1);
19466 return resultobj;
19467 fail:
19468 return NULL;
19469 }
19470
19471
19472 static PyObject *_wrap_delete_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
19473 PyObject *resultobj;
19474 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19475 PyObject * obj0 = 0 ;
19476 char *kwnames[] = {
19477 (char *) "self", NULL
19478 };
19479
19480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ColourDatabase",kwnames,&obj0)) goto fail;
19481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19482 if (SWIG_arg_fail(1)) SWIG_fail;
19483 {
19484 PyThreadState* __tstate = wxPyBeginAllowThreads();
19485 delete arg1;
19486
19487 wxPyEndAllowThreads(__tstate);
19488 if (PyErr_Occurred()) SWIG_fail;
19489 }
19490 Py_INCREF(Py_None); resultobj = Py_None;
19491 return resultobj;
19492 fail:
19493 return NULL;
19494 }
19495
19496
19497 static PyObject *_wrap_ColourDatabase_Find(PyObject *, PyObject *args, PyObject *kwargs) {
19498 PyObject *resultobj;
19499 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19500 wxString *arg2 = 0 ;
19501 wxColour result;
19502 bool temp2 = false ;
19503 PyObject * obj0 = 0 ;
19504 PyObject * obj1 = 0 ;
19505 char *kwnames[] = {
19506 (char *) "self",(char *) "name", NULL
19507 };
19508
19509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_Find",kwnames,&obj0,&obj1)) goto fail;
19510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19511 if (SWIG_arg_fail(1)) SWIG_fail;
19512 {
19513 arg2 = wxString_in_helper(obj1);
19514 if (arg2 == NULL) SWIG_fail;
19515 temp2 = true;
19516 }
19517 {
19518 PyThreadState* __tstate = wxPyBeginAllowThreads();
19519 result = ((wxColourDatabase const *)arg1)->Find((wxString const &)*arg2);
19520
19521 wxPyEndAllowThreads(__tstate);
19522 if (PyErr_Occurred()) SWIG_fail;
19523 }
19524 {
19525 wxColour * resultptr;
19526 resultptr = new wxColour((wxColour &)(result));
19527 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
19528 }
19529 {
19530 if (temp2)
19531 delete arg2;
19532 }
19533 return resultobj;
19534 fail:
19535 {
19536 if (temp2)
19537 delete arg2;
19538 }
19539 return NULL;
19540 }
19541
19542
19543 static PyObject *_wrap_ColourDatabase_FindName(PyObject *, PyObject *args, PyObject *kwargs) {
19544 PyObject *resultobj;
19545 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19546 wxColour *arg2 = 0 ;
19547 wxString result;
19548 wxColour temp2 ;
19549 PyObject * obj0 = 0 ;
19550 PyObject * obj1 = 0 ;
19551 char *kwnames[] = {
19552 (char *) "self",(char *) "colour", NULL
19553 };
19554
19555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_FindName",kwnames,&obj0,&obj1)) goto fail;
19556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19557 if (SWIG_arg_fail(1)) SWIG_fail;
19558 {
19559 arg2 = &temp2;
19560 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19561 }
19562 {
19563 PyThreadState* __tstate = wxPyBeginAllowThreads();
19564 result = ((wxColourDatabase const *)arg1)->FindName((wxColour const &)*arg2);
19565
19566 wxPyEndAllowThreads(__tstate);
19567 if (PyErr_Occurred()) SWIG_fail;
19568 }
19569 {
19570 #if wxUSE_UNICODE
19571 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19572 #else
19573 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19574 #endif
19575 }
19576 return resultobj;
19577 fail:
19578 return NULL;
19579 }
19580
19581
19582 static PyObject *_wrap_ColourDatabase_AddColour(PyObject *, PyObject *args, PyObject *kwargs) {
19583 PyObject *resultobj;
19584 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19585 wxString *arg2 = 0 ;
19586 wxColour *arg3 = 0 ;
19587 bool temp2 = false ;
19588 wxColour temp3 ;
19589 PyObject * obj0 = 0 ;
19590 PyObject * obj1 = 0 ;
19591 PyObject * obj2 = 0 ;
19592 char *kwnames[] = {
19593 (char *) "self",(char *) "name",(char *) "colour", NULL
19594 };
19595
19596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ColourDatabase_AddColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
19597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19598 if (SWIG_arg_fail(1)) SWIG_fail;
19599 {
19600 arg2 = wxString_in_helper(obj1);
19601 if (arg2 == NULL) SWIG_fail;
19602 temp2 = true;
19603 }
19604 {
19605 arg3 = &temp3;
19606 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
19607 }
19608 {
19609 PyThreadState* __tstate = wxPyBeginAllowThreads();
19610 (arg1)->AddColour((wxString const &)*arg2,(wxColour const &)*arg3);
19611
19612 wxPyEndAllowThreads(__tstate);
19613 if (PyErr_Occurred()) SWIG_fail;
19614 }
19615 Py_INCREF(Py_None); resultobj = Py_None;
19616 {
19617 if (temp2)
19618 delete arg2;
19619 }
19620 return resultobj;
19621 fail:
19622 {
19623 if (temp2)
19624 delete arg2;
19625 }
19626 return NULL;
19627 }
19628
19629
19630 static PyObject *_wrap_ColourDatabase_Append(PyObject *, PyObject *args, PyObject *kwargs) {
19631 PyObject *resultobj;
19632 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19633 wxString *arg2 = 0 ;
19634 int arg3 ;
19635 int arg4 ;
19636 int arg5 ;
19637 bool temp2 = false ;
19638 PyObject * obj0 = 0 ;
19639 PyObject * obj1 = 0 ;
19640 PyObject * obj2 = 0 ;
19641 PyObject * obj3 = 0 ;
19642 PyObject * obj4 = 0 ;
19643 char *kwnames[] = {
19644 (char *) "self",(char *) "name",(char *) "red",(char *) "green",(char *) "blue", NULL
19645 };
19646
19647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:ColourDatabase_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19649 if (SWIG_arg_fail(1)) SWIG_fail;
19650 {
19651 arg2 = wxString_in_helper(obj1);
19652 if (arg2 == NULL) SWIG_fail;
19653 temp2 = true;
19654 }
19655 {
19656 arg3 = (int)(SWIG_As_int(obj2));
19657 if (SWIG_arg_fail(3)) SWIG_fail;
19658 }
19659 {
19660 arg4 = (int)(SWIG_As_int(obj3));
19661 if (SWIG_arg_fail(4)) SWIG_fail;
19662 }
19663 {
19664 arg5 = (int)(SWIG_As_int(obj4));
19665 if (SWIG_arg_fail(5)) SWIG_fail;
19666 }
19667 {
19668 PyThreadState* __tstate = wxPyBeginAllowThreads();
19669 wxColourDatabase_Append(arg1,(wxString const &)*arg2,arg3,arg4,arg5);
19670
19671 wxPyEndAllowThreads(__tstate);
19672 if (PyErr_Occurred()) SWIG_fail;
19673 }
19674 Py_INCREF(Py_None); resultobj = Py_None;
19675 {
19676 if (temp2)
19677 delete arg2;
19678 }
19679 return resultobj;
19680 fail:
19681 {
19682 if (temp2)
19683 delete arg2;
19684 }
19685 return NULL;
19686 }
19687
19688
19689 static PyObject * ColourDatabase_swigregister(PyObject *, PyObject *args) {
19690 PyObject *obj;
19691 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19692 SWIG_TypeClientData(SWIGTYPE_p_wxColourDatabase, obj);
19693 Py_INCREF(obj);
19694 return Py_BuildValue((char *)"");
19695 }
19696 static PyObject *_wrap_FontList_AddFont(PyObject *, PyObject *args, PyObject *kwargs) {
19697 PyObject *resultobj;
19698 wxFontList *arg1 = (wxFontList *) 0 ;
19699 wxFont *arg2 = (wxFont *) 0 ;
19700 PyObject * obj0 = 0 ;
19701 PyObject * obj1 = 0 ;
19702 char *kwnames[] = {
19703 (char *) "self",(char *) "font", NULL
19704 };
19705
19706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_AddFont",kwnames,&obj0,&obj1)) goto fail;
19707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
19708 if (SWIG_arg_fail(1)) SWIG_fail;
19709 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
19710 if (SWIG_arg_fail(2)) SWIG_fail;
19711 {
19712 PyThreadState* __tstate = wxPyBeginAllowThreads();
19713 (arg1)->AddFont(arg2);
19714
19715 wxPyEndAllowThreads(__tstate);
19716 if (PyErr_Occurred()) SWIG_fail;
19717 }
19718 Py_INCREF(Py_None); resultobj = Py_None;
19719 return resultobj;
19720 fail:
19721 return NULL;
19722 }
19723
19724
19725 static PyObject *_wrap_FontList_FindOrCreateFont(PyObject *, PyObject *args, PyObject *kwargs) {
19726 PyObject *resultobj;
19727 wxFontList *arg1 = (wxFontList *) 0 ;
19728 int arg2 ;
19729 int arg3 ;
19730 int arg4 ;
19731 int arg5 ;
19732 bool arg6 = (bool) false ;
19733 wxString const &arg7_defvalue = wxPyEmptyString ;
19734 wxString *arg7 = (wxString *) &arg7_defvalue ;
19735 wxFontEncoding arg8 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
19736 wxFont *result;
19737 bool temp7 = false ;
19738 PyObject * obj0 = 0 ;
19739 PyObject * obj1 = 0 ;
19740 PyObject * obj2 = 0 ;
19741 PyObject * obj3 = 0 ;
19742 PyObject * obj4 = 0 ;
19743 PyObject * obj5 = 0 ;
19744 PyObject * obj6 = 0 ;
19745 PyObject * obj7 = 0 ;
19746 char *kwnames[] = {
19747 (char *) "self",(char *) "point_size",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "facename",(char *) "encoding", NULL
19748 };
19749
19750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:FontList_FindOrCreateFont",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
19751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
19752 if (SWIG_arg_fail(1)) SWIG_fail;
19753 {
19754 arg2 = (int)(SWIG_As_int(obj1));
19755 if (SWIG_arg_fail(2)) SWIG_fail;
19756 }
19757 {
19758 arg3 = (int)(SWIG_As_int(obj2));
19759 if (SWIG_arg_fail(3)) SWIG_fail;
19760 }
19761 {
19762 arg4 = (int)(SWIG_As_int(obj3));
19763 if (SWIG_arg_fail(4)) SWIG_fail;
19764 }
19765 {
19766 arg5 = (int)(SWIG_As_int(obj4));
19767 if (SWIG_arg_fail(5)) SWIG_fail;
19768 }
19769 if (obj5) {
19770 {
19771 arg6 = (bool)(SWIG_As_bool(obj5));
19772 if (SWIG_arg_fail(6)) SWIG_fail;
19773 }
19774 }
19775 if (obj6) {
19776 {
19777 arg7 = wxString_in_helper(obj6);
19778 if (arg7 == NULL) SWIG_fail;
19779 temp7 = true;
19780 }
19781 }
19782 if (obj7) {
19783 {
19784 arg8 = (wxFontEncoding)(SWIG_As_int(obj7));
19785 if (SWIG_arg_fail(8)) SWIG_fail;
19786 }
19787 }
19788 {
19789 PyThreadState* __tstate = wxPyBeginAllowThreads();
19790 result = (wxFont *)(arg1)->FindOrCreateFont(arg2,arg3,arg4,arg5,arg6,(wxString const &)*arg7,(wxFontEncoding )arg8);
19791
19792 wxPyEndAllowThreads(__tstate);
19793 if (PyErr_Occurred()) SWIG_fail;
19794 }
19795 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
19796 {
19797 if (temp7)
19798 delete arg7;
19799 }
19800 return resultobj;
19801 fail:
19802 {
19803 if (temp7)
19804 delete arg7;
19805 }
19806 return NULL;
19807 }
19808
19809
19810 static PyObject *_wrap_FontList_RemoveFont(PyObject *, PyObject *args, PyObject *kwargs) {
19811 PyObject *resultobj;
19812 wxFontList *arg1 = (wxFontList *) 0 ;
19813 wxFont *arg2 = (wxFont *) 0 ;
19814 PyObject * obj0 = 0 ;
19815 PyObject * obj1 = 0 ;
19816 char *kwnames[] = {
19817 (char *) "self",(char *) "font", NULL
19818 };
19819
19820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_RemoveFont",kwnames,&obj0,&obj1)) goto fail;
19821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
19822 if (SWIG_arg_fail(1)) SWIG_fail;
19823 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
19824 if (SWIG_arg_fail(2)) SWIG_fail;
19825 {
19826 PyThreadState* __tstate = wxPyBeginAllowThreads();
19827 (arg1)->RemoveFont(arg2);
19828
19829 wxPyEndAllowThreads(__tstate);
19830 if (PyErr_Occurred()) SWIG_fail;
19831 }
19832 Py_INCREF(Py_None); resultobj = Py_None;
19833 return resultobj;
19834 fail:
19835 return NULL;
19836 }
19837
19838
19839 static PyObject *_wrap_FontList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
19840 PyObject *resultobj;
19841 wxFontList *arg1 = (wxFontList *) 0 ;
19842 int result;
19843 PyObject * obj0 = 0 ;
19844 char *kwnames[] = {
19845 (char *) "self", NULL
19846 };
19847
19848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontList_GetCount",kwnames,&obj0)) goto fail;
19849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
19850 if (SWIG_arg_fail(1)) SWIG_fail;
19851 {
19852 PyThreadState* __tstate = wxPyBeginAllowThreads();
19853 result = (int)(arg1)->GetCount();
19854
19855 wxPyEndAllowThreads(__tstate);
19856 if (PyErr_Occurred()) SWIG_fail;
19857 }
19858 {
19859 resultobj = SWIG_From_int((int)(result));
19860 }
19861 return resultobj;
19862 fail:
19863 return NULL;
19864 }
19865
19866
19867 static PyObject * FontList_swigregister(PyObject *, PyObject *args) {
19868 PyObject *obj;
19869 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19870 SWIG_TypeClientData(SWIGTYPE_p_wxFontList, obj);
19871 Py_INCREF(obj);
19872 return Py_BuildValue((char *)"");
19873 }
19874 static int _wrap_TheFontList_set(PyObject *) {
19875 PyErr_SetString(PyExc_TypeError,"Variable TheFontList is read-only.");
19876 return 1;
19877 }
19878
19879
19880 static PyObject *_wrap_TheFontList_get(void) {
19881 PyObject *pyobj;
19882
19883 pyobj = SWIG_NewPointerObj((void *)(wxTheFontList), SWIGTYPE_p_wxFontList, 0);
19884 return pyobj;
19885 }
19886
19887
19888 static int _wrap_ThePenList_set(PyObject *) {
19889 PyErr_SetString(PyExc_TypeError,"Variable ThePenList is read-only.");
19890 return 1;
19891 }
19892
19893
19894 static PyObject *_wrap_ThePenList_get(void) {
19895 PyObject *pyobj;
19896
19897 pyobj = SWIG_NewPointerObj((void *)(wxThePenList), SWIGTYPE_p_wxPenList, 0);
19898 return pyobj;
19899 }
19900
19901
19902 static int _wrap_TheBrushList_set(PyObject *) {
19903 PyErr_SetString(PyExc_TypeError,"Variable TheBrushList is read-only.");
19904 return 1;
19905 }
19906
19907
19908 static PyObject *_wrap_TheBrushList_get(void) {
19909 PyObject *pyobj;
19910
19911 pyobj = SWIG_NewPointerObj((void *)(wxTheBrushList), SWIGTYPE_p_wxBrushList, 0);
19912 return pyobj;
19913 }
19914
19915
19916 static int _wrap_TheColourDatabase_set(PyObject *) {
19917 PyErr_SetString(PyExc_TypeError,"Variable TheColourDatabase is read-only.");
19918 return 1;
19919 }
19920
19921
19922 static PyObject *_wrap_TheColourDatabase_get(void) {
19923 PyObject *pyobj;
19924
19925 pyobj = SWIG_NewPointerObj((void *)(wxTheColourDatabase), SWIGTYPE_p_wxColourDatabase, 0);
19926 return pyobj;
19927 }
19928
19929
19930 static PyObject *_wrap_new_Effects(PyObject *, PyObject *args, PyObject *kwargs) {
19931 PyObject *resultobj;
19932 wxEffects *result;
19933 char *kwnames[] = {
19934 NULL
19935 };
19936
19937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Effects",kwnames)) goto fail;
19938 {
19939 PyThreadState* __tstate = wxPyBeginAllowThreads();
19940 result = (wxEffects *)new wxEffects();
19941
19942 wxPyEndAllowThreads(__tstate);
19943 if (PyErr_Occurred()) SWIG_fail;
19944 }
19945 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEffects, 1);
19946 return resultobj;
19947 fail:
19948 return NULL;
19949 }
19950
19951
19952 static PyObject *_wrap_Effects_GetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
19953 PyObject *resultobj;
19954 wxEffects *arg1 = (wxEffects *) 0 ;
19955 wxColour result;
19956 PyObject * obj0 = 0 ;
19957 char *kwnames[] = {
19958 (char *) "self", NULL
19959 };
19960
19961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetHighlightColour",kwnames,&obj0)) goto fail;
19962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
19963 if (SWIG_arg_fail(1)) SWIG_fail;
19964 {
19965 PyThreadState* __tstate = wxPyBeginAllowThreads();
19966 result = ((wxEffects const *)arg1)->GetHighlightColour();
19967
19968 wxPyEndAllowThreads(__tstate);
19969 if (PyErr_Occurred()) SWIG_fail;
19970 }
19971 {
19972 wxColour * resultptr;
19973 resultptr = new wxColour((wxColour &)(result));
19974 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
19975 }
19976 return resultobj;
19977 fail:
19978 return NULL;
19979 }
19980
19981
19982 static PyObject *_wrap_Effects_GetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
19983 PyObject *resultobj;
19984 wxEffects *arg1 = (wxEffects *) 0 ;
19985 wxColour result;
19986 PyObject * obj0 = 0 ;
19987 char *kwnames[] = {
19988 (char *) "self", NULL
19989 };
19990
19991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetLightShadow",kwnames,&obj0)) goto fail;
19992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
19993 if (SWIG_arg_fail(1)) SWIG_fail;
19994 {
19995 PyThreadState* __tstate = wxPyBeginAllowThreads();
19996 result = ((wxEffects const *)arg1)->GetLightShadow();
19997
19998 wxPyEndAllowThreads(__tstate);
19999 if (PyErr_Occurred()) SWIG_fail;
20000 }
20001 {
20002 wxColour * resultptr;
20003 resultptr = new wxColour((wxColour &)(result));
20004 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20005 }
20006 return resultobj;
20007 fail:
20008 return NULL;
20009 }
20010
20011
20012 static PyObject *_wrap_Effects_GetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
20013 PyObject *resultobj;
20014 wxEffects *arg1 = (wxEffects *) 0 ;
20015 wxColour result;
20016 PyObject * obj0 = 0 ;
20017 char *kwnames[] = {
20018 (char *) "self", NULL
20019 };
20020
20021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetFaceColour",kwnames,&obj0)) goto fail;
20022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20023 if (SWIG_arg_fail(1)) SWIG_fail;
20024 {
20025 PyThreadState* __tstate = wxPyBeginAllowThreads();
20026 result = ((wxEffects const *)arg1)->GetFaceColour();
20027
20028 wxPyEndAllowThreads(__tstate);
20029 if (PyErr_Occurred()) SWIG_fail;
20030 }
20031 {
20032 wxColour * resultptr;
20033 resultptr = new wxColour((wxColour &)(result));
20034 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20035 }
20036 return resultobj;
20037 fail:
20038 return NULL;
20039 }
20040
20041
20042 static PyObject *_wrap_Effects_GetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20043 PyObject *resultobj;
20044 wxEffects *arg1 = (wxEffects *) 0 ;
20045 wxColour result;
20046 PyObject * obj0 = 0 ;
20047 char *kwnames[] = {
20048 (char *) "self", NULL
20049 };
20050
20051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetMediumShadow",kwnames,&obj0)) goto fail;
20052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20053 if (SWIG_arg_fail(1)) SWIG_fail;
20054 {
20055 PyThreadState* __tstate = wxPyBeginAllowThreads();
20056 result = ((wxEffects const *)arg1)->GetMediumShadow();
20057
20058 wxPyEndAllowThreads(__tstate);
20059 if (PyErr_Occurred()) SWIG_fail;
20060 }
20061 {
20062 wxColour * resultptr;
20063 resultptr = new wxColour((wxColour &)(result));
20064 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20065 }
20066 return resultobj;
20067 fail:
20068 return NULL;
20069 }
20070
20071
20072 static PyObject *_wrap_Effects_GetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20073 PyObject *resultobj;
20074 wxEffects *arg1 = (wxEffects *) 0 ;
20075 wxColour result;
20076 PyObject * obj0 = 0 ;
20077 char *kwnames[] = {
20078 (char *) "self", NULL
20079 };
20080
20081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetDarkShadow",kwnames,&obj0)) goto fail;
20082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20083 if (SWIG_arg_fail(1)) SWIG_fail;
20084 {
20085 PyThreadState* __tstate = wxPyBeginAllowThreads();
20086 result = ((wxEffects const *)arg1)->GetDarkShadow();
20087
20088 wxPyEndAllowThreads(__tstate);
20089 if (PyErr_Occurred()) SWIG_fail;
20090 }
20091 {
20092 wxColour * resultptr;
20093 resultptr = new wxColour((wxColour &)(result));
20094 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20095 }
20096 return resultobj;
20097 fail:
20098 return NULL;
20099 }
20100
20101
20102 static PyObject *_wrap_Effects_SetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
20103 PyObject *resultobj;
20104 wxEffects *arg1 = (wxEffects *) 0 ;
20105 wxColour *arg2 = 0 ;
20106 wxColour temp2 ;
20107 PyObject * obj0 = 0 ;
20108 PyObject * obj1 = 0 ;
20109 char *kwnames[] = {
20110 (char *) "self",(char *) "c", NULL
20111 };
20112
20113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetHighlightColour",kwnames,&obj0,&obj1)) goto fail;
20114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20115 if (SWIG_arg_fail(1)) SWIG_fail;
20116 {
20117 arg2 = &temp2;
20118 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20119 }
20120 {
20121 PyThreadState* __tstate = wxPyBeginAllowThreads();
20122 (arg1)->SetHighlightColour((wxColour const &)*arg2);
20123
20124 wxPyEndAllowThreads(__tstate);
20125 if (PyErr_Occurred()) SWIG_fail;
20126 }
20127 Py_INCREF(Py_None); resultobj = Py_None;
20128 return resultobj;
20129 fail:
20130 return NULL;
20131 }
20132
20133
20134 static PyObject *_wrap_Effects_SetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20135 PyObject *resultobj;
20136 wxEffects *arg1 = (wxEffects *) 0 ;
20137 wxColour *arg2 = 0 ;
20138 wxColour temp2 ;
20139 PyObject * obj0 = 0 ;
20140 PyObject * obj1 = 0 ;
20141 char *kwnames[] = {
20142 (char *) "self",(char *) "c", NULL
20143 };
20144
20145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetLightShadow",kwnames,&obj0,&obj1)) goto fail;
20146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20147 if (SWIG_arg_fail(1)) SWIG_fail;
20148 {
20149 arg2 = &temp2;
20150 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20151 }
20152 {
20153 PyThreadState* __tstate = wxPyBeginAllowThreads();
20154 (arg1)->SetLightShadow((wxColour const &)*arg2);
20155
20156 wxPyEndAllowThreads(__tstate);
20157 if (PyErr_Occurred()) SWIG_fail;
20158 }
20159 Py_INCREF(Py_None); resultobj = Py_None;
20160 return resultobj;
20161 fail:
20162 return NULL;
20163 }
20164
20165
20166 static PyObject *_wrap_Effects_SetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
20167 PyObject *resultobj;
20168 wxEffects *arg1 = (wxEffects *) 0 ;
20169 wxColour *arg2 = 0 ;
20170 wxColour temp2 ;
20171 PyObject * obj0 = 0 ;
20172 PyObject * obj1 = 0 ;
20173 char *kwnames[] = {
20174 (char *) "self",(char *) "c", NULL
20175 };
20176
20177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetFaceColour",kwnames,&obj0,&obj1)) goto fail;
20178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20179 if (SWIG_arg_fail(1)) SWIG_fail;
20180 {
20181 arg2 = &temp2;
20182 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20183 }
20184 {
20185 PyThreadState* __tstate = wxPyBeginAllowThreads();
20186 (arg1)->SetFaceColour((wxColour const &)*arg2);
20187
20188 wxPyEndAllowThreads(__tstate);
20189 if (PyErr_Occurred()) SWIG_fail;
20190 }
20191 Py_INCREF(Py_None); resultobj = Py_None;
20192 return resultobj;
20193 fail:
20194 return NULL;
20195 }
20196
20197
20198 static PyObject *_wrap_Effects_SetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20199 PyObject *resultobj;
20200 wxEffects *arg1 = (wxEffects *) 0 ;
20201 wxColour *arg2 = 0 ;
20202 wxColour temp2 ;
20203 PyObject * obj0 = 0 ;
20204 PyObject * obj1 = 0 ;
20205 char *kwnames[] = {
20206 (char *) "self",(char *) "c", NULL
20207 };
20208
20209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetMediumShadow",kwnames,&obj0,&obj1)) goto fail;
20210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20211 if (SWIG_arg_fail(1)) SWIG_fail;
20212 {
20213 arg2 = &temp2;
20214 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20215 }
20216 {
20217 PyThreadState* __tstate = wxPyBeginAllowThreads();
20218 (arg1)->SetMediumShadow((wxColour const &)*arg2);
20219
20220 wxPyEndAllowThreads(__tstate);
20221 if (PyErr_Occurred()) SWIG_fail;
20222 }
20223 Py_INCREF(Py_None); resultobj = Py_None;
20224 return resultobj;
20225 fail:
20226 return NULL;
20227 }
20228
20229
20230 static PyObject *_wrap_Effects_SetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20231 PyObject *resultobj;
20232 wxEffects *arg1 = (wxEffects *) 0 ;
20233 wxColour *arg2 = 0 ;
20234 wxColour temp2 ;
20235 PyObject * obj0 = 0 ;
20236 PyObject * obj1 = 0 ;
20237 char *kwnames[] = {
20238 (char *) "self",(char *) "c", NULL
20239 };
20240
20241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetDarkShadow",kwnames,&obj0,&obj1)) goto fail;
20242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20243 if (SWIG_arg_fail(1)) SWIG_fail;
20244 {
20245 arg2 = &temp2;
20246 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20247 }
20248 {
20249 PyThreadState* __tstate = wxPyBeginAllowThreads();
20250 (arg1)->SetDarkShadow((wxColour const &)*arg2);
20251
20252 wxPyEndAllowThreads(__tstate);
20253 if (PyErr_Occurred()) SWIG_fail;
20254 }
20255 Py_INCREF(Py_None); resultobj = Py_None;
20256 return resultobj;
20257 fail:
20258 return NULL;
20259 }
20260
20261
20262 static PyObject *_wrap_Effects_Set(PyObject *, PyObject *args, PyObject *kwargs) {
20263 PyObject *resultobj;
20264 wxEffects *arg1 = (wxEffects *) 0 ;
20265 wxColour *arg2 = 0 ;
20266 wxColour *arg3 = 0 ;
20267 wxColour *arg4 = 0 ;
20268 wxColour *arg5 = 0 ;
20269 wxColour *arg6 = 0 ;
20270 wxColour temp2 ;
20271 wxColour temp3 ;
20272 wxColour temp4 ;
20273 wxColour temp5 ;
20274 wxColour temp6 ;
20275 PyObject * obj0 = 0 ;
20276 PyObject * obj1 = 0 ;
20277 PyObject * obj2 = 0 ;
20278 PyObject * obj3 = 0 ;
20279 PyObject * obj4 = 0 ;
20280 PyObject * obj5 = 0 ;
20281 char *kwnames[] = {
20282 (char *) "self",(char *) "highlightColour",(char *) "lightShadow",(char *) "faceColour",(char *) "mediumShadow",(char *) "darkShadow", NULL
20283 };
20284
20285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Effects_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
20286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20287 if (SWIG_arg_fail(1)) SWIG_fail;
20288 {
20289 arg2 = &temp2;
20290 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20291 }
20292 {
20293 arg3 = &temp3;
20294 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
20295 }
20296 {
20297 arg4 = &temp4;
20298 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
20299 }
20300 {
20301 arg5 = &temp5;
20302 if ( ! wxColour_helper(obj4, &arg5)) SWIG_fail;
20303 }
20304 {
20305 arg6 = &temp6;
20306 if ( ! wxColour_helper(obj5, &arg6)) SWIG_fail;
20307 }
20308 {
20309 PyThreadState* __tstate = wxPyBeginAllowThreads();
20310 (arg1)->Set((wxColour const &)*arg2,(wxColour const &)*arg3,(wxColour const &)*arg4,(wxColour const &)*arg5,(wxColour const &)*arg6);
20311
20312 wxPyEndAllowThreads(__tstate);
20313 if (PyErr_Occurred()) SWIG_fail;
20314 }
20315 Py_INCREF(Py_None); resultobj = Py_None;
20316 return resultobj;
20317 fail:
20318 return NULL;
20319 }
20320
20321
20322 static PyObject *_wrap_Effects_DrawSunkenEdge(PyObject *, PyObject *args, PyObject *kwargs) {
20323 PyObject *resultobj;
20324 wxEffects *arg1 = (wxEffects *) 0 ;
20325 wxDC *arg2 = 0 ;
20326 wxRect *arg3 = 0 ;
20327 int arg4 = (int) 1 ;
20328 wxRect temp3 ;
20329 PyObject * obj0 = 0 ;
20330 PyObject * obj1 = 0 ;
20331 PyObject * obj2 = 0 ;
20332 PyObject * obj3 = 0 ;
20333 char *kwnames[] = {
20334 (char *) "self",(char *) "dc",(char *) "rect",(char *) "borderSize", NULL
20335 };
20336
20337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Effects_DrawSunkenEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20339 if (SWIG_arg_fail(1)) SWIG_fail;
20340 {
20341 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20342 if (SWIG_arg_fail(2)) SWIG_fail;
20343 if (arg2 == NULL) {
20344 SWIG_null_ref("wxDC");
20345 }
20346 if (SWIG_arg_fail(2)) SWIG_fail;
20347 }
20348 {
20349 arg3 = &temp3;
20350 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
20351 }
20352 if (obj3) {
20353 {
20354 arg4 = (int)(SWIG_As_int(obj3));
20355 if (SWIG_arg_fail(4)) SWIG_fail;
20356 }
20357 }
20358 {
20359 PyThreadState* __tstate = wxPyBeginAllowThreads();
20360 (arg1)->DrawSunkenEdge(*arg2,(wxRect const &)*arg3,arg4);
20361
20362 wxPyEndAllowThreads(__tstate);
20363 if (PyErr_Occurred()) SWIG_fail;
20364 }
20365 Py_INCREF(Py_None); resultobj = Py_None;
20366 return resultobj;
20367 fail:
20368 return NULL;
20369 }
20370
20371
20372 static PyObject *_wrap_Effects_TileBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
20373 PyObject *resultobj;
20374 wxEffects *arg1 = (wxEffects *) 0 ;
20375 wxRect *arg2 = 0 ;
20376 wxDC *arg3 = 0 ;
20377 wxBitmap *arg4 = 0 ;
20378 bool result;
20379 wxRect temp2 ;
20380 PyObject * obj0 = 0 ;
20381 PyObject * obj1 = 0 ;
20382 PyObject * obj2 = 0 ;
20383 PyObject * obj3 = 0 ;
20384 char *kwnames[] = {
20385 (char *) "self",(char *) "rect",(char *) "dc",(char *) "bitmap", NULL
20386 };
20387
20388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Effects_TileBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20390 if (SWIG_arg_fail(1)) SWIG_fail;
20391 {
20392 arg2 = &temp2;
20393 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
20394 }
20395 {
20396 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20397 if (SWIG_arg_fail(3)) SWIG_fail;
20398 if (arg3 == NULL) {
20399 SWIG_null_ref("wxDC");
20400 }
20401 if (SWIG_arg_fail(3)) SWIG_fail;
20402 }
20403 {
20404 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
20405 if (SWIG_arg_fail(4)) SWIG_fail;
20406 if (arg4 == NULL) {
20407 SWIG_null_ref("wxBitmap");
20408 }
20409 if (SWIG_arg_fail(4)) SWIG_fail;
20410 }
20411 {
20412 PyThreadState* __tstate = wxPyBeginAllowThreads();
20413 result = (bool)(arg1)->TileBitmap((wxRect const &)*arg2,*arg3,*arg4);
20414
20415 wxPyEndAllowThreads(__tstate);
20416 if (PyErr_Occurred()) SWIG_fail;
20417 }
20418 {
20419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20420 }
20421 return resultobj;
20422 fail:
20423 return NULL;
20424 }
20425
20426
20427 static PyObject * Effects_swigregister(PyObject *, PyObject *args) {
20428 PyObject *obj;
20429 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20430 SWIG_TypeClientData(SWIGTYPE_p_wxEffects, obj);
20431 Py_INCREF(obj);
20432 return Py_BuildValue((char *)"");
20433 }
20434 static PyMethodDef SwigMethods[] = {
20435 { (char *)"new_GDIObject", (PyCFunction) _wrap_new_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
20436 { (char *)"delete_GDIObject", (PyCFunction) _wrap_delete_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
20437 { (char *)"GDIObject_GetVisible", (PyCFunction) _wrap_GDIObject_GetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20438 { (char *)"GDIObject_SetVisible", (PyCFunction) _wrap_GDIObject_SetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20439 { (char *)"GDIObject_IsNull", (PyCFunction) _wrap_GDIObject_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
20440 { (char *)"GDIObject_swigregister", GDIObject_swigregister, METH_VARARGS, NULL},
20441 { (char *)"new_Colour", (PyCFunction) _wrap_new_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
20442 { (char *)"new_NamedColour", (PyCFunction) _wrap_new_NamedColour, METH_VARARGS | METH_KEYWORDS, NULL},
20443 { (char *)"new_ColourRGB", (PyCFunction) _wrap_new_ColourRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20444 { (char *)"delete_Colour", (PyCFunction) _wrap_delete_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
20445 { (char *)"Colour_Red", (PyCFunction) _wrap_Colour_Red, METH_VARARGS | METH_KEYWORDS, NULL},
20446 { (char *)"Colour_Green", (PyCFunction) _wrap_Colour_Green, METH_VARARGS | METH_KEYWORDS, NULL},
20447 { (char *)"Colour_Blue", (PyCFunction) _wrap_Colour_Blue, METH_VARARGS | METH_KEYWORDS, NULL},
20448 { (char *)"Colour_Ok", (PyCFunction) _wrap_Colour_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20449 { (char *)"Colour_Set", (PyCFunction) _wrap_Colour_Set, METH_VARARGS | METH_KEYWORDS, NULL},
20450 { (char *)"Colour_SetRGB", (PyCFunction) _wrap_Colour_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20451 { (char *)"Colour_SetFromName", (PyCFunction) _wrap_Colour_SetFromName, METH_VARARGS | METH_KEYWORDS, NULL},
20452 { (char *)"Colour_GetPixel", (PyCFunction) _wrap_Colour_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
20453 { (char *)"Colour___eq__", (PyCFunction) _wrap_Colour___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20454 { (char *)"Colour___ne__", (PyCFunction) _wrap_Colour___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20455 { (char *)"Colour_Get", (PyCFunction) _wrap_Colour_Get, METH_VARARGS | METH_KEYWORDS, NULL},
20456 { (char *)"Colour_GetRGB", (PyCFunction) _wrap_Colour_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20457 { (char *)"Colour_swigregister", Colour_swigregister, METH_VARARGS, NULL},
20458 { (char *)"new_Palette", (PyCFunction) _wrap_new_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
20459 { (char *)"delete_Palette", (PyCFunction) _wrap_delete_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
20460 { (char *)"Palette_GetPixel", (PyCFunction) _wrap_Palette_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
20461 { (char *)"Palette_GetRGB", (PyCFunction) _wrap_Palette_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20462 { (char *)"Palette_GetColoursCount", (PyCFunction) _wrap_Palette_GetColoursCount, METH_VARARGS | METH_KEYWORDS, NULL},
20463 { (char *)"Palette_Ok", (PyCFunction) _wrap_Palette_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20464 { (char *)"Palette_swigregister", Palette_swigregister, METH_VARARGS, NULL},
20465 { (char *)"new_Pen", (PyCFunction) _wrap_new_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
20466 { (char *)"delete_Pen", (PyCFunction) _wrap_delete_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
20467 { (char *)"Pen_GetCap", (PyCFunction) _wrap_Pen_GetCap, METH_VARARGS | METH_KEYWORDS, NULL},
20468 { (char *)"Pen_GetColour", (PyCFunction) _wrap_Pen_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20469 { (char *)"Pen_GetJoin", (PyCFunction) _wrap_Pen_GetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
20470 { (char *)"Pen_GetStyle", (PyCFunction) _wrap_Pen_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20471 { (char *)"Pen_GetWidth", (PyCFunction) _wrap_Pen_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20472 { (char *)"Pen_Ok", (PyCFunction) _wrap_Pen_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20473 { (char *)"Pen_SetCap", (PyCFunction) _wrap_Pen_SetCap, METH_VARARGS | METH_KEYWORDS, NULL},
20474 { (char *)"Pen_SetColour", (PyCFunction) _wrap_Pen_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20475 { (char *)"Pen_SetJoin", (PyCFunction) _wrap_Pen_SetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
20476 { (char *)"Pen_SetStyle", (PyCFunction) _wrap_Pen_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20477 { (char *)"Pen_SetWidth", (PyCFunction) _wrap_Pen_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20478 { (char *)"Pen_SetDashes", (PyCFunction) _wrap_Pen_SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
20479 { (char *)"Pen_GetDashes", (PyCFunction) _wrap_Pen_GetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
20480 { (char *)"Pen__SetDashes", (PyCFunction) _wrap_Pen__SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
20481 { (char *)"Pen_GetDashCount", (PyCFunction) _wrap_Pen_GetDashCount, METH_VARARGS | METH_KEYWORDS, NULL},
20482 { (char *)"Pen___eq__", (PyCFunction) _wrap_Pen___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20483 { (char *)"Pen___ne__", (PyCFunction) _wrap_Pen___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20484 { (char *)"Pen_swigregister", Pen_swigregister, METH_VARARGS, NULL},
20485 { (char *)"new_Brush", (PyCFunction) _wrap_new_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
20486 { (char *)"delete_Brush", (PyCFunction) _wrap_delete_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
20487 { (char *)"Brush_SetColour", (PyCFunction) _wrap_Brush_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20488 { (char *)"Brush_SetStyle", (PyCFunction) _wrap_Brush_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20489 { (char *)"Brush_SetStipple", (PyCFunction) _wrap_Brush_SetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
20490 { (char *)"Brush_GetColour", (PyCFunction) _wrap_Brush_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20491 { (char *)"Brush_GetStyle", (PyCFunction) _wrap_Brush_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20492 { (char *)"Brush_GetStipple", (PyCFunction) _wrap_Brush_GetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
20493 { (char *)"Brush_IsHatch", (PyCFunction) _wrap_Brush_IsHatch, METH_VARARGS | METH_KEYWORDS, NULL},
20494 { (char *)"Brush_Ok", (PyCFunction) _wrap_Brush_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20495 { (char *)"Brush_swigregister", Brush_swigregister, METH_VARARGS, NULL},
20496 { (char *)"new_Bitmap", (PyCFunction) _wrap_new_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20497 { (char *)"delete_Bitmap", (PyCFunction) _wrap_delete_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20498 { (char *)"new_EmptyBitmap", (PyCFunction) _wrap_new_EmptyBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20499 { (char *)"new_BitmapFromIcon", (PyCFunction) _wrap_new_BitmapFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20500 { (char *)"new_BitmapFromImage", (PyCFunction) _wrap_new_BitmapFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
20501 { (char *)"new_BitmapFromXPMData", (PyCFunction) _wrap_new_BitmapFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
20502 { (char *)"new_BitmapFromBits", (PyCFunction) _wrap_new_BitmapFromBits, METH_VARARGS | METH_KEYWORDS, NULL},
20503 { (char *)"Bitmap_Ok", (PyCFunction) _wrap_Bitmap_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20504 { (char *)"Bitmap_GetWidth", (PyCFunction) _wrap_Bitmap_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20505 { (char *)"Bitmap_GetHeight", (PyCFunction) _wrap_Bitmap_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20506 { (char *)"Bitmap_GetDepth", (PyCFunction) _wrap_Bitmap_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20507 { (char *)"Bitmap_GetSize", (PyCFunction) _wrap_Bitmap_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20508 { (char *)"Bitmap_ConvertToImage", (PyCFunction) _wrap_Bitmap_ConvertToImage, METH_VARARGS | METH_KEYWORDS, NULL},
20509 { (char *)"Bitmap_GetMask", (PyCFunction) _wrap_Bitmap_GetMask, METH_VARARGS | METH_KEYWORDS, NULL},
20510 { (char *)"Bitmap_SetMask", (PyCFunction) _wrap_Bitmap_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
20511 { (char *)"Bitmap_SetMaskColour", (PyCFunction) _wrap_Bitmap_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
20512 { (char *)"Bitmap_GetSubBitmap", (PyCFunction) _wrap_Bitmap_GetSubBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20513 { (char *)"Bitmap_SaveFile", (PyCFunction) _wrap_Bitmap_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
20514 { (char *)"Bitmap_LoadFile", (PyCFunction) _wrap_Bitmap_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
20515 { (char *)"Bitmap_GetPalette", (PyCFunction) _wrap_Bitmap_GetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
20516 { (char *)"Bitmap_CopyFromIcon", (PyCFunction) _wrap_Bitmap_CopyFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20517 { (char *)"Bitmap_SetHeight", (PyCFunction) _wrap_Bitmap_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20518 { (char *)"Bitmap_SetWidth", (PyCFunction) _wrap_Bitmap_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20519 { (char *)"Bitmap_SetDepth", (PyCFunction) _wrap_Bitmap_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20520 { (char *)"Bitmap_SetSize", (PyCFunction) _wrap_Bitmap_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20521 { (char *)"Bitmap___eq__", (PyCFunction) _wrap_Bitmap___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20522 { (char *)"Bitmap___ne__", (PyCFunction) _wrap_Bitmap___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20523 { (char *)"Bitmap_swigregister", Bitmap_swigregister, METH_VARARGS, NULL},
20524 { (char *)"new_Mask", (PyCFunction) _wrap_new_Mask, METH_VARARGS | METH_KEYWORDS, NULL},
20525 { (char *)"Mask_swigregister", Mask_swigregister, METH_VARARGS, NULL},
20526 { (char *)"new_Icon", (PyCFunction) _wrap_new_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
20527 { (char *)"delete_Icon", (PyCFunction) _wrap_delete_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
20528 { (char *)"new_EmptyIcon", (PyCFunction) _wrap_new_EmptyIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20529 { (char *)"new_IconFromLocation", (PyCFunction) _wrap_new_IconFromLocation, METH_VARARGS | METH_KEYWORDS, NULL},
20530 { (char *)"new_IconFromBitmap", (PyCFunction) _wrap_new_IconFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20531 { (char *)"new_IconFromXPMData", (PyCFunction) _wrap_new_IconFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
20532 { (char *)"Icon_LoadFile", (PyCFunction) _wrap_Icon_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
20533 { (char *)"Icon_Ok", (PyCFunction) _wrap_Icon_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20534 { (char *)"Icon_GetWidth", (PyCFunction) _wrap_Icon_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20535 { (char *)"Icon_GetHeight", (PyCFunction) _wrap_Icon_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20536 { (char *)"Icon_GetDepth", (PyCFunction) _wrap_Icon_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20537 { (char *)"Icon_SetWidth", (PyCFunction) _wrap_Icon_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20538 { (char *)"Icon_SetHeight", (PyCFunction) _wrap_Icon_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20539 { (char *)"Icon_SetDepth", (PyCFunction) _wrap_Icon_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20540 { (char *)"Icon_CopyFromBitmap", (PyCFunction) _wrap_Icon_CopyFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20541 { (char *)"Icon_swigregister", Icon_swigregister, METH_VARARGS, NULL},
20542 { (char *)"new_IconLocation", (PyCFunction) _wrap_new_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
20543 { (char *)"delete_IconLocation", (PyCFunction) _wrap_delete_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
20544 { (char *)"IconLocation_IsOk", (PyCFunction) _wrap_IconLocation_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
20545 { (char *)"IconLocation_SetFileName", (PyCFunction) _wrap_IconLocation_SetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
20546 { (char *)"IconLocation_GetFileName", (PyCFunction) _wrap_IconLocation_GetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
20547 { (char *)"IconLocation_SetIndex", (PyCFunction) _wrap_IconLocation_SetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
20548 { (char *)"IconLocation_GetIndex", (PyCFunction) _wrap_IconLocation_GetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
20549 { (char *)"IconLocation_swigregister", IconLocation_swigregister, METH_VARARGS, NULL},
20550 { (char *)"new_IconBundle", (PyCFunction) _wrap_new_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
20551 { (char *)"new_IconBundleFromFile", (PyCFunction) _wrap_new_IconBundleFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
20552 { (char *)"new_IconBundleFromIcon", (PyCFunction) _wrap_new_IconBundleFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20553 { (char *)"delete_IconBundle", (PyCFunction) _wrap_delete_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
20554 { (char *)"IconBundle_AddIcon", (PyCFunction) _wrap_IconBundle_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20555 { (char *)"IconBundle_AddIconFromFile", (PyCFunction) _wrap_IconBundle_AddIconFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
20556 { (char *)"IconBundle_GetIcon", (PyCFunction) _wrap_IconBundle_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20557 { (char *)"IconBundle_swigregister", IconBundle_swigregister, METH_VARARGS, NULL},
20558 { (char *)"new_Cursor", (PyCFunction) _wrap_new_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
20559 { (char *)"delete_Cursor", (PyCFunction) _wrap_delete_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
20560 { (char *)"new_StockCursor", (PyCFunction) _wrap_new_StockCursor, METH_VARARGS | METH_KEYWORDS, NULL},
20561 { (char *)"new_CursorFromImage", (PyCFunction) _wrap_new_CursorFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
20562 { (char *)"Cursor_Ok", (PyCFunction) _wrap_Cursor_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20563 { (char *)"Cursor_swigregister", Cursor_swigregister, METH_VARARGS, NULL},
20564 { (char *)"new_Region", (PyCFunction) _wrap_new_Region, METH_VARARGS | METH_KEYWORDS, NULL},
20565 { (char *)"new_RegionFromBitmap", (PyCFunction) _wrap_new_RegionFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20566 { (char *)"new_RegionFromBitmapColour", (PyCFunction) _wrap_new_RegionFromBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
20567 { (char *)"new_RegionFromPoints", (PyCFunction) _wrap_new_RegionFromPoints, METH_VARARGS | METH_KEYWORDS, NULL},
20568 { (char *)"delete_Region", (PyCFunction) _wrap_delete_Region, METH_VARARGS | METH_KEYWORDS, NULL},
20569 { (char *)"Region_Clear", (PyCFunction) _wrap_Region_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
20570 { (char *)"Region_Offset", (PyCFunction) _wrap_Region_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
20571 { (char *)"Region_Contains", (PyCFunction) _wrap_Region_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
20572 { (char *)"Region_ContainsPoint", (PyCFunction) _wrap_Region_ContainsPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20573 { (char *)"Region_ContainsRect", (PyCFunction) _wrap_Region_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
20574 { (char *)"Region_ContainsRectDim", (PyCFunction) _wrap_Region_ContainsRectDim, METH_VARARGS | METH_KEYWORDS, NULL},
20575 { (char *)"Region_GetBox", (PyCFunction) _wrap_Region_GetBox, METH_VARARGS | METH_KEYWORDS, NULL},
20576 { (char *)"Region_Intersect", (PyCFunction) _wrap_Region_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
20577 { (char *)"Region_IntersectRect", (PyCFunction) _wrap_Region_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
20578 { (char *)"Region_IntersectRegion", (PyCFunction) _wrap_Region_IntersectRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20579 { (char *)"Region_IsEmpty", (PyCFunction) _wrap_Region_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
20580 { (char *)"Region_Union", (PyCFunction) _wrap_Region_Union, METH_VARARGS | METH_KEYWORDS, NULL},
20581 { (char *)"Region_UnionRect", (PyCFunction) _wrap_Region_UnionRect, METH_VARARGS | METH_KEYWORDS, NULL},
20582 { (char *)"Region_UnionRegion", (PyCFunction) _wrap_Region_UnionRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20583 { (char *)"Region_Subtract", (PyCFunction) _wrap_Region_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
20584 { (char *)"Region_SubtractRect", (PyCFunction) _wrap_Region_SubtractRect, METH_VARARGS | METH_KEYWORDS, NULL},
20585 { (char *)"Region_SubtractRegion", (PyCFunction) _wrap_Region_SubtractRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20586 { (char *)"Region_Xor", (PyCFunction) _wrap_Region_Xor, METH_VARARGS | METH_KEYWORDS, NULL},
20587 { (char *)"Region_XorRect", (PyCFunction) _wrap_Region_XorRect, METH_VARARGS | METH_KEYWORDS, NULL},
20588 { (char *)"Region_XorRegion", (PyCFunction) _wrap_Region_XorRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20589 { (char *)"Region_ConvertToBitmap", (PyCFunction) _wrap_Region_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20590 { (char *)"Region_UnionBitmap", (PyCFunction) _wrap_Region_UnionBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20591 { (char *)"Region_UnionBitmapColour", (PyCFunction) _wrap_Region_UnionBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
20592 { (char *)"Region_swigregister", Region_swigregister, METH_VARARGS, NULL},
20593 { (char *)"new_RegionIterator", (PyCFunction) _wrap_new_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
20594 { (char *)"delete_RegionIterator", (PyCFunction) _wrap_delete_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
20595 { (char *)"RegionIterator_GetX", (PyCFunction) _wrap_RegionIterator_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
20596 { (char *)"RegionIterator_GetY", (PyCFunction) _wrap_RegionIterator_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
20597 { (char *)"RegionIterator_GetW", (PyCFunction) _wrap_RegionIterator_GetW, METH_VARARGS | METH_KEYWORDS, NULL},
20598 { (char *)"RegionIterator_GetWidth", (PyCFunction) _wrap_RegionIterator_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20599 { (char *)"RegionIterator_GetH", (PyCFunction) _wrap_RegionIterator_GetH, METH_VARARGS | METH_KEYWORDS, NULL},
20600 { (char *)"RegionIterator_GetHeight", (PyCFunction) _wrap_RegionIterator_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20601 { (char *)"RegionIterator_GetRect", (PyCFunction) _wrap_RegionIterator_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
20602 { (char *)"RegionIterator_HaveRects", (PyCFunction) _wrap_RegionIterator_HaveRects, METH_VARARGS | METH_KEYWORDS, NULL},
20603 { (char *)"RegionIterator_Reset", (PyCFunction) _wrap_RegionIterator_Reset, METH_VARARGS | METH_KEYWORDS, NULL},
20604 { (char *)"RegionIterator_Next", (PyCFunction) _wrap_RegionIterator_Next, METH_VARARGS | METH_KEYWORDS, NULL},
20605 { (char *)"RegionIterator___nonzero__", (PyCFunction) _wrap_RegionIterator___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
20606 { (char *)"RegionIterator_swigregister", RegionIterator_swigregister, METH_VARARGS, NULL},
20607 { (char *)"new_NativeFontInfo", (PyCFunction) _wrap_new_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20608 { (char *)"delete_NativeFontInfo", (PyCFunction) _wrap_delete_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20609 { (char *)"NativeFontInfo_Init", (PyCFunction) _wrap_NativeFontInfo_Init, METH_VARARGS | METH_KEYWORDS, NULL},
20610 { (char *)"NativeFontInfo_InitFromFont", (PyCFunction) _wrap_NativeFontInfo_InitFromFont, METH_VARARGS | METH_KEYWORDS, NULL},
20611 { (char *)"NativeFontInfo_GetPointSize", (PyCFunction) _wrap_NativeFontInfo_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20612 { (char *)"NativeFontInfo_GetStyle", (PyCFunction) _wrap_NativeFontInfo_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20613 { (char *)"NativeFontInfo_GetWeight", (PyCFunction) _wrap_NativeFontInfo_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20614 { (char *)"NativeFontInfo_GetUnderlined", (PyCFunction) _wrap_NativeFontInfo_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20615 { (char *)"NativeFontInfo_GetFaceName", (PyCFunction) _wrap_NativeFontInfo_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20616 { (char *)"NativeFontInfo_GetFamily", (PyCFunction) _wrap_NativeFontInfo_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20617 { (char *)"NativeFontInfo_GetEncoding", (PyCFunction) _wrap_NativeFontInfo_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20618 { (char *)"NativeFontInfo_SetPointSize", (PyCFunction) _wrap_NativeFontInfo_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20619 { (char *)"NativeFontInfo_SetStyle", (PyCFunction) _wrap_NativeFontInfo_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20620 { (char *)"NativeFontInfo_SetWeight", (PyCFunction) _wrap_NativeFontInfo_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20621 { (char *)"NativeFontInfo_SetUnderlined", (PyCFunction) _wrap_NativeFontInfo_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20622 { (char *)"NativeFontInfo_SetFaceName", (PyCFunction) _wrap_NativeFontInfo_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20623 { (char *)"NativeFontInfo_SetFamily", (PyCFunction) _wrap_NativeFontInfo_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20624 { (char *)"NativeFontInfo_SetEncoding", (PyCFunction) _wrap_NativeFontInfo_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20625 { (char *)"NativeFontInfo_FromString", (PyCFunction) _wrap_NativeFontInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
20626 { (char *)"NativeFontInfo_ToString", (PyCFunction) _wrap_NativeFontInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
20627 { (char *)"NativeFontInfo___str__", (PyCFunction) _wrap_NativeFontInfo___str__, METH_VARARGS | METH_KEYWORDS, NULL},
20628 { (char *)"NativeFontInfo_FromUserString", (PyCFunction) _wrap_NativeFontInfo_FromUserString, METH_VARARGS | METH_KEYWORDS, NULL},
20629 { (char *)"NativeFontInfo_ToUserString", (PyCFunction) _wrap_NativeFontInfo_ToUserString, METH_VARARGS | METH_KEYWORDS, NULL},
20630 { (char *)"NativeFontInfo_swigregister", NativeFontInfo_swigregister, METH_VARARGS, NULL},
20631 { (char *)"NativeEncodingInfo_facename_set", (PyCFunction) _wrap_NativeEncodingInfo_facename_set, METH_VARARGS | METH_KEYWORDS, NULL},
20632 { (char *)"NativeEncodingInfo_facename_get", (PyCFunction) _wrap_NativeEncodingInfo_facename_get, METH_VARARGS | METH_KEYWORDS, NULL},
20633 { (char *)"NativeEncodingInfo_encoding_set", (PyCFunction) _wrap_NativeEncodingInfo_encoding_set, METH_VARARGS | METH_KEYWORDS, NULL},
20634 { (char *)"NativeEncodingInfo_encoding_get", (PyCFunction) _wrap_NativeEncodingInfo_encoding_get, METH_VARARGS | METH_KEYWORDS, NULL},
20635 { (char *)"new_NativeEncodingInfo", (PyCFunction) _wrap_new_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20636 { (char *)"delete_NativeEncodingInfo", (PyCFunction) _wrap_delete_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20637 { (char *)"NativeEncodingInfo_FromString", (PyCFunction) _wrap_NativeEncodingInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
20638 { (char *)"NativeEncodingInfo_ToString", (PyCFunction) _wrap_NativeEncodingInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
20639 { (char *)"NativeEncodingInfo_swigregister", NativeEncodingInfo_swigregister, METH_VARARGS, NULL},
20640 { (char *)"GetNativeFontEncoding", (PyCFunction) _wrap_GetNativeFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20641 { (char *)"TestFontEncoding", (PyCFunction) _wrap_TestFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20642 { (char *)"new_FontMapper", (PyCFunction) _wrap_new_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
20643 { (char *)"delete_FontMapper", (PyCFunction) _wrap_delete_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
20644 { (char *)"FontMapper_Get", (PyCFunction) _wrap_FontMapper_Get, METH_VARARGS | METH_KEYWORDS, NULL},
20645 { (char *)"FontMapper_Set", (PyCFunction) _wrap_FontMapper_Set, METH_VARARGS | METH_KEYWORDS, NULL},
20646 { (char *)"FontMapper_CharsetToEncoding", (PyCFunction) _wrap_FontMapper_CharsetToEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20647 { (char *)"FontMapper_GetSupportedEncodingsCount", (PyCFunction) _wrap_FontMapper_GetSupportedEncodingsCount, METH_VARARGS | METH_KEYWORDS, NULL},
20648 { (char *)"FontMapper_GetEncoding", (PyCFunction) _wrap_FontMapper_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20649 { (char *)"FontMapper_GetEncodingName", (PyCFunction) _wrap_FontMapper_GetEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
20650 { (char *)"FontMapper_GetEncodingDescription", (PyCFunction) _wrap_FontMapper_GetEncodingDescription, METH_VARARGS | METH_KEYWORDS, NULL},
20651 { (char *)"FontMapper_GetEncodingFromName", (PyCFunction) _wrap_FontMapper_GetEncodingFromName, METH_VARARGS | METH_KEYWORDS, NULL},
20652 { (char *)"FontMapper_SetConfig", (PyCFunction) _wrap_FontMapper_SetConfig, METH_VARARGS | METH_KEYWORDS, NULL},
20653 { (char *)"FontMapper_SetConfigPath", (PyCFunction) _wrap_FontMapper_SetConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
20654 { (char *)"FontMapper_GetDefaultConfigPath", (PyCFunction) _wrap_FontMapper_GetDefaultConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
20655 { (char *)"FontMapper_GetAltForEncoding", (PyCFunction) _wrap_FontMapper_GetAltForEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20656 { (char *)"FontMapper_IsEncodingAvailable", (PyCFunction) _wrap_FontMapper_IsEncodingAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
20657 { (char *)"FontMapper_SetDialogParent", (PyCFunction) _wrap_FontMapper_SetDialogParent, METH_VARARGS | METH_KEYWORDS, NULL},
20658 { (char *)"FontMapper_SetDialogTitle", (PyCFunction) _wrap_FontMapper_SetDialogTitle, METH_VARARGS | METH_KEYWORDS, NULL},
20659 { (char *)"FontMapper_swigregister", FontMapper_swigregister, METH_VARARGS, NULL},
20660 { (char *)"new_Font", (PyCFunction) _wrap_new_Font, METH_VARARGS | METH_KEYWORDS, NULL},
20661 { (char *)"delete_Font", (PyCFunction) _wrap_delete_Font, METH_VARARGS | METH_KEYWORDS, NULL},
20662 { (char *)"new_FontFromNativeInfo", (PyCFunction) _wrap_new_FontFromNativeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20663 { (char *)"new_FontFromNativeInfoString", (PyCFunction) _wrap_new_FontFromNativeInfoString, METH_VARARGS | METH_KEYWORDS, NULL},
20664 { (char *)"new_Font2", (PyCFunction) _wrap_new_Font2, METH_VARARGS | METH_KEYWORDS, NULL},
20665 { (char *)"new_FontFromPixelSize", (PyCFunction) _wrap_new_FontFromPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20666 { (char *)"Font_Ok", (PyCFunction) _wrap_Font_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20667 { (char *)"Font___eq__", (PyCFunction) _wrap_Font___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20668 { (char *)"Font___ne__", (PyCFunction) _wrap_Font___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20669 { (char *)"Font_GetPointSize", (PyCFunction) _wrap_Font_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20670 { (char *)"Font_GetPixelSize", (PyCFunction) _wrap_Font_GetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20671 { (char *)"Font_IsUsingSizeInPixels", (PyCFunction) _wrap_Font_IsUsingSizeInPixels, METH_VARARGS | METH_KEYWORDS, NULL},
20672 { (char *)"Font_GetFamily", (PyCFunction) _wrap_Font_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20673 { (char *)"Font_GetStyle", (PyCFunction) _wrap_Font_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20674 { (char *)"Font_GetWeight", (PyCFunction) _wrap_Font_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20675 { (char *)"Font_GetUnderlined", (PyCFunction) _wrap_Font_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20676 { (char *)"Font_GetFaceName", (PyCFunction) _wrap_Font_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20677 { (char *)"Font_GetEncoding", (PyCFunction) _wrap_Font_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20678 { (char *)"Font_GetNativeFontInfo", (PyCFunction) _wrap_Font_GetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20679 { (char *)"Font_IsFixedWidth", (PyCFunction) _wrap_Font_IsFixedWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20680 { (char *)"Font_GetNativeFontInfoDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoDesc, METH_VARARGS | METH_KEYWORDS, NULL},
20681 { (char *)"Font_GetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
20682 { (char *)"Font_SetPointSize", (PyCFunction) _wrap_Font_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20683 { (char *)"Font_SetPixelSize", (PyCFunction) _wrap_Font_SetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20684 { (char *)"Font_SetFamily", (PyCFunction) _wrap_Font_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20685 { (char *)"Font_SetStyle", (PyCFunction) _wrap_Font_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20686 { (char *)"Font_SetWeight", (PyCFunction) _wrap_Font_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20687 { (char *)"Font_SetFaceName", (PyCFunction) _wrap_Font_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20688 { (char *)"Font_SetUnderlined", (PyCFunction) _wrap_Font_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20689 { (char *)"Font_SetEncoding", (PyCFunction) _wrap_Font_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20690 { (char *)"Font_SetNativeFontInfo", (PyCFunction) _wrap_Font_SetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20691 { (char *)"Font_SetNativeFontInfoFromString", (PyCFunction) _wrap_Font_SetNativeFontInfoFromString, METH_VARARGS | METH_KEYWORDS, NULL},
20692 { (char *)"Font_SetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_SetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
20693 { (char *)"Font_GetFamilyString", (PyCFunction) _wrap_Font_GetFamilyString, METH_VARARGS | METH_KEYWORDS, NULL},
20694 { (char *)"Font_GetStyleString", (PyCFunction) _wrap_Font_GetStyleString, METH_VARARGS | METH_KEYWORDS, NULL},
20695 { (char *)"Font_GetWeightString", (PyCFunction) _wrap_Font_GetWeightString, METH_VARARGS | METH_KEYWORDS, NULL},
20696 { (char *)"Font_SetNoAntiAliasing", (PyCFunction) _wrap_Font_SetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
20697 { (char *)"Font_GetNoAntiAliasing", (PyCFunction) _wrap_Font_GetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
20698 { (char *)"Font_GetDefaultEncoding", (PyCFunction) _wrap_Font_GetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20699 { (char *)"Font_SetDefaultEncoding", (PyCFunction) _wrap_Font_SetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20700 { (char *)"Font_swigregister", Font_swigregister, METH_VARARGS, NULL},
20701 { (char *)"new_FontEnumerator", (PyCFunction) _wrap_new_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
20702 { (char *)"delete_FontEnumerator", (PyCFunction) _wrap_delete_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
20703 { (char *)"FontEnumerator__setCallbackInfo", (PyCFunction) _wrap_FontEnumerator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20704 { (char *)"FontEnumerator_EnumerateFacenames", (PyCFunction) _wrap_FontEnumerator_EnumerateFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
20705 { (char *)"FontEnumerator_EnumerateEncodings", (PyCFunction) _wrap_FontEnumerator_EnumerateEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
20706 { (char *)"FontEnumerator_GetEncodings", (PyCFunction) _wrap_FontEnumerator_GetEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
20707 { (char *)"FontEnumerator_GetFacenames", (PyCFunction) _wrap_FontEnumerator_GetFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
20708 { (char *)"FontEnumerator_swigregister", FontEnumerator_swigregister, METH_VARARGS, NULL},
20709 { (char *)"LanguageInfo_Language_set", (PyCFunction) _wrap_LanguageInfo_Language_set, METH_VARARGS | METH_KEYWORDS, NULL},
20710 { (char *)"LanguageInfo_Language_get", (PyCFunction) _wrap_LanguageInfo_Language_get, METH_VARARGS | METH_KEYWORDS, NULL},
20711 { (char *)"LanguageInfo_CanonicalName_set", (PyCFunction) _wrap_LanguageInfo_CanonicalName_set, METH_VARARGS | METH_KEYWORDS, NULL},
20712 { (char *)"LanguageInfo_CanonicalName_get", (PyCFunction) _wrap_LanguageInfo_CanonicalName_get, METH_VARARGS | METH_KEYWORDS, NULL},
20713 { (char *)"LanguageInfo_Description_set", (PyCFunction) _wrap_LanguageInfo_Description_set, METH_VARARGS | METH_KEYWORDS, NULL},
20714 { (char *)"LanguageInfo_Description_get", (PyCFunction) _wrap_LanguageInfo_Description_get, METH_VARARGS | METH_KEYWORDS, NULL},
20715 { (char *)"LanguageInfo_swigregister", LanguageInfo_swigregister, METH_VARARGS, NULL},
20716 { (char *)"new_Locale", (PyCFunction) _wrap_new_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
20717 { (char *)"delete_Locale", (PyCFunction) _wrap_delete_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
20718 { (char *)"Locale_Init1", (PyCFunction) _wrap_Locale_Init1, METH_VARARGS | METH_KEYWORDS, NULL},
20719 { (char *)"Locale_Init2", (PyCFunction) _wrap_Locale_Init2, METH_VARARGS | METH_KEYWORDS, NULL},
20720 { (char *)"Locale_GetSystemLanguage", (PyCFunction) _wrap_Locale_GetSystemLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
20721 { (char *)"Locale_GetSystemEncoding", (PyCFunction) _wrap_Locale_GetSystemEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20722 { (char *)"Locale_GetSystemEncodingName", (PyCFunction) _wrap_Locale_GetSystemEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
20723 { (char *)"Locale_IsOk", (PyCFunction) _wrap_Locale_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
20724 { (char *)"Locale_GetLocale", (PyCFunction) _wrap_Locale_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
20725 { (char *)"Locale_GetLanguage", (PyCFunction) _wrap_Locale_GetLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
20726 { (char *)"Locale_GetSysName", (PyCFunction) _wrap_Locale_GetSysName, METH_VARARGS | METH_KEYWORDS, NULL},
20727 { (char *)"Locale_GetCanonicalName", (PyCFunction) _wrap_Locale_GetCanonicalName, METH_VARARGS | METH_KEYWORDS, NULL},
20728 { (char *)"Locale_AddCatalogLookupPathPrefix", (PyCFunction) _wrap_Locale_AddCatalogLookupPathPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
20729 { (char *)"Locale_AddCatalog", (PyCFunction) _wrap_Locale_AddCatalog, METH_VARARGS | METH_KEYWORDS, NULL},
20730 { (char *)"Locale_IsLoaded", (PyCFunction) _wrap_Locale_IsLoaded, METH_VARARGS | METH_KEYWORDS, NULL},
20731 { (char *)"Locale_GetLanguageInfo", (PyCFunction) _wrap_Locale_GetLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20732 { (char *)"Locale_GetLanguageName", (PyCFunction) _wrap_Locale_GetLanguageName, METH_VARARGS | METH_KEYWORDS, NULL},
20733 { (char *)"Locale_FindLanguageInfo", (PyCFunction) _wrap_Locale_FindLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20734 { (char *)"Locale_AddLanguage", (PyCFunction) _wrap_Locale_AddLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
20735 { (char *)"Locale_GetString", (PyCFunction) _wrap_Locale_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
20736 { (char *)"Locale_GetName", (PyCFunction) _wrap_Locale_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
20737 { (char *)"Locale_swigregister", Locale_swigregister, METH_VARARGS, NULL},
20738 { (char *)"GetLocale", (PyCFunction) _wrap_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
20739 { (char *)"GetTranslation", _wrap_GetTranslation, METH_VARARGS, NULL},
20740 { (char *)"new_EncodingConverter", (PyCFunction) _wrap_new_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
20741 { (char *)"delete_EncodingConverter", (PyCFunction) _wrap_delete_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
20742 { (char *)"EncodingConverter_Init", (PyCFunction) _wrap_EncodingConverter_Init, METH_VARARGS | METH_KEYWORDS, NULL},
20743 { (char *)"EncodingConverter_Convert", (PyCFunction) _wrap_EncodingConverter_Convert, METH_VARARGS | METH_KEYWORDS, NULL},
20744 { (char *)"EncodingConverter_GetPlatformEquivalents", (PyCFunction) _wrap_EncodingConverter_GetPlatformEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
20745 { (char *)"EncodingConverter_GetAllEquivalents", (PyCFunction) _wrap_EncodingConverter_GetAllEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
20746 { (char *)"EncodingConverter_CanConvert", (PyCFunction) _wrap_EncodingConverter_CanConvert, METH_VARARGS | METH_KEYWORDS, NULL},
20747 { (char *)"EncodingConverter_swigregister", EncodingConverter_swigregister, METH_VARARGS, NULL},
20748 { (char *)"delete_DC", (PyCFunction) _wrap_delete_DC, METH_VARARGS | METH_KEYWORDS, NULL},
20749 { (char *)"DC_BeginDrawing", (PyCFunction) _wrap_DC_BeginDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
20750 { (char *)"DC_EndDrawing", (PyCFunction) _wrap_DC_EndDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
20751 { (char *)"DC_FloodFill", (PyCFunction) _wrap_DC_FloodFill, METH_VARARGS | METH_KEYWORDS, NULL},
20752 { (char *)"DC_FloodFillPoint", (PyCFunction) _wrap_DC_FloodFillPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20753 { (char *)"DC_GetPixel", (PyCFunction) _wrap_DC_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
20754 { (char *)"DC_GetPixelPoint", (PyCFunction) _wrap_DC_GetPixelPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20755 { (char *)"DC_DrawLine", (PyCFunction) _wrap_DC_DrawLine, METH_VARARGS | METH_KEYWORDS, NULL},
20756 { (char *)"DC_DrawLinePoint", (PyCFunction) _wrap_DC_DrawLinePoint, METH_VARARGS | METH_KEYWORDS, NULL},
20757 { (char *)"DC_CrossHair", (PyCFunction) _wrap_DC_CrossHair, METH_VARARGS | METH_KEYWORDS, NULL},
20758 { (char *)"DC_CrossHairPoint", (PyCFunction) _wrap_DC_CrossHairPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20759 { (char *)"DC_DrawArc", (PyCFunction) _wrap_DC_DrawArc, METH_VARARGS | METH_KEYWORDS, NULL},
20760 { (char *)"DC_DrawArcPoint", (PyCFunction) _wrap_DC_DrawArcPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20761 { (char *)"DC_DrawCheckMark", (PyCFunction) _wrap_DC_DrawCheckMark, METH_VARARGS | METH_KEYWORDS, NULL},
20762 { (char *)"DC_DrawCheckMarkRect", (PyCFunction) _wrap_DC_DrawCheckMarkRect, METH_VARARGS | METH_KEYWORDS, NULL},
20763 { (char *)"DC_DrawEllipticArc", (PyCFunction) _wrap_DC_DrawEllipticArc, METH_VARARGS | METH_KEYWORDS, NULL},
20764 { (char *)"DC_DrawEllipticArcPointSize", (PyCFunction) _wrap_DC_DrawEllipticArcPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20765 { (char *)"DC_DrawPoint", (PyCFunction) _wrap_DC_DrawPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20766 { (char *)"DC_DrawPointPoint", (PyCFunction) _wrap_DC_DrawPointPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20767 { (char *)"DC_DrawRectangle", (PyCFunction) _wrap_DC_DrawRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
20768 { (char *)"DC_DrawRectangleRect", (PyCFunction) _wrap_DC_DrawRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
20769 { (char *)"DC_DrawRectanglePointSize", (PyCFunction) _wrap_DC_DrawRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20770 { (char *)"DC_DrawRoundedRectangle", (PyCFunction) _wrap_DC_DrawRoundedRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
20771 { (char *)"DC_DrawRoundedRectangleRect", (PyCFunction) _wrap_DC_DrawRoundedRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
20772 { (char *)"DC_DrawRoundedRectanglePointSize", (PyCFunction) _wrap_DC_DrawRoundedRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20773 { (char *)"DC_DrawCircle", (PyCFunction) _wrap_DC_DrawCircle, METH_VARARGS | METH_KEYWORDS, NULL},
20774 { (char *)"DC_DrawCirclePoint", (PyCFunction) _wrap_DC_DrawCirclePoint, METH_VARARGS | METH_KEYWORDS, NULL},
20775 { (char *)"DC_DrawEllipse", (PyCFunction) _wrap_DC_DrawEllipse, METH_VARARGS | METH_KEYWORDS, NULL},
20776 { (char *)"DC_DrawEllipseRect", (PyCFunction) _wrap_DC_DrawEllipseRect, METH_VARARGS | METH_KEYWORDS, NULL},
20777 { (char *)"DC_DrawEllipsePointSize", (PyCFunction) _wrap_DC_DrawEllipsePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20778 { (char *)"DC_DrawIcon", (PyCFunction) _wrap_DC_DrawIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20779 { (char *)"DC_DrawIconPoint", (PyCFunction) _wrap_DC_DrawIconPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20780 { (char *)"DC_DrawBitmap", (PyCFunction) _wrap_DC_DrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20781 { (char *)"DC_DrawBitmapPoint", (PyCFunction) _wrap_DC_DrawBitmapPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20782 { (char *)"DC_DrawText", (PyCFunction) _wrap_DC_DrawText, METH_VARARGS | METH_KEYWORDS, NULL},
20783 { (char *)"DC_DrawTextPoint", (PyCFunction) _wrap_DC_DrawTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20784 { (char *)"DC_DrawRotatedText", (PyCFunction) _wrap_DC_DrawRotatedText, METH_VARARGS | METH_KEYWORDS, NULL},
20785 { (char *)"DC_DrawRotatedTextPoint", (PyCFunction) _wrap_DC_DrawRotatedTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20786 { (char *)"DC_Blit", (PyCFunction) _wrap_DC_Blit, METH_VARARGS | METH_KEYWORDS, NULL},
20787 { (char *)"DC_BlitPointSize", (PyCFunction) _wrap_DC_BlitPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20788 { (char *)"DC_SetClippingRegion", (PyCFunction) _wrap_DC_SetClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20789 { (char *)"DC_SetClippingRegionPointSize", (PyCFunction) _wrap_DC_SetClippingRegionPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20790 { (char *)"DC_SetClippingRegionAsRegion", (PyCFunction) _wrap_DC_SetClippingRegionAsRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20791 { (char *)"DC_SetClippingRect", (PyCFunction) _wrap_DC_SetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
20792 { (char *)"DC_DrawLines", (PyCFunction) _wrap_DC_DrawLines, METH_VARARGS | METH_KEYWORDS, NULL},
20793 { (char *)"DC_DrawPolygon", (PyCFunction) _wrap_DC_DrawPolygon, METH_VARARGS | METH_KEYWORDS, NULL},
20794 { (char *)"DC_DrawLabel", (PyCFunction) _wrap_DC_DrawLabel, METH_VARARGS | METH_KEYWORDS, NULL},
20795 { (char *)"DC_DrawImageLabel", (PyCFunction) _wrap_DC_DrawImageLabel, METH_VARARGS | METH_KEYWORDS, NULL},
20796 { (char *)"DC_DrawSpline", (PyCFunction) _wrap_DC_DrawSpline, METH_VARARGS | METH_KEYWORDS, NULL},
20797 { (char *)"DC_Clear", (PyCFunction) _wrap_DC_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
20798 { (char *)"DC_StartDoc", (PyCFunction) _wrap_DC_StartDoc, METH_VARARGS | METH_KEYWORDS, NULL},
20799 { (char *)"DC_EndDoc", (PyCFunction) _wrap_DC_EndDoc, METH_VARARGS | METH_KEYWORDS, NULL},
20800 { (char *)"DC_StartPage", (PyCFunction) _wrap_DC_StartPage, METH_VARARGS | METH_KEYWORDS, NULL},
20801 { (char *)"DC_EndPage", (PyCFunction) _wrap_DC_EndPage, METH_VARARGS | METH_KEYWORDS, NULL},
20802 { (char *)"DC_SetFont", (PyCFunction) _wrap_DC_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
20803 { (char *)"DC_SetPen", (PyCFunction) _wrap_DC_SetPen, METH_VARARGS | METH_KEYWORDS, NULL},
20804 { (char *)"DC_SetBrush", (PyCFunction) _wrap_DC_SetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
20805 { (char *)"DC_SetBackground", (PyCFunction) _wrap_DC_SetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20806 { (char *)"DC_SetBackgroundMode", (PyCFunction) _wrap_DC_SetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
20807 { (char *)"DC_SetPalette", (PyCFunction) _wrap_DC_SetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
20808 { (char *)"DC_DestroyClippingRegion", (PyCFunction) _wrap_DC_DestroyClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20809 { (char *)"DC_GetClippingBox", (PyCFunction) _wrap_DC_GetClippingBox, METH_VARARGS | METH_KEYWORDS, NULL},
20810 { (char *)"DC_GetClippingRect", (PyCFunction) _wrap_DC_GetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
20811 { (char *)"DC_GetCharHeight", (PyCFunction) _wrap_DC_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20812 { (char *)"DC_GetCharWidth", (PyCFunction) _wrap_DC_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20813 { (char *)"DC_GetTextExtent", (PyCFunction) _wrap_DC_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
20814 { (char *)"DC_GetFullTextExtent", (PyCFunction) _wrap_DC_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
20815 { (char *)"DC_GetMultiLineTextExtent", (PyCFunction) _wrap_DC_GetMultiLineTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
20816 { (char *)"DC_GetPartialTextExtents", (PyCFunction) _wrap_DC_GetPartialTextExtents, METH_VARARGS | METH_KEYWORDS, NULL},
20817 { (char *)"DC_GetSize", (PyCFunction) _wrap_DC_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20818 { (char *)"DC_GetSizeTuple", (PyCFunction) _wrap_DC_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
20819 { (char *)"DC_GetSizeMM", (PyCFunction) _wrap_DC_GetSizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
20820 { (char *)"DC_GetSizeMMTuple", (PyCFunction) _wrap_DC_GetSizeMMTuple, METH_VARARGS | METH_KEYWORDS, NULL},
20821 { (char *)"DC_DeviceToLogicalX", (PyCFunction) _wrap_DC_DeviceToLogicalX, METH_VARARGS | METH_KEYWORDS, NULL},
20822 { (char *)"DC_DeviceToLogicalY", (PyCFunction) _wrap_DC_DeviceToLogicalY, METH_VARARGS | METH_KEYWORDS, NULL},
20823 { (char *)"DC_DeviceToLogicalXRel", (PyCFunction) _wrap_DC_DeviceToLogicalXRel, METH_VARARGS | METH_KEYWORDS, NULL},
20824 { (char *)"DC_DeviceToLogicalYRel", (PyCFunction) _wrap_DC_DeviceToLogicalYRel, METH_VARARGS | METH_KEYWORDS, NULL},
20825 { (char *)"DC_LogicalToDeviceX", (PyCFunction) _wrap_DC_LogicalToDeviceX, METH_VARARGS | METH_KEYWORDS, NULL},
20826 { (char *)"DC_LogicalToDeviceY", (PyCFunction) _wrap_DC_LogicalToDeviceY, METH_VARARGS | METH_KEYWORDS, NULL},
20827 { (char *)"DC_LogicalToDeviceXRel", (PyCFunction) _wrap_DC_LogicalToDeviceXRel, METH_VARARGS | METH_KEYWORDS, NULL},
20828 { (char *)"DC_LogicalToDeviceYRel", (PyCFunction) _wrap_DC_LogicalToDeviceYRel, METH_VARARGS | METH_KEYWORDS, NULL},
20829 { (char *)"DC_CanDrawBitmap", (PyCFunction) _wrap_DC_CanDrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20830 { (char *)"DC_CanGetTextExtent", (PyCFunction) _wrap_DC_CanGetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
20831 { (char *)"DC_GetDepth", (PyCFunction) _wrap_DC_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20832 { (char *)"DC_GetPPI", (PyCFunction) _wrap_DC_GetPPI, METH_VARARGS | METH_KEYWORDS, NULL},
20833 { (char *)"DC_Ok", (PyCFunction) _wrap_DC_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20834 { (char *)"DC_GetBackgroundMode", (PyCFunction) _wrap_DC_GetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
20835 { (char *)"DC_GetBackground", (PyCFunction) _wrap_DC_GetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20836 { (char *)"DC_GetBrush", (PyCFunction) _wrap_DC_GetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
20837 { (char *)"DC_GetFont", (PyCFunction) _wrap_DC_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
20838 { (char *)"DC_GetPen", (PyCFunction) _wrap_DC_GetPen, METH_VARARGS | METH_KEYWORDS, NULL},
20839 { (char *)"DC_GetTextBackground", (PyCFunction) _wrap_DC_GetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20840 { (char *)"DC_GetTextForeground", (PyCFunction) _wrap_DC_GetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
20841 { (char *)"DC_SetTextForeground", (PyCFunction) _wrap_DC_SetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
20842 { (char *)"DC_SetTextBackground", (PyCFunction) _wrap_DC_SetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20843 { (char *)"DC_GetMapMode", (PyCFunction) _wrap_DC_GetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
20844 { (char *)"DC_SetMapMode", (PyCFunction) _wrap_DC_SetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
20845 { (char *)"DC_GetUserScale", (PyCFunction) _wrap_DC_GetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
20846 { (char *)"DC_SetUserScale", (PyCFunction) _wrap_DC_SetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
20847 { (char *)"DC_GetLogicalScale", (PyCFunction) _wrap_DC_GetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
20848 { (char *)"DC_SetLogicalScale", (PyCFunction) _wrap_DC_SetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
20849 { (char *)"DC_GetLogicalOrigin", (PyCFunction) _wrap_DC_GetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
20850 { (char *)"DC_GetLogicalOriginTuple", (PyCFunction) _wrap_DC_GetLogicalOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
20851 { (char *)"DC_SetLogicalOrigin", (PyCFunction) _wrap_DC_SetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
20852 { (char *)"DC_SetLogicalOriginPoint", (PyCFunction) _wrap_DC_SetLogicalOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20853 { (char *)"DC_GetDeviceOrigin", (PyCFunction) _wrap_DC_GetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
20854 { (char *)"DC_GetDeviceOriginTuple", (PyCFunction) _wrap_DC_GetDeviceOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
20855 { (char *)"DC_SetDeviceOrigin", (PyCFunction) _wrap_DC_SetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
20856 { (char *)"DC_SetDeviceOriginPoint", (PyCFunction) _wrap_DC_SetDeviceOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20857 { (char *)"DC_SetAxisOrientation", (PyCFunction) _wrap_DC_SetAxisOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
20858 { (char *)"DC_GetLogicalFunction", (PyCFunction) _wrap_DC_GetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
20859 { (char *)"DC_SetLogicalFunction", (PyCFunction) _wrap_DC_SetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
20860 { (char *)"DC_ComputeScaleAndOrigin", (PyCFunction) _wrap_DC_ComputeScaleAndOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
20861 { (char *)"DC_CalcBoundingBox", (PyCFunction) _wrap_DC_CalcBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
20862 { (char *)"DC_CalcBoundingBoxPoint", (PyCFunction) _wrap_DC_CalcBoundingBoxPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20863 { (char *)"DC_ResetBoundingBox", (PyCFunction) _wrap_DC_ResetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
20864 { (char *)"DC_MinX", (PyCFunction) _wrap_DC_MinX, METH_VARARGS | METH_KEYWORDS, NULL},
20865 { (char *)"DC_MaxX", (PyCFunction) _wrap_DC_MaxX, METH_VARARGS | METH_KEYWORDS, NULL},
20866 { (char *)"DC_MinY", (PyCFunction) _wrap_DC_MinY, METH_VARARGS | METH_KEYWORDS, NULL},
20867 { (char *)"DC_MaxY", (PyCFunction) _wrap_DC_MaxY, METH_VARARGS | METH_KEYWORDS, NULL},
20868 { (char *)"DC_GetBoundingBox", (PyCFunction) _wrap_DC_GetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
20869 { (char *)"DC__DrawPointList", (PyCFunction) _wrap_DC__DrawPointList, METH_VARARGS | METH_KEYWORDS, NULL},
20870 { (char *)"DC__DrawLineList", (PyCFunction) _wrap_DC__DrawLineList, METH_VARARGS | METH_KEYWORDS, NULL},
20871 { (char *)"DC__DrawRectangleList", (PyCFunction) _wrap_DC__DrawRectangleList, METH_VARARGS | METH_KEYWORDS, NULL},
20872 { (char *)"DC__DrawEllipseList", (PyCFunction) _wrap_DC__DrawEllipseList, METH_VARARGS | METH_KEYWORDS, NULL},
20873 { (char *)"DC__DrawPolygonList", (PyCFunction) _wrap_DC__DrawPolygonList, METH_VARARGS | METH_KEYWORDS, NULL},
20874 { (char *)"DC__DrawTextList", (PyCFunction) _wrap_DC__DrawTextList, METH_VARARGS | METH_KEYWORDS, NULL},
20875 { (char *)"DC_swigregister", DC_swigregister, METH_VARARGS, NULL},
20876 { (char *)"new_MemoryDC", (PyCFunction) _wrap_new_MemoryDC, METH_VARARGS | METH_KEYWORDS, NULL},
20877 { (char *)"new_MemoryDCFromDC", (PyCFunction) _wrap_new_MemoryDCFromDC, METH_VARARGS | METH_KEYWORDS, NULL},
20878 { (char *)"MemoryDC_SelectObject", (PyCFunction) _wrap_MemoryDC_SelectObject, METH_VARARGS | METH_KEYWORDS, NULL},
20879 { (char *)"MemoryDC_swigregister", MemoryDC_swigregister, METH_VARARGS, NULL},
20880 { (char *)"new_BufferedDC", _wrap_new_BufferedDC, METH_VARARGS, NULL},
20881 { (char *)"delete_BufferedDC", (PyCFunction) _wrap_delete_BufferedDC, METH_VARARGS | METH_KEYWORDS, NULL},
20882 { (char *)"BufferedDC_UnMask", (PyCFunction) _wrap_BufferedDC_UnMask, METH_VARARGS | METH_KEYWORDS, NULL},
20883 { (char *)"BufferedDC_swigregister", BufferedDC_swigregister, METH_VARARGS, NULL},
20884 { (char *)"new_BufferedPaintDC", (PyCFunction) _wrap_new_BufferedPaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
20885 { (char *)"BufferedPaintDC_swigregister", BufferedPaintDC_swigregister, METH_VARARGS, NULL},
20886 { (char *)"new_ScreenDC", (PyCFunction) _wrap_new_ScreenDC, METH_VARARGS | METH_KEYWORDS, NULL},
20887 { (char *)"ScreenDC_StartDrawingOnTopWin", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTopWin, METH_VARARGS | METH_KEYWORDS, NULL},
20888 { (char *)"ScreenDC_StartDrawingOnTop", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
20889 { (char *)"ScreenDC_EndDrawingOnTop", (PyCFunction) _wrap_ScreenDC_EndDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
20890 { (char *)"ScreenDC_swigregister", ScreenDC_swigregister, METH_VARARGS, NULL},
20891 { (char *)"new_ClientDC", (PyCFunction) _wrap_new_ClientDC, METH_VARARGS | METH_KEYWORDS, NULL},
20892 { (char *)"ClientDC_swigregister", ClientDC_swigregister, METH_VARARGS, NULL},
20893 { (char *)"new_PaintDC", (PyCFunction) _wrap_new_PaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
20894 { (char *)"PaintDC_swigregister", PaintDC_swigregister, METH_VARARGS, NULL},
20895 { (char *)"new_WindowDC", (PyCFunction) _wrap_new_WindowDC, METH_VARARGS | METH_KEYWORDS, NULL},
20896 { (char *)"WindowDC_swigregister", WindowDC_swigregister, METH_VARARGS, NULL},
20897 { (char *)"new_MirrorDC", (PyCFunction) _wrap_new_MirrorDC, METH_VARARGS | METH_KEYWORDS, NULL},
20898 { (char *)"MirrorDC_swigregister", MirrorDC_swigregister, METH_VARARGS, NULL},
20899 { (char *)"new_PostScriptDC", (PyCFunction) _wrap_new_PostScriptDC, METH_VARARGS | METH_KEYWORDS, NULL},
20900 { (char *)"PostScriptDC_GetPrintData", (PyCFunction) _wrap_PostScriptDC_GetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
20901 { (char *)"PostScriptDC_SetPrintData", (PyCFunction) _wrap_PostScriptDC_SetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
20902 { (char *)"PostScriptDC_SetResolution", (PyCFunction) _wrap_PostScriptDC_SetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
20903 { (char *)"PostScriptDC_GetResolution", (PyCFunction) _wrap_PostScriptDC_GetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
20904 { (char *)"PostScriptDC_swigregister", PostScriptDC_swigregister, METH_VARARGS, NULL},
20905 { (char *)"new_MetaFile", (PyCFunction) _wrap_new_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
20906 { (char *)"MetaFile_swigregister", MetaFile_swigregister, METH_VARARGS, NULL},
20907 { (char *)"new_MetaFileDC", (PyCFunction) _wrap_new_MetaFileDC, METH_VARARGS | METH_KEYWORDS, NULL},
20908 { (char *)"MetaFileDC_swigregister", MetaFileDC_swigregister, METH_VARARGS, NULL},
20909 { (char *)"new_PrinterDC", (PyCFunction) _wrap_new_PrinterDC, METH_VARARGS | METH_KEYWORDS, NULL},
20910 { (char *)"PrinterDC_swigregister", PrinterDC_swigregister, METH_VARARGS, NULL},
20911 { (char *)"new_ImageList", (PyCFunction) _wrap_new_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
20912 { (char *)"delete_ImageList", (PyCFunction) _wrap_delete_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
20913 { (char *)"ImageList_Add", (PyCFunction) _wrap_ImageList_Add, METH_VARARGS | METH_KEYWORDS, NULL},
20914 { (char *)"ImageList_AddWithColourMask", (PyCFunction) _wrap_ImageList_AddWithColourMask, METH_VARARGS | METH_KEYWORDS, NULL},
20915 { (char *)"ImageList_AddIcon", (PyCFunction) _wrap_ImageList_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20916 { (char *)"ImageList_GetBitmap", (PyCFunction) _wrap_ImageList_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20917 { (char *)"ImageList_GetIcon", (PyCFunction) _wrap_ImageList_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20918 { (char *)"ImageList_Replace", (PyCFunction) _wrap_ImageList_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
20919 { (char *)"ImageList_Draw", (PyCFunction) _wrap_ImageList_Draw, METH_VARARGS | METH_KEYWORDS, NULL},
20920 { (char *)"ImageList_GetImageCount", (PyCFunction) _wrap_ImageList_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
20921 { (char *)"ImageList_Remove", (PyCFunction) _wrap_ImageList_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
20922 { (char *)"ImageList_RemoveAll", (PyCFunction) _wrap_ImageList_RemoveAll, METH_VARARGS | METH_KEYWORDS, NULL},
20923 { (char *)"ImageList_GetSize", (PyCFunction) _wrap_ImageList_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20924 { (char *)"ImageList_swigregister", ImageList_swigregister, METH_VARARGS, NULL},
20925 { (char *)"PenList_AddPen", (PyCFunction) _wrap_PenList_AddPen, METH_VARARGS | METH_KEYWORDS, NULL},
20926 { (char *)"PenList_FindOrCreatePen", (PyCFunction) _wrap_PenList_FindOrCreatePen, METH_VARARGS | METH_KEYWORDS, NULL},
20927 { (char *)"PenList_RemovePen", (PyCFunction) _wrap_PenList_RemovePen, METH_VARARGS | METH_KEYWORDS, NULL},
20928 { (char *)"PenList_GetCount", (PyCFunction) _wrap_PenList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
20929 { (char *)"PenList_swigregister", PenList_swigregister, METH_VARARGS, NULL},
20930 { (char *)"BrushList_AddBrush", (PyCFunction) _wrap_BrushList_AddBrush, METH_VARARGS | METH_KEYWORDS, NULL},
20931 { (char *)"BrushList_FindOrCreateBrush", (PyCFunction) _wrap_BrushList_FindOrCreateBrush, METH_VARARGS | METH_KEYWORDS, NULL},
20932 { (char *)"BrushList_RemoveBrush", (PyCFunction) _wrap_BrushList_RemoveBrush, METH_VARARGS | METH_KEYWORDS, NULL},
20933 { (char *)"BrushList_GetCount", (PyCFunction) _wrap_BrushList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
20934 { (char *)"BrushList_swigregister", BrushList_swigregister, METH_VARARGS, NULL},
20935 { (char *)"new_ColourDatabase", (PyCFunction) _wrap_new_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
20936 { (char *)"delete_ColourDatabase", (PyCFunction) _wrap_delete_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
20937 { (char *)"ColourDatabase_Find", (PyCFunction) _wrap_ColourDatabase_Find, METH_VARARGS | METH_KEYWORDS, NULL},
20938 { (char *)"ColourDatabase_FindName", (PyCFunction) _wrap_ColourDatabase_FindName, METH_VARARGS | METH_KEYWORDS, NULL},
20939 { (char *)"ColourDatabase_AddColour", (PyCFunction) _wrap_ColourDatabase_AddColour, METH_VARARGS | METH_KEYWORDS, NULL},
20940 { (char *)"ColourDatabase_Append", (PyCFunction) _wrap_ColourDatabase_Append, METH_VARARGS | METH_KEYWORDS, NULL},
20941 { (char *)"ColourDatabase_swigregister", ColourDatabase_swigregister, METH_VARARGS, NULL},
20942 { (char *)"FontList_AddFont", (PyCFunction) _wrap_FontList_AddFont, METH_VARARGS | METH_KEYWORDS, NULL},
20943 { (char *)"FontList_FindOrCreateFont", (PyCFunction) _wrap_FontList_FindOrCreateFont, METH_VARARGS | METH_KEYWORDS, NULL},
20944 { (char *)"FontList_RemoveFont", (PyCFunction) _wrap_FontList_RemoveFont, METH_VARARGS | METH_KEYWORDS, NULL},
20945 { (char *)"FontList_GetCount", (PyCFunction) _wrap_FontList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
20946 { (char *)"FontList_swigregister", FontList_swigregister, METH_VARARGS, NULL},
20947 { (char *)"new_Effects", (PyCFunction) _wrap_new_Effects, METH_VARARGS | METH_KEYWORDS, NULL},
20948 { (char *)"Effects_GetHighlightColour", (PyCFunction) _wrap_Effects_GetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
20949 { (char *)"Effects_GetLightShadow", (PyCFunction) _wrap_Effects_GetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
20950 { (char *)"Effects_GetFaceColour", (PyCFunction) _wrap_Effects_GetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
20951 { (char *)"Effects_GetMediumShadow", (PyCFunction) _wrap_Effects_GetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
20952 { (char *)"Effects_GetDarkShadow", (PyCFunction) _wrap_Effects_GetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
20953 { (char *)"Effects_SetHighlightColour", (PyCFunction) _wrap_Effects_SetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
20954 { (char *)"Effects_SetLightShadow", (PyCFunction) _wrap_Effects_SetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
20955 { (char *)"Effects_SetFaceColour", (PyCFunction) _wrap_Effects_SetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
20956 { (char *)"Effects_SetMediumShadow", (PyCFunction) _wrap_Effects_SetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
20957 { (char *)"Effects_SetDarkShadow", (PyCFunction) _wrap_Effects_SetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
20958 { (char *)"Effects_Set", (PyCFunction) _wrap_Effects_Set, METH_VARARGS | METH_KEYWORDS, NULL},
20959 { (char *)"Effects_DrawSunkenEdge", (PyCFunction) _wrap_Effects_DrawSunkenEdge, METH_VARARGS | METH_KEYWORDS, NULL},
20960 { (char *)"Effects_TileBitmap", (PyCFunction) _wrap_Effects_TileBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20961 { (char *)"Effects_swigregister", Effects_swigregister, METH_VARARGS, NULL},
20962 { NULL, NULL, 0, NULL }
20963 };
20964
20965
20966 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
20967
20968 static void *_p_wxBufferedDCTo_p_wxMemoryDC(void *x) {
20969 return (void *)((wxMemoryDC *) ((wxBufferedDC *) x));
20970 }
20971 static void *_p_wxBufferedPaintDCTo_p_wxMemoryDC(void *x) {
20972 return (void *)((wxMemoryDC *) (wxBufferedDC *) ((wxBufferedPaintDC *) x));
20973 }
20974 static void *_p_wxIconTo_p_wxGDIObject(void *x) {
20975 return (void *)((wxGDIObject *) ((wxIcon *) x));
20976 }
20977 static void *_p_wxPaletteTo_p_wxGDIObject(void *x) {
20978 return (void *)((wxGDIObject *) ((wxPalette *) x));
20979 }
20980 static void *_p_wxPenTo_p_wxGDIObject(void *x) {
20981 return (void *)((wxGDIObject *) ((wxPen *) x));
20982 }
20983 static void *_p_wxFontTo_p_wxGDIObject(void *x) {
20984 return (void *)((wxGDIObject *) ((wxFont *) x));
20985 }
20986 static void *_p_wxCursorTo_p_wxGDIObject(void *x) {
20987 return (void *)((wxGDIObject *) ((wxCursor *) x));
20988 }
20989 static void *_p_wxBitmapTo_p_wxGDIObject(void *x) {
20990 return (void *)((wxGDIObject *) ((wxBitmap *) x));
20991 }
20992 static void *_p_wxRegionTo_p_wxGDIObject(void *x) {
20993 return (void *)((wxGDIObject *) ((wxRegion *) x));
20994 }
20995 static void *_p_wxBrushTo_p_wxGDIObject(void *x) {
20996 return (void *)((wxGDIObject *) ((wxBrush *) x));
20997 }
20998 static void *_p_wxBufferedDCTo_p_wxDC(void *x) {
20999 return (void *)((wxDC *) (wxMemoryDC *) ((wxBufferedDC *) x));
21000 }
21001 static void *_p_wxScreenDCTo_p_wxDC(void *x) {
21002 return (void *)((wxDC *) ((wxScreenDC *) x));
21003 }
21004 static void *_p_wxMirrorDCTo_p_wxDC(void *x) {
21005 return (void *)((wxDC *) ((wxMirrorDC *) x));
21006 }
21007 static void *_p_wxMemoryDCTo_p_wxDC(void *x) {
21008 return (void *)((wxDC *) ((wxMemoryDC *) x));
21009 }
21010 static void *_p_wxWindowDCTo_p_wxDC(void *x) {
21011 return (void *)((wxDC *) ((wxWindowDC *) x));
21012 }
21013 static void *_p_wxMetaFileDCTo_p_wxDC(void *x) {
21014 return (void *)((wxDC *) ((wxMetaFileDC *) x));
21015 }
21016 static void *_p_wxBufferedPaintDCTo_p_wxDC(void *x) {
21017 return (void *)((wxDC *) (wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
21018 }
21019 static void *_p_wxClientDCTo_p_wxDC(void *x) {
21020 return (void *)((wxDC *) ((wxClientDC *) x));
21021 }
21022 static void *_p_wxPaintDCTo_p_wxDC(void *x) {
21023 return (void *)((wxDC *) ((wxPaintDC *) x));
21024 }
21025 static void *_p_wxPostScriptDCTo_p_wxDC(void *x) {
21026 return (void *)((wxDC *) ((wxPostScriptDC *) x));
21027 }
21028 static void *_p_wxPrinterDCTo_p_wxDC(void *x) {
21029 return (void *)((wxDC *) ((wxPrinterDC *) x));
21030 }
21031 static void *_p_wxBufferedPaintDCTo_p_wxBufferedDC(void *x) {
21032 return (void *)((wxBufferedDC *) ((wxBufferedPaintDC *) x));
21033 }
21034 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
21035 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
21036 }
21037 static void *_p_wxPenTo_p_wxObject(void *x) {
21038 return (void *)((wxObject *) (wxGDIObject *) ((wxPen *) x));
21039 }
21040 static void *_p_wxRegionIteratorTo_p_wxObject(void *x) {
21041 return (void *)((wxObject *) ((wxRegionIterator *) x));
21042 }
21043 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
21044 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
21045 }
21046 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
21047 return (void *)((wxObject *) ((wxSizerItem *) x));
21048 }
21049 static void *_p_wxColourDatabaseTo_p_wxObject(void *x) {
21050 return (void *)((wxObject *) ((wxColourDatabase *) x));
21051 }
21052 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
21053 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
21054 }
21055 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
21056 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
21057 }
21058 static void *_p_wxIconTo_p_wxObject(void *x) {
21059 return (void *)((wxObject *) (wxGDIObject *) ((wxIcon *) x));
21060 }
21061 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
21062 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
21063 }
21064 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
21065 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
21066 }
21067 static void *_p_wxSizerTo_p_wxObject(void *x) {
21068 return (void *)((wxObject *) ((wxSizer *) x));
21069 }
21070 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
21071 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
21072 }
21073 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
21074 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
21075 }
21076 static void *_p_wxPenListTo_p_wxObject(void *x) {
21077 return (void *)((wxObject *) ((wxPenList *) x));
21078 }
21079 static void *_p_wxEventTo_p_wxObject(void *x) {
21080 return (void *)((wxObject *) ((wxEvent *) x));
21081 }
21082 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
21083 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
21084 }
21085 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
21086 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
21087 }
21088 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
21089 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
21090 }
21091 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
21092 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
21093 }
21094 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
21095 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
21096 }
21097 static void *_p_wxDCTo_p_wxObject(void *x) {
21098 return (void *)((wxObject *) ((wxDC *) x));
21099 }
21100 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
21101 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
21102 }
21103 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
21104 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
21105 }
21106 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
21107 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
21108 }
21109 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
21110 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
21111 }
21112 static void *_p_wxControlTo_p_wxObject(void *x) {
21113 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
21114 }
21115 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
21116 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
21117 }
21118 static void *_p_wxClientDCTo_p_wxObject(void *x) {
21119 return (void *)((wxObject *) (wxDC *) ((wxClientDC *) x));
21120 }
21121 static void *_p_wxFSFileTo_p_wxObject(void *x) {
21122 return (void *)((wxObject *) ((wxFSFile *) x));
21123 }
21124 static void *_p_wxMemoryDCTo_p_wxObject(void *x) {
21125 return (void *)((wxObject *) (wxDC *) ((wxMemoryDC *) x));
21126 }
21127 static void *_p_wxRegionTo_p_wxObject(void *x) {
21128 return (void *)((wxObject *) (wxGDIObject *) ((wxRegion *) x));
21129 }
21130 static void *_p_wxPySizerTo_p_wxObject(void *x) {
21131 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
21132 }
21133 static void *_p_wxWindowDCTo_p_wxObject(void *x) {
21134 return (void *)((wxObject *) (wxDC *) ((wxWindowDC *) x));
21135 }
21136 static void *_p_wxGDIObjectTo_p_wxObject(void *x) {
21137 return (void *)((wxObject *) ((wxGDIObject *) x));
21138 }
21139 static void *_p_wxEffectsTo_p_wxObject(void *x) {
21140 return (void *)((wxObject *) ((wxEffects *) x));
21141 }
21142 static void *_p_wxPyEventTo_p_wxObject(void *x) {
21143 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
21144 }
21145 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
21146 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
21147 }
21148 static void *_p_wxPostScriptDCTo_p_wxObject(void *x) {
21149 return (void *)((wxObject *) (wxDC *) ((wxPostScriptDC *) x));
21150 }
21151 static void *_p_wxShowEventTo_p_wxObject(void *x) {
21152 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
21153 }
21154 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
21155 return (void *)((wxObject *) ((wxMenuItem *) x));
21156 }
21157 static void *_p_wxDateEventTo_p_wxObject(void *x) {
21158 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
21159 }
21160 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
21161 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
21162 }
21163 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
21164 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
21165 }
21166 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
21167 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
21168 }
21169 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
21170 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
21171 }
21172 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
21173 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
21174 }
21175 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
21176 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
21177 }
21178 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
21179 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
21180 }
21181 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
21182 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
21183 }
21184 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
21185 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
21186 }
21187 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
21188 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
21189 }
21190 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
21191 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
21192 }
21193 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
21194 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
21195 }
21196 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
21197 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
21198 }
21199 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
21200 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
21201 }
21202 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
21203 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
21204 }
21205 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
21206 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
21207 }
21208 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
21209 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
21210 }
21211 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
21212 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
21213 }
21214 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
21215 return (void *)((wxObject *) ((wxImageHandler *) x));
21216 }
21217 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
21218 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
21219 }
21220 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
21221 return (void *)((wxObject *) ((wxEvtHandler *) x));
21222 }
21223 static void *_p_wxBufferedPaintDCTo_p_wxObject(void *x) {
21224 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
21225 }
21226 static void *_p_wxPaintDCTo_p_wxObject(void *x) {
21227 return (void *)((wxObject *) (wxDC *) ((wxPaintDC *) x));
21228 }
21229 static void *_p_wxPrinterDCTo_p_wxObject(void *x) {
21230 return (void *)((wxObject *) (wxDC *) ((wxPrinterDC *) x));
21231 }
21232 static void *_p_wxScreenDCTo_p_wxObject(void *x) {
21233 return (void *)((wxObject *) (wxDC *) ((wxScreenDC *) x));
21234 }
21235 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
21236 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
21237 }
21238 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
21239 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
21240 }
21241 static void *_p_wxImageTo_p_wxObject(void *x) {
21242 return (void *)((wxObject *) ((wxImage *) x));
21243 }
21244 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
21245 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
21246 }
21247 static void *_p_wxPaletteTo_p_wxObject(void *x) {
21248 return (void *)((wxObject *) (wxGDIObject *) ((wxPalette *) x));
21249 }
21250 static void *_p_wxBufferedDCTo_p_wxObject(void *x) {
21251 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *) ((wxBufferedDC *) x));
21252 }
21253 static void *_p_wxImageListTo_p_wxObject(void *x) {
21254 return (void *)((wxObject *) ((wxImageList *) x));
21255 }
21256 static void *_p_wxCursorTo_p_wxObject(void *x) {
21257 return (void *)((wxObject *) (wxGDIObject *) ((wxCursor *) x));
21258 }
21259 static void *_p_wxEncodingConverterTo_p_wxObject(void *x) {
21260 return (void *)((wxObject *) ((wxEncodingConverter *) x));
21261 }
21262 static void *_p_wxMirrorDCTo_p_wxObject(void *x) {
21263 return (void *)((wxObject *) (wxDC *) ((wxMirrorDC *) x));
21264 }
21265 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
21266 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21267 }
21268 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
21269 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
21270 }
21271 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
21272 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
21273 }
21274 static void *_p_wxWindowTo_p_wxObject(void *x) {
21275 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
21276 }
21277 static void *_p_wxMenuTo_p_wxObject(void *x) {
21278 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
21279 }
21280 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
21281 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
21282 }
21283 static void *_p_wxMetaFileDCTo_p_wxObject(void *x) {
21284 return (void *)((wxObject *) (wxDC *) ((wxMetaFileDC *) x));
21285 }
21286 static void *_p_wxBrushListTo_p_wxObject(void *x) {
21287 return (void *)((wxObject *) ((wxBrushList *) x));
21288 }
21289 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
21290 return (void *)((wxObject *) ((wxFileSystem *) x));
21291 }
21292 static void *_p_wxBitmapTo_p_wxObject(void *x) {
21293 return (void *)((wxObject *) (wxGDIObject *) ((wxBitmap *) x));
21294 }
21295 static void *_p_wxMaskTo_p_wxObject(void *x) {
21296 return (void *)((wxObject *) ((wxMask *) x));
21297 }
21298 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
21299 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
21300 }
21301 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
21302 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
21303 }
21304 static void *_p_wxPyAppTo_p_wxObject(void *x) {
21305 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
21306 }
21307 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
21308 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
21309 }
21310 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
21311 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
21312 }
21313 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
21314 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
21315 }
21316 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
21317 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
21318 }
21319 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
21320 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
21321 }
21322 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
21323 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
21324 }
21325 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
21326 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
21327 }
21328 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
21329 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
21330 }
21331 static void *_p_wxFontTo_p_wxObject(void *x) {
21332 return (void *)((wxObject *) (wxGDIObject *) ((wxFont *) x));
21333 }
21334 static void *_p_wxBrushTo_p_wxObject(void *x) {
21335 return (void *)((wxObject *) (wxGDIObject *) ((wxBrush *) x));
21336 }
21337 static void *_p_wxMetaFileTo_p_wxObject(void *x) {
21338 return (void *)((wxObject *) ((wxMetaFile *) x));
21339 }
21340 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
21341 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
21342 }
21343 static void *_p_wxColourTo_p_wxObject(void *x) {
21344 return (void *)((wxObject *) ((wxColour *) x));
21345 }
21346 static void *_p_wxFontListTo_p_wxObject(void *x) {
21347 return (void *)((wxObject *) ((wxFontList *) x));
21348 }
21349 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
21350 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
21351 }
21352 static void *_p_wxValidatorTo_p_wxObject(void *x) {
21353 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
21354 }
21355 static void *_p_wxControlTo_p_wxWindow(void *x) {
21356 return (void *)((wxWindow *) ((wxControl *) x));
21357 }
21358 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
21359 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
21360 }
21361 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
21362 return (void *)((wxWindow *) ((wxMenuBar *) x));
21363 }
21364 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}};
21365 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}};
21366 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}};
21367 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}};
21368 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}};
21369 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}};
21370 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}};
21371 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}};
21372 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}};
21373 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}};
21374 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}};
21375 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}};
21376 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}};
21377 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}};
21378 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}};
21379 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}};
21380 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}};
21381 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}};
21382 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}};
21383 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}};
21384 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}};
21385 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}};
21386 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}};
21387 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}};
21388 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}};
21389 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}};
21390 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}};
21391 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}};
21392 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}};
21393 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}};
21394 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}};
21395 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}};
21396 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}};
21397 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}};
21398 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}};
21399 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}};
21400 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}};
21401 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}};
21402 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}};
21403 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}};
21404 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}};
21405 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}};
21406 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}};
21407 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}};
21408 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}};
21409 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}};
21410 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}};
21411 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}};
21412 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}};
21413 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}};
21414 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}};
21415 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}};
21416 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}};
21417 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}};
21418 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}};
21419 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}};
21420 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}};
21421 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}};
21422 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}};
21423 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}};
21424 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}};
21425 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}};
21426
21427 static swig_type_info *swig_types_initial[] = {
21428 _swigt__p_wxPostScriptDC,
21429 _swigt__p_wxBrush,
21430 _swigt__p_wxColour,
21431 _swigt__p_wxDC,
21432 _swigt__p_wxMirrorDC,
21433 _swigt__p_form_ops_t,
21434 _swigt__p_wxDuplexMode,
21435 _swigt__p_wxPyFontEnumerator,
21436 _swigt__p_char,
21437 _swigt__p_wxIconLocation,
21438 _swigt__p_wxImage,
21439 _swigt__p_wxMetaFileDC,
21440 _swigt__p_wxMask,
21441 _swigt__p_wxSize,
21442 _swigt__p_wxFont,
21443 _swigt__p_wxWindow,
21444 _swigt__p_double,
21445 _swigt__p_wxMemoryDC,
21446 _swigt__p_wxFontMapper,
21447 _swigt__p_wxEffects,
21448 _swigt__p_wxNativeEncodingInfo,
21449 _swigt__p_wxPalette,
21450 _swigt__p_wxBitmap,
21451 _swigt__p_wxObject,
21452 _swigt__p_wxRegionIterator,
21453 _swigt__p_wxRect,
21454 _swigt__p_wxPaperSize,
21455 _swigt__p_wxString,
21456 _swigt__unsigned_int,
21457 _swigt__p_unsigned_int,
21458 _swigt__p_wxPrinterDC,
21459 _swigt__p_wxIconBundle,
21460 _swigt__p_wxPoint,
21461 _swigt__p_wxDash,
21462 _swigt__p_wxScreenDC,
21463 _swigt__p_wxCursor,
21464 _swigt__p_wxClientDC,
21465 _swigt__p_wxBufferedDC,
21466 _swigt__p_wxImageList,
21467 _swigt__p_unsigned_char,
21468 _swigt__p_wxGDIObject,
21469 _swigt__p_wxIcon,
21470 _swigt__p_wxLocale,
21471 _swigt__ptrdiff_t,
21472 _swigt__std__ptrdiff_t,
21473 _swigt__p_wxRegion,
21474 _swigt__p_wxConfigBase,
21475 _swigt__p_wxLanguageInfo,
21476 _swigt__p_wxWindowDC,
21477 _swigt__p_wxPrintData,
21478 _swigt__p_wxBrushList,
21479 _swigt__p_wxFontList,
21480 _swigt__p_wxPen,
21481 _swigt__p_wxBufferedPaintDC,
21482 _swigt__p_wxPaintDC,
21483 _swigt__p_wxPenList,
21484 _swigt__p_int,
21485 _swigt__p_wxMetaFile,
21486 _swigt__p_unsigned_long,
21487 _swigt__p_wxNativeFontInfo,
21488 _swigt__p_wxEncodingConverter,
21489 _swigt__p_wxColourDatabase,
21490 0
21491 };
21492
21493
21494 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
21495
21496 static swig_const_info swig_const_table[] = {
21497 {0, 0, 0, 0.0, 0, 0}};
21498
21499 #ifdef __cplusplus
21500 }
21501 #endif
21502
21503
21504 #ifdef __cplusplus
21505 extern "C" {
21506 #endif
21507
21508 /* Python-specific SWIG API */
21509 #define SWIG_newvarlink() SWIG_Python_newvarlink()
21510 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
21511 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
21512
21513 /* -----------------------------------------------------------------------------
21514 * global variable support code.
21515 * ----------------------------------------------------------------------------- */
21516
21517 typedef struct swig_globalvar {
21518 char *name; /* Name of global variable */
21519 PyObject *(*get_attr)(); /* Return the current value */
21520 int (*set_attr)(PyObject *); /* Set the value */
21521 struct swig_globalvar *next;
21522 } swig_globalvar;
21523
21524 typedef struct swig_varlinkobject {
21525 PyObject_HEAD
21526 swig_globalvar *vars;
21527 } swig_varlinkobject;
21528
21529 static PyObject *
21530 swig_varlink_repr(swig_varlinkobject *v) {
21531 v = v;
21532 return PyString_FromString("<Swig global variables>");
21533 }
21534
21535 static int
21536 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
21537 swig_globalvar *var;
21538 flags = flags;
21539 fprintf(fp,"Swig global variables { ");
21540 for (var = v->vars; var; var=var->next) {
21541 fprintf(fp,"%s", var->name);
21542 if (var->next) fprintf(fp,", ");
21543 }
21544 fprintf(fp," }\n");
21545 return 0;
21546 }
21547
21548 static PyObject *
21549 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
21550 swig_globalvar *var = v->vars;
21551 while (var) {
21552 if (strcmp(var->name,n) == 0) {
21553 return (*var->get_attr)();
21554 }
21555 var = var->next;
21556 }
21557 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
21558 return NULL;
21559 }
21560
21561 static int
21562 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
21563 swig_globalvar *var = v->vars;
21564 while (var) {
21565 if (strcmp(var->name,n) == 0) {
21566 return (*var->set_attr)(p);
21567 }
21568 var = var->next;
21569 }
21570 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
21571 return 1;
21572 }
21573
21574 static PyTypeObject varlinktype = {
21575 PyObject_HEAD_INIT(0)
21576 0, /* Number of items in variable part (ob_size) */
21577 (char *)"swigvarlink", /* Type name (tp_name) */
21578 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
21579 0, /* Itemsize (tp_itemsize) */
21580 0, /* Deallocator (tp_dealloc) */
21581 (printfunc) swig_varlink_print, /* Print (tp_print) */
21582 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
21583 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
21584 0, /* tp_compare */
21585 (reprfunc) swig_varlink_repr, /* tp_repr */
21586 0, /* tp_as_number */
21587 0, /* tp_as_sequence */
21588 0, /* tp_as_mapping */
21589 0, /* tp_hash */
21590 0, /* tp_call */
21591 0, /* tp_str */
21592 0, /* tp_getattro */
21593 0, /* tp_setattro */
21594 0, /* tp_as_buffer */
21595 0, /* tp_flags */
21596 0, /* tp_doc */
21597 #if PY_VERSION_HEX >= 0x02000000
21598 0, /* tp_traverse */
21599 0, /* tp_clear */
21600 #endif
21601 #if PY_VERSION_HEX >= 0x02010000
21602 0, /* tp_richcompare */
21603 0, /* tp_weaklistoffset */
21604 #endif
21605 #if PY_VERSION_HEX >= 0x02020000
21606 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
21607 #endif
21608 #if PY_VERSION_HEX >= 0x02030000
21609 0, /* tp_del */
21610 #endif
21611 #ifdef COUNT_ALLOCS
21612 0,0,0,0 /* tp_alloc -> tp_next */
21613 #endif
21614 };
21615
21616 /* Create a variable linking object for use later */
21617 static PyObject *
21618 SWIG_Python_newvarlink(void) {
21619 swig_varlinkobject *result = 0;
21620 result = PyMem_NEW(swig_varlinkobject,1);
21621 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
21622 result->ob_type = &varlinktype;
21623 result->vars = 0;
21624 result->ob_refcnt = 0;
21625 Py_XINCREF((PyObject *) result);
21626 return ((PyObject*) result);
21627 }
21628
21629 static void
21630 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
21631 swig_varlinkobject *v;
21632 swig_globalvar *gv;
21633 v= (swig_varlinkobject *) p;
21634 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
21635 gv->name = (char *) malloc(strlen(name)+1);
21636 strcpy(gv->name,name);
21637 gv->get_attr = get_attr;
21638 gv->set_attr = set_attr;
21639 gv->next = v->vars;
21640 v->vars = gv;
21641 }
21642
21643 /* -----------------------------------------------------------------------------
21644 * constants/methods manipulation
21645 * ----------------------------------------------------------------------------- */
21646
21647 /* Install Constants */
21648 static void
21649 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
21650 PyObject *obj = 0;
21651 size_t i;
21652 for (i = 0; constants[i].type; i++) {
21653 switch(constants[i].type) {
21654 case SWIG_PY_INT:
21655 obj = PyInt_FromLong(constants[i].lvalue);
21656 break;
21657 case SWIG_PY_FLOAT:
21658 obj = PyFloat_FromDouble(constants[i].dvalue);
21659 break;
21660 case SWIG_PY_STRING:
21661 if (constants[i].pvalue) {
21662 obj = PyString_FromString((char *) constants[i].pvalue);
21663 } else {
21664 Py_INCREF(Py_None);
21665 obj = Py_None;
21666 }
21667 break;
21668 case SWIG_PY_POINTER:
21669 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
21670 break;
21671 case SWIG_PY_BINARY:
21672 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
21673 break;
21674 default:
21675 obj = 0;
21676 break;
21677 }
21678 if (obj) {
21679 PyDict_SetItemString(d,constants[i].name,obj);
21680 Py_DECREF(obj);
21681 }
21682 }
21683 }
21684
21685 /* -----------------------------------------------------------------------------*/
21686 /* Fix SwigMethods to carry the callback ptrs when needed */
21687 /* -----------------------------------------------------------------------------*/
21688
21689 static void
21690 SWIG_Python_FixMethods(PyMethodDef *methods,
21691 swig_const_info *const_table,
21692 swig_type_info **types,
21693 swig_type_info **types_initial) {
21694 size_t i;
21695 for (i = 0; methods[i].ml_name; ++i) {
21696 char *c = methods[i].ml_doc;
21697 if (c && (c = strstr(c, "swig_ptr: "))) {
21698 int j;
21699 swig_const_info *ci = 0;
21700 char *name = c + 10;
21701 for (j = 0; const_table[j].type; j++) {
21702 if (strncmp(const_table[j].name, name,
21703 strlen(const_table[j].name)) == 0) {
21704 ci = &(const_table[j]);
21705 break;
21706 }
21707 }
21708 if (ci) {
21709 size_t shift = (ci->ptype) - types;
21710 swig_type_info *ty = types_initial[shift];
21711 size_t ldoc = (c - methods[i].ml_doc);
21712 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
21713 char *ndoc = (char*)malloc(ldoc + lptr + 10);
21714 char *buff = ndoc;
21715 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
21716 strncpy(buff, methods[i].ml_doc, ldoc);
21717 buff += ldoc;
21718 strncpy(buff, "swig_ptr: ", 10);
21719 buff += 10;
21720 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
21721 methods[i].ml_doc = ndoc;
21722 }
21723 }
21724 }
21725 }
21726
21727 /* -----------------------------------------------------------------------------*
21728 * Initialize type list
21729 * -----------------------------------------------------------------------------*/
21730
21731 #if PY_MAJOR_VERSION < 2
21732 /* PyModule_AddObject function was introduced in Python 2.0. The following function
21733 is copied out of Python/modsupport.c in python version 2.3.4 */
21734 static int
21735 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
21736 {
21737 PyObject *dict;
21738 if (!PyModule_Check(m)) {
21739 PyErr_SetString(PyExc_TypeError,
21740 "PyModule_AddObject() needs module as first arg");
21741 return -1;
21742 }
21743 if (!o) {
21744 PyErr_SetString(PyExc_TypeError,
21745 "PyModule_AddObject() needs non-NULL value");
21746 return -1;
21747 }
21748
21749 dict = PyModule_GetDict(m);
21750 if (dict == NULL) {
21751 /* Internal error -- modules must have a dict! */
21752 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
21753 PyModule_GetName(m));
21754 return -1;
21755 }
21756 if (PyDict_SetItemString(dict, name, o))
21757 return -1;
21758 Py_DECREF(o);
21759 return 0;
21760 }
21761 #endif
21762
21763 static swig_type_info **
21764 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
21765 static PyMethodDef swig_empty_runtime_method_table[] = {
21766 {
21767 NULL, NULL, 0, NULL
21768 }
21769 };/* Sentinel */
21770
21771 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
21772 swig_empty_runtime_method_table);
21773 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
21774 if (pointer && module) {
21775 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
21776 }
21777 return type_list_handle;
21778 }
21779
21780 static swig_type_info **
21781 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
21782 swig_type_info **type_pointer;
21783
21784 /* first check if module already created */
21785 type_pointer = SWIG_Python_GetTypeListHandle();
21786 if (type_pointer) {
21787 return type_pointer;
21788 } else {
21789 /* create a new module and variable */
21790 return SWIG_Python_SetTypeListHandle(type_list_handle);
21791 }
21792 }
21793
21794 #ifdef __cplusplus
21795 }
21796 #endif
21797
21798 /* -----------------------------------------------------------------------------*
21799 * Partial Init method
21800 * -----------------------------------------------------------------------------*/
21801
21802 #ifdef SWIG_LINK_RUNTIME
21803 #ifdef __cplusplus
21804 extern "C"
21805 #endif
21806 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
21807 #endif
21808
21809 #ifdef __cplusplus
21810 extern "C"
21811 #endif
21812 SWIGEXPORT(void) SWIG_init(void) {
21813 static PyObject *SWIG_globals = 0;
21814 static int typeinit = 0;
21815 PyObject *m, *d;
21816 int i;
21817 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
21818
21819 /* Fix SwigMethods to carry the callback ptrs when needed */
21820 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
21821
21822 m = Py_InitModule((char *) SWIG_name, SwigMethods);
21823 d = PyModule_GetDict(m);
21824
21825 if (!typeinit) {
21826 #ifdef SWIG_LINK_RUNTIME
21827 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
21828 #else
21829 # ifndef SWIG_STATIC_RUNTIME
21830 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
21831 # endif
21832 #endif
21833 for (i = 0; swig_types_initial[i]; i++) {
21834 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
21835 }
21836 typeinit = 1;
21837 }
21838 SWIG_InstallConstants(d,swig_const_table);
21839
21840 {
21841 PyDict_SetItemString(d,"OutRegion", SWIG_From_int((int)(wxOutRegion)));
21842 }
21843 {
21844 PyDict_SetItemString(d,"PartRegion", SWIG_From_int((int)(wxPartRegion)));
21845 }
21846 {
21847 PyDict_SetItemString(d,"InRegion", SWIG_From_int((int)(wxInRegion)));
21848 }
21849 {
21850 PyDict_SetItemString(d,"FONTFAMILY_DEFAULT", SWIG_From_int((int)(wxFONTFAMILY_DEFAULT)));
21851 }
21852 {
21853 PyDict_SetItemString(d,"FONTFAMILY_DECORATIVE", SWIG_From_int((int)(wxFONTFAMILY_DECORATIVE)));
21854 }
21855 {
21856 PyDict_SetItemString(d,"FONTFAMILY_ROMAN", SWIG_From_int((int)(wxFONTFAMILY_ROMAN)));
21857 }
21858 {
21859 PyDict_SetItemString(d,"FONTFAMILY_SCRIPT", SWIG_From_int((int)(wxFONTFAMILY_SCRIPT)));
21860 }
21861 {
21862 PyDict_SetItemString(d,"FONTFAMILY_SWISS", SWIG_From_int((int)(wxFONTFAMILY_SWISS)));
21863 }
21864 {
21865 PyDict_SetItemString(d,"FONTFAMILY_MODERN", SWIG_From_int((int)(wxFONTFAMILY_MODERN)));
21866 }
21867 {
21868 PyDict_SetItemString(d,"FONTFAMILY_TELETYPE", SWIG_From_int((int)(wxFONTFAMILY_TELETYPE)));
21869 }
21870 {
21871 PyDict_SetItemString(d,"FONTFAMILY_MAX", SWIG_From_int((int)(wxFONTFAMILY_MAX)));
21872 }
21873 {
21874 PyDict_SetItemString(d,"FONTFAMILY_UNKNOWN", SWIG_From_int((int)(wxFONTFAMILY_UNKNOWN)));
21875 }
21876 {
21877 PyDict_SetItemString(d,"FONTSTYLE_NORMAL", SWIG_From_int((int)(wxFONTSTYLE_NORMAL)));
21878 }
21879 {
21880 PyDict_SetItemString(d,"FONTSTYLE_ITALIC", SWIG_From_int((int)(wxFONTSTYLE_ITALIC)));
21881 }
21882 {
21883 PyDict_SetItemString(d,"FONTSTYLE_SLANT", SWIG_From_int((int)(wxFONTSTYLE_SLANT)));
21884 }
21885 {
21886 PyDict_SetItemString(d,"FONTSTYLE_MAX", SWIG_From_int((int)(wxFONTSTYLE_MAX)));
21887 }
21888 {
21889 PyDict_SetItemString(d,"FONTWEIGHT_NORMAL", SWIG_From_int((int)(wxFONTWEIGHT_NORMAL)));
21890 }
21891 {
21892 PyDict_SetItemString(d,"FONTWEIGHT_LIGHT", SWIG_From_int((int)(wxFONTWEIGHT_LIGHT)));
21893 }
21894 {
21895 PyDict_SetItemString(d,"FONTWEIGHT_BOLD", SWIG_From_int((int)(wxFONTWEIGHT_BOLD)));
21896 }
21897 {
21898 PyDict_SetItemString(d,"FONTWEIGHT_MAX", SWIG_From_int((int)(wxFONTWEIGHT_MAX)));
21899 }
21900 {
21901 PyDict_SetItemString(d,"FONTFLAG_DEFAULT", SWIG_From_int((int)(wxFONTFLAG_DEFAULT)));
21902 }
21903 {
21904 PyDict_SetItemString(d,"FONTFLAG_ITALIC", SWIG_From_int((int)(wxFONTFLAG_ITALIC)));
21905 }
21906 {
21907 PyDict_SetItemString(d,"FONTFLAG_SLANT", SWIG_From_int((int)(wxFONTFLAG_SLANT)));
21908 }
21909 {
21910 PyDict_SetItemString(d,"FONTFLAG_LIGHT", SWIG_From_int((int)(wxFONTFLAG_LIGHT)));
21911 }
21912 {
21913 PyDict_SetItemString(d,"FONTFLAG_BOLD", SWIG_From_int((int)(wxFONTFLAG_BOLD)));
21914 }
21915 {
21916 PyDict_SetItemString(d,"FONTFLAG_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_ANTIALIASED)));
21917 }
21918 {
21919 PyDict_SetItemString(d,"FONTFLAG_NOT_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_NOT_ANTIALIASED)));
21920 }
21921 {
21922 PyDict_SetItemString(d,"FONTFLAG_UNDERLINED", SWIG_From_int((int)(wxFONTFLAG_UNDERLINED)));
21923 }
21924 {
21925 PyDict_SetItemString(d,"FONTFLAG_STRIKETHROUGH", SWIG_From_int((int)(wxFONTFLAG_STRIKETHROUGH)));
21926 }
21927 {
21928 PyDict_SetItemString(d,"FONTFLAG_MASK", SWIG_From_int((int)(wxFONTFLAG_MASK)));
21929 }
21930 {
21931 PyDict_SetItemString(d,"FONTENCODING_SYSTEM", SWIG_From_int((int)(wxFONTENCODING_SYSTEM)));
21932 }
21933 {
21934 PyDict_SetItemString(d,"FONTENCODING_DEFAULT", SWIG_From_int((int)(wxFONTENCODING_DEFAULT)));
21935 }
21936 {
21937 PyDict_SetItemString(d,"FONTENCODING_ISO8859_1", SWIG_From_int((int)(wxFONTENCODING_ISO8859_1)));
21938 }
21939 {
21940 PyDict_SetItemString(d,"FONTENCODING_ISO8859_2", SWIG_From_int((int)(wxFONTENCODING_ISO8859_2)));
21941 }
21942 {
21943 PyDict_SetItemString(d,"FONTENCODING_ISO8859_3", SWIG_From_int((int)(wxFONTENCODING_ISO8859_3)));
21944 }
21945 {
21946 PyDict_SetItemString(d,"FONTENCODING_ISO8859_4", SWIG_From_int((int)(wxFONTENCODING_ISO8859_4)));
21947 }
21948 {
21949 PyDict_SetItemString(d,"FONTENCODING_ISO8859_5", SWIG_From_int((int)(wxFONTENCODING_ISO8859_5)));
21950 }
21951 {
21952 PyDict_SetItemString(d,"FONTENCODING_ISO8859_6", SWIG_From_int((int)(wxFONTENCODING_ISO8859_6)));
21953 }
21954 {
21955 PyDict_SetItemString(d,"FONTENCODING_ISO8859_7", SWIG_From_int((int)(wxFONTENCODING_ISO8859_7)));
21956 }
21957 {
21958 PyDict_SetItemString(d,"FONTENCODING_ISO8859_8", SWIG_From_int((int)(wxFONTENCODING_ISO8859_8)));
21959 }
21960 {
21961 PyDict_SetItemString(d,"FONTENCODING_ISO8859_9", SWIG_From_int((int)(wxFONTENCODING_ISO8859_9)));
21962 }
21963 {
21964 PyDict_SetItemString(d,"FONTENCODING_ISO8859_10", SWIG_From_int((int)(wxFONTENCODING_ISO8859_10)));
21965 }
21966 {
21967 PyDict_SetItemString(d,"FONTENCODING_ISO8859_11", SWIG_From_int((int)(wxFONTENCODING_ISO8859_11)));
21968 }
21969 {
21970 PyDict_SetItemString(d,"FONTENCODING_ISO8859_12", SWIG_From_int((int)(wxFONTENCODING_ISO8859_12)));
21971 }
21972 {
21973 PyDict_SetItemString(d,"FONTENCODING_ISO8859_13", SWIG_From_int((int)(wxFONTENCODING_ISO8859_13)));
21974 }
21975 {
21976 PyDict_SetItemString(d,"FONTENCODING_ISO8859_14", SWIG_From_int((int)(wxFONTENCODING_ISO8859_14)));
21977 }
21978 {
21979 PyDict_SetItemString(d,"FONTENCODING_ISO8859_15", SWIG_From_int((int)(wxFONTENCODING_ISO8859_15)));
21980 }
21981 {
21982 PyDict_SetItemString(d,"FONTENCODING_ISO8859_MAX", SWIG_From_int((int)(wxFONTENCODING_ISO8859_MAX)));
21983 }
21984 {
21985 PyDict_SetItemString(d,"FONTENCODING_KOI8", SWIG_From_int((int)(wxFONTENCODING_KOI8)));
21986 }
21987 {
21988 PyDict_SetItemString(d,"FONTENCODING_KOI8_U", SWIG_From_int((int)(wxFONTENCODING_KOI8_U)));
21989 }
21990 {
21991 PyDict_SetItemString(d,"FONTENCODING_ALTERNATIVE", SWIG_From_int((int)(wxFONTENCODING_ALTERNATIVE)));
21992 }
21993 {
21994 PyDict_SetItemString(d,"FONTENCODING_BULGARIAN", SWIG_From_int((int)(wxFONTENCODING_BULGARIAN)));
21995 }
21996 {
21997 PyDict_SetItemString(d,"FONTENCODING_CP437", SWIG_From_int((int)(wxFONTENCODING_CP437)));
21998 }
21999 {
22000 PyDict_SetItemString(d,"FONTENCODING_CP850", SWIG_From_int((int)(wxFONTENCODING_CP850)));
22001 }
22002 {
22003 PyDict_SetItemString(d,"FONTENCODING_CP852", SWIG_From_int((int)(wxFONTENCODING_CP852)));
22004 }
22005 {
22006 PyDict_SetItemString(d,"FONTENCODING_CP855", SWIG_From_int((int)(wxFONTENCODING_CP855)));
22007 }
22008 {
22009 PyDict_SetItemString(d,"FONTENCODING_CP866", SWIG_From_int((int)(wxFONTENCODING_CP866)));
22010 }
22011 {
22012 PyDict_SetItemString(d,"FONTENCODING_CP874", SWIG_From_int((int)(wxFONTENCODING_CP874)));
22013 }
22014 {
22015 PyDict_SetItemString(d,"FONTENCODING_CP932", SWIG_From_int((int)(wxFONTENCODING_CP932)));
22016 }
22017 {
22018 PyDict_SetItemString(d,"FONTENCODING_CP936", SWIG_From_int((int)(wxFONTENCODING_CP936)));
22019 }
22020 {
22021 PyDict_SetItemString(d,"FONTENCODING_CP949", SWIG_From_int((int)(wxFONTENCODING_CP949)));
22022 }
22023 {
22024 PyDict_SetItemString(d,"FONTENCODING_CP950", SWIG_From_int((int)(wxFONTENCODING_CP950)));
22025 }
22026 {
22027 PyDict_SetItemString(d,"FONTENCODING_CP1250", SWIG_From_int((int)(wxFONTENCODING_CP1250)));
22028 }
22029 {
22030 PyDict_SetItemString(d,"FONTENCODING_CP1251", SWIG_From_int((int)(wxFONTENCODING_CP1251)));
22031 }
22032 {
22033 PyDict_SetItemString(d,"FONTENCODING_CP1252", SWIG_From_int((int)(wxFONTENCODING_CP1252)));
22034 }
22035 {
22036 PyDict_SetItemString(d,"FONTENCODING_CP1253", SWIG_From_int((int)(wxFONTENCODING_CP1253)));
22037 }
22038 {
22039 PyDict_SetItemString(d,"FONTENCODING_CP1254", SWIG_From_int((int)(wxFONTENCODING_CP1254)));
22040 }
22041 {
22042 PyDict_SetItemString(d,"FONTENCODING_CP1255", SWIG_From_int((int)(wxFONTENCODING_CP1255)));
22043 }
22044 {
22045 PyDict_SetItemString(d,"FONTENCODING_CP1256", SWIG_From_int((int)(wxFONTENCODING_CP1256)));
22046 }
22047 {
22048 PyDict_SetItemString(d,"FONTENCODING_CP1257", SWIG_From_int((int)(wxFONTENCODING_CP1257)));
22049 }
22050 {
22051 PyDict_SetItemString(d,"FONTENCODING_CP12_MAX", SWIG_From_int((int)(wxFONTENCODING_CP12_MAX)));
22052 }
22053 {
22054 PyDict_SetItemString(d,"FONTENCODING_UTF7", SWIG_From_int((int)(wxFONTENCODING_UTF7)));
22055 }
22056 {
22057 PyDict_SetItemString(d,"FONTENCODING_UTF8", SWIG_From_int((int)(wxFONTENCODING_UTF8)));
22058 }
22059 {
22060 PyDict_SetItemString(d,"FONTENCODING_EUC_JP", SWIG_From_int((int)(wxFONTENCODING_EUC_JP)));
22061 }
22062 {
22063 PyDict_SetItemString(d,"FONTENCODING_UTF16BE", SWIG_From_int((int)(wxFONTENCODING_UTF16BE)));
22064 }
22065 {
22066 PyDict_SetItemString(d,"FONTENCODING_UTF16LE", SWIG_From_int((int)(wxFONTENCODING_UTF16LE)));
22067 }
22068 {
22069 PyDict_SetItemString(d,"FONTENCODING_UTF32BE", SWIG_From_int((int)(wxFONTENCODING_UTF32BE)));
22070 }
22071 {
22072 PyDict_SetItemString(d,"FONTENCODING_UTF32LE", SWIG_From_int((int)(wxFONTENCODING_UTF32LE)));
22073 }
22074 {
22075 PyDict_SetItemString(d,"FONTENCODING_MACROMAN", SWIG_From_int((int)(wxFONTENCODING_MACROMAN)));
22076 }
22077 {
22078 PyDict_SetItemString(d,"FONTENCODING_MACJAPANESE", SWIG_From_int((int)(wxFONTENCODING_MACJAPANESE)));
22079 }
22080 {
22081 PyDict_SetItemString(d,"FONTENCODING_MACCHINESETRAD", SWIG_From_int((int)(wxFONTENCODING_MACCHINESETRAD)));
22082 }
22083 {
22084 PyDict_SetItemString(d,"FONTENCODING_MACKOREAN", SWIG_From_int((int)(wxFONTENCODING_MACKOREAN)));
22085 }
22086 {
22087 PyDict_SetItemString(d,"FONTENCODING_MACARABIC", SWIG_From_int((int)(wxFONTENCODING_MACARABIC)));
22088 }
22089 {
22090 PyDict_SetItemString(d,"FONTENCODING_MACHEBREW", SWIG_From_int((int)(wxFONTENCODING_MACHEBREW)));
22091 }
22092 {
22093 PyDict_SetItemString(d,"FONTENCODING_MACGREEK", SWIG_From_int((int)(wxFONTENCODING_MACGREEK)));
22094 }
22095 {
22096 PyDict_SetItemString(d,"FONTENCODING_MACCYRILLIC", SWIG_From_int((int)(wxFONTENCODING_MACCYRILLIC)));
22097 }
22098 {
22099 PyDict_SetItemString(d,"FONTENCODING_MACDEVANAGARI", SWIG_From_int((int)(wxFONTENCODING_MACDEVANAGARI)));
22100 }
22101 {
22102 PyDict_SetItemString(d,"FONTENCODING_MACGURMUKHI", SWIG_From_int((int)(wxFONTENCODING_MACGURMUKHI)));
22103 }
22104 {
22105 PyDict_SetItemString(d,"FONTENCODING_MACGUJARATI", SWIG_From_int((int)(wxFONTENCODING_MACGUJARATI)));
22106 }
22107 {
22108 PyDict_SetItemString(d,"FONTENCODING_MACORIYA", SWIG_From_int((int)(wxFONTENCODING_MACORIYA)));
22109 }
22110 {
22111 PyDict_SetItemString(d,"FONTENCODING_MACBENGALI", SWIG_From_int((int)(wxFONTENCODING_MACBENGALI)));
22112 }
22113 {
22114 PyDict_SetItemString(d,"FONTENCODING_MACTAMIL", SWIG_From_int((int)(wxFONTENCODING_MACTAMIL)));
22115 }
22116 {
22117 PyDict_SetItemString(d,"FONTENCODING_MACTELUGU", SWIG_From_int((int)(wxFONTENCODING_MACTELUGU)));
22118 }
22119 {
22120 PyDict_SetItemString(d,"FONTENCODING_MACKANNADA", SWIG_From_int((int)(wxFONTENCODING_MACKANNADA)));
22121 }
22122 {
22123 PyDict_SetItemString(d,"FONTENCODING_MACMALAJALAM", SWIG_From_int((int)(wxFONTENCODING_MACMALAJALAM)));
22124 }
22125 {
22126 PyDict_SetItemString(d,"FONTENCODING_MACSINHALESE", SWIG_From_int((int)(wxFONTENCODING_MACSINHALESE)));
22127 }
22128 {
22129 PyDict_SetItemString(d,"FONTENCODING_MACBURMESE", SWIG_From_int((int)(wxFONTENCODING_MACBURMESE)));
22130 }
22131 {
22132 PyDict_SetItemString(d,"FONTENCODING_MACKHMER", SWIG_From_int((int)(wxFONTENCODING_MACKHMER)));
22133 }
22134 {
22135 PyDict_SetItemString(d,"FONTENCODING_MACTHAI", SWIG_From_int((int)(wxFONTENCODING_MACTHAI)));
22136 }
22137 {
22138 PyDict_SetItemString(d,"FONTENCODING_MACLAOTIAN", SWIG_From_int((int)(wxFONTENCODING_MACLAOTIAN)));
22139 }
22140 {
22141 PyDict_SetItemString(d,"FONTENCODING_MACGEORGIAN", SWIG_From_int((int)(wxFONTENCODING_MACGEORGIAN)));
22142 }
22143 {
22144 PyDict_SetItemString(d,"FONTENCODING_MACARMENIAN", SWIG_From_int((int)(wxFONTENCODING_MACARMENIAN)));
22145 }
22146 {
22147 PyDict_SetItemString(d,"FONTENCODING_MACCHINESESIMP", SWIG_From_int((int)(wxFONTENCODING_MACCHINESESIMP)));
22148 }
22149 {
22150 PyDict_SetItemString(d,"FONTENCODING_MACTIBETAN", SWIG_From_int((int)(wxFONTENCODING_MACTIBETAN)));
22151 }
22152 {
22153 PyDict_SetItemString(d,"FONTENCODING_MACMONGOLIAN", SWIG_From_int((int)(wxFONTENCODING_MACMONGOLIAN)));
22154 }
22155 {
22156 PyDict_SetItemString(d,"FONTENCODING_MACETHIOPIC", SWIG_From_int((int)(wxFONTENCODING_MACETHIOPIC)));
22157 }
22158 {
22159 PyDict_SetItemString(d,"FONTENCODING_MACCENTRALEUR", SWIG_From_int((int)(wxFONTENCODING_MACCENTRALEUR)));
22160 }
22161 {
22162 PyDict_SetItemString(d,"FONTENCODING_MACVIATNAMESE", SWIG_From_int((int)(wxFONTENCODING_MACVIATNAMESE)));
22163 }
22164 {
22165 PyDict_SetItemString(d,"FONTENCODING_MACARABICEXT", SWIG_From_int((int)(wxFONTENCODING_MACARABICEXT)));
22166 }
22167 {
22168 PyDict_SetItemString(d,"FONTENCODING_MACSYMBOL", SWIG_From_int((int)(wxFONTENCODING_MACSYMBOL)));
22169 }
22170 {
22171 PyDict_SetItemString(d,"FONTENCODING_MACDINGBATS", SWIG_From_int((int)(wxFONTENCODING_MACDINGBATS)));
22172 }
22173 {
22174 PyDict_SetItemString(d,"FONTENCODING_MACTURKISH", SWIG_From_int((int)(wxFONTENCODING_MACTURKISH)));
22175 }
22176 {
22177 PyDict_SetItemString(d,"FONTENCODING_MACCROATIAN", SWIG_From_int((int)(wxFONTENCODING_MACCROATIAN)));
22178 }
22179 {
22180 PyDict_SetItemString(d,"FONTENCODING_MACICELANDIC", SWIG_From_int((int)(wxFONTENCODING_MACICELANDIC)));
22181 }
22182 {
22183 PyDict_SetItemString(d,"FONTENCODING_MACROMANIAN", SWIG_From_int((int)(wxFONTENCODING_MACROMANIAN)));
22184 }
22185 {
22186 PyDict_SetItemString(d,"FONTENCODING_MACCELTIC", SWIG_From_int((int)(wxFONTENCODING_MACCELTIC)));
22187 }
22188 {
22189 PyDict_SetItemString(d,"FONTENCODING_MACGAELIC", SWIG_From_int((int)(wxFONTENCODING_MACGAELIC)));
22190 }
22191 {
22192 PyDict_SetItemString(d,"FONTENCODING_MACKEYBOARD", SWIG_From_int((int)(wxFONTENCODING_MACKEYBOARD)));
22193 }
22194 {
22195 PyDict_SetItemString(d,"FONTENCODING_MACMIN", SWIG_From_int((int)(wxFONTENCODING_MACMIN)));
22196 }
22197 {
22198 PyDict_SetItemString(d,"FONTENCODING_MACMAX", SWIG_From_int((int)(wxFONTENCODING_MACMAX)));
22199 }
22200 {
22201 PyDict_SetItemString(d,"FONTENCODING_MAX", SWIG_From_int((int)(wxFONTENCODING_MAX)));
22202 }
22203 {
22204 PyDict_SetItemString(d,"FONTENCODING_UTF16", SWIG_From_int((int)(wxFONTENCODING_UTF16)));
22205 }
22206 {
22207 PyDict_SetItemString(d,"FONTENCODING_UTF32", SWIG_From_int((int)(wxFONTENCODING_UTF32)));
22208 }
22209 {
22210 PyDict_SetItemString(d,"FONTENCODING_UNICODE", SWIG_From_int((int)(wxFONTENCODING_UNICODE)));
22211 }
22212 {
22213 PyDict_SetItemString(d,"FONTENCODING_GB2312", SWIG_From_int((int)(wxFONTENCODING_GB2312)));
22214 }
22215 {
22216 PyDict_SetItemString(d,"FONTENCODING_BIG5", SWIG_From_int((int)(wxFONTENCODING_BIG5)));
22217 }
22218 {
22219 PyDict_SetItemString(d,"FONTENCODING_SHIFT_JIS", SWIG_From_int((int)(wxFONTENCODING_SHIFT_JIS)));
22220 }
22221
22222 wxPyPtrTypeMap_Add("wxFontEnumerator", "wxPyFontEnumerator");
22223
22224 {
22225 PyDict_SetItemString(d,"LANGUAGE_DEFAULT", SWIG_From_int((int)(wxLANGUAGE_DEFAULT)));
22226 }
22227 {
22228 PyDict_SetItemString(d,"LANGUAGE_UNKNOWN", SWIG_From_int((int)(wxLANGUAGE_UNKNOWN)));
22229 }
22230 {
22231 PyDict_SetItemString(d,"LANGUAGE_ABKHAZIAN", SWIG_From_int((int)(wxLANGUAGE_ABKHAZIAN)));
22232 }
22233 {
22234 PyDict_SetItemString(d,"LANGUAGE_AFAR", SWIG_From_int((int)(wxLANGUAGE_AFAR)));
22235 }
22236 {
22237 PyDict_SetItemString(d,"LANGUAGE_AFRIKAANS", SWIG_From_int((int)(wxLANGUAGE_AFRIKAANS)));
22238 }
22239 {
22240 PyDict_SetItemString(d,"LANGUAGE_ALBANIAN", SWIG_From_int((int)(wxLANGUAGE_ALBANIAN)));
22241 }
22242 {
22243 PyDict_SetItemString(d,"LANGUAGE_AMHARIC", SWIG_From_int((int)(wxLANGUAGE_AMHARIC)));
22244 }
22245 {
22246 PyDict_SetItemString(d,"LANGUAGE_ARABIC", SWIG_From_int((int)(wxLANGUAGE_ARABIC)));
22247 }
22248 {
22249 PyDict_SetItemString(d,"LANGUAGE_ARABIC_ALGERIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_ALGERIA)));
22250 }
22251 {
22252 PyDict_SetItemString(d,"LANGUAGE_ARABIC_BAHRAIN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_BAHRAIN)));
22253 }
22254 {
22255 PyDict_SetItemString(d,"LANGUAGE_ARABIC_EGYPT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_EGYPT)));
22256 }
22257 {
22258 PyDict_SetItemString(d,"LANGUAGE_ARABIC_IRAQ", SWIG_From_int((int)(wxLANGUAGE_ARABIC_IRAQ)));
22259 }
22260 {
22261 PyDict_SetItemString(d,"LANGUAGE_ARABIC_JORDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_JORDAN)));
22262 }
22263 {
22264 PyDict_SetItemString(d,"LANGUAGE_ARABIC_KUWAIT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_KUWAIT)));
22265 }
22266 {
22267 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LEBANON", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LEBANON)));
22268 }
22269 {
22270 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LIBYA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LIBYA)));
22271 }
22272 {
22273 PyDict_SetItemString(d,"LANGUAGE_ARABIC_MOROCCO", SWIG_From_int((int)(wxLANGUAGE_ARABIC_MOROCCO)));
22274 }
22275 {
22276 PyDict_SetItemString(d,"LANGUAGE_ARABIC_OMAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_OMAN)));
22277 }
22278 {
22279 PyDict_SetItemString(d,"LANGUAGE_ARABIC_QATAR", SWIG_From_int((int)(wxLANGUAGE_ARABIC_QATAR)));
22280 }
22281 {
22282 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SAUDI_ARABIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SAUDI_ARABIA)));
22283 }
22284 {
22285 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SUDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SUDAN)));
22286 }
22287 {
22288 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SYRIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SYRIA)));
22289 }
22290 {
22291 PyDict_SetItemString(d,"LANGUAGE_ARABIC_TUNISIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_TUNISIA)));
22292 }
22293 {
22294 PyDict_SetItemString(d,"LANGUAGE_ARABIC_UAE", SWIG_From_int((int)(wxLANGUAGE_ARABIC_UAE)));
22295 }
22296 {
22297 PyDict_SetItemString(d,"LANGUAGE_ARABIC_YEMEN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_YEMEN)));
22298 }
22299 {
22300 PyDict_SetItemString(d,"LANGUAGE_ARMENIAN", SWIG_From_int((int)(wxLANGUAGE_ARMENIAN)));
22301 }
22302 {
22303 PyDict_SetItemString(d,"LANGUAGE_ASSAMESE", SWIG_From_int((int)(wxLANGUAGE_ASSAMESE)));
22304 }
22305 {
22306 PyDict_SetItemString(d,"LANGUAGE_AYMARA", SWIG_From_int((int)(wxLANGUAGE_AYMARA)));
22307 }
22308 {
22309 PyDict_SetItemString(d,"LANGUAGE_AZERI", SWIG_From_int((int)(wxLANGUAGE_AZERI)));
22310 }
22311 {
22312 PyDict_SetItemString(d,"LANGUAGE_AZERI_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_AZERI_CYRILLIC)));
22313 }
22314 {
22315 PyDict_SetItemString(d,"LANGUAGE_AZERI_LATIN", SWIG_From_int((int)(wxLANGUAGE_AZERI_LATIN)));
22316 }
22317 {
22318 PyDict_SetItemString(d,"LANGUAGE_BASHKIR", SWIG_From_int((int)(wxLANGUAGE_BASHKIR)));
22319 }
22320 {
22321 PyDict_SetItemString(d,"LANGUAGE_BASQUE", SWIG_From_int((int)(wxLANGUAGE_BASQUE)));
22322 }
22323 {
22324 PyDict_SetItemString(d,"LANGUAGE_BELARUSIAN", SWIG_From_int((int)(wxLANGUAGE_BELARUSIAN)));
22325 }
22326 {
22327 PyDict_SetItemString(d,"LANGUAGE_BENGALI", SWIG_From_int((int)(wxLANGUAGE_BENGALI)));
22328 }
22329 {
22330 PyDict_SetItemString(d,"LANGUAGE_BHUTANI", SWIG_From_int((int)(wxLANGUAGE_BHUTANI)));
22331 }
22332 {
22333 PyDict_SetItemString(d,"LANGUAGE_BIHARI", SWIG_From_int((int)(wxLANGUAGE_BIHARI)));
22334 }
22335 {
22336 PyDict_SetItemString(d,"LANGUAGE_BISLAMA", SWIG_From_int((int)(wxLANGUAGE_BISLAMA)));
22337 }
22338 {
22339 PyDict_SetItemString(d,"LANGUAGE_BRETON", SWIG_From_int((int)(wxLANGUAGE_BRETON)));
22340 }
22341 {
22342 PyDict_SetItemString(d,"LANGUAGE_BULGARIAN", SWIG_From_int((int)(wxLANGUAGE_BULGARIAN)));
22343 }
22344 {
22345 PyDict_SetItemString(d,"LANGUAGE_BURMESE", SWIG_From_int((int)(wxLANGUAGE_BURMESE)));
22346 }
22347 {
22348 PyDict_SetItemString(d,"LANGUAGE_CAMBODIAN", SWIG_From_int((int)(wxLANGUAGE_CAMBODIAN)));
22349 }
22350 {
22351 PyDict_SetItemString(d,"LANGUAGE_CATALAN", SWIG_From_int((int)(wxLANGUAGE_CATALAN)));
22352 }
22353 {
22354 PyDict_SetItemString(d,"LANGUAGE_CHINESE", SWIG_From_int((int)(wxLANGUAGE_CHINESE)));
22355 }
22356 {
22357 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SIMPLIFIED", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SIMPLIFIED)));
22358 }
22359 {
22360 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TRADITIONAL", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TRADITIONAL)));
22361 }
22362 {
22363 PyDict_SetItemString(d,"LANGUAGE_CHINESE_HONGKONG", SWIG_From_int((int)(wxLANGUAGE_CHINESE_HONGKONG)));
22364 }
22365 {
22366 PyDict_SetItemString(d,"LANGUAGE_CHINESE_MACAU", SWIG_From_int((int)(wxLANGUAGE_CHINESE_MACAU)));
22367 }
22368 {
22369 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SINGAPORE", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SINGAPORE)));
22370 }
22371 {
22372 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TAIWAN", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TAIWAN)));
22373 }
22374 {
22375 PyDict_SetItemString(d,"LANGUAGE_CORSICAN", SWIG_From_int((int)(wxLANGUAGE_CORSICAN)));
22376 }
22377 {
22378 PyDict_SetItemString(d,"LANGUAGE_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_CROATIAN)));
22379 }
22380 {
22381 PyDict_SetItemString(d,"LANGUAGE_CZECH", SWIG_From_int((int)(wxLANGUAGE_CZECH)));
22382 }
22383 {
22384 PyDict_SetItemString(d,"LANGUAGE_DANISH", SWIG_From_int((int)(wxLANGUAGE_DANISH)));
22385 }
22386 {
22387 PyDict_SetItemString(d,"LANGUAGE_DUTCH", SWIG_From_int((int)(wxLANGUAGE_DUTCH)));
22388 }
22389 {
22390 PyDict_SetItemString(d,"LANGUAGE_DUTCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_DUTCH_BELGIAN)));
22391 }
22392 {
22393 PyDict_SetItemString(d,"LANGUAGE_ENGLISH", SWIG_From_int((int)(wxLANGUAGE_ENGLISH)));
22394 }
22395 {
22396 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_UK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_UK)));
22397 }
22398 {
22399 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_US", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_US)));
22400 }
22401 {
22402 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_AUSTRALIA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_AUSTRALIA)));
22403 }
22404 {
22405 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BELIZE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BELIZE)));
22406 }
22407 {
22408 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BOTSWANA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BOTSWANA)));
22409 }
22410 {
22411 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CANADA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CANADA)));
22412 }
22413 {
22414 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CARIBBEAN", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CARIBBEAN)));
22415 }
22416 {
22417 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_DENMARK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_DENMARK)));
22418 }
22419 {
22420 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_EIRE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_EIRE)));
22421 }
22422 {
22423 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_JAMAICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_JAMAICA)));
22424 }
22425 {
22426 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_NEW_ZEALAND", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_NEW_ZEALAND)));
22427 }
22428 {
22429 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_PHILIPPINES", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_PHILIPPINES)));
22430 }
22431 {
22432 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_SOUTH_AFRICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_SOUTH_AFRICA)));
22433 }
22434 {
22435 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_TRINIDAD", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_TRINIDAD)));
22436 }
22437 {
22438 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_ZIMBABWE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_ZIMBABWE)));
22439 }
22440 {
22441 PyDict_SetItemString(d,"LANGUAGE_ESPERANTO", SWIG_From_int((int)(wxLANGUAGE_ESPERANTO)));
22442 }
22443 {
22444 PyDict_SetItemString(d,"LANGUAGE_ESTONIAN", SWIG_From_int((int)(wxLANGUAGE_ESTONIAN)));
22445 }
22446 {
22447 PyDict_SetItemString(d,"LANGUAGE_FAEROESE", SWIG_From_int((int)(wxLANGUAGE_FAEROESE)));
22448 }
22449 {
22450 PyDict_SetItemString(d,"LANGUAGE_FARSI", SWIG_From_int((int)(wxLANGUAGE_FARSI)));
22451 }
22452 {
22453 PyDict_SetItemString(d,"LANGUAGE_FIJI", SWIG_From_int((int)(wxLANGUAGE_FIJI)));
22454 }
22455 {
22456 PyDict_SetItemString(d,"LANGUAGE_FINNISH", SWIG_From_int((int)(wxLANGUAGE_FINNISH)));
22457 }
22458 {
22459 PyDict_SetItemString(d,"LANGUAGE_FRENCH", SWIG_From_int((int)(wxLANGUAGE_FRENCH)));
22460 }
22461 {
22462 PyDict_SetItemString(d,"LANGUAGE_FRENCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_BELGIAN)));
22463 }
22464 {
22465 PyDict_SetItemString(d,"LANGUAGE_FRENCH_CANADIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_CANADIAN)));
22466 }
22467 {
22468 PyDict_SetItemString(d,"LANGUAGE_FRENCH_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_FRENCH_LUXEMBOURG)));
22469 }
22470 {
22471 PyDict_SetItemString(d,"LANGUAGE_FRENCH_MONACO", SWIG_From_int((int)(wxLANGUAGE_FRENCH_MONACO)));
22472 }
22473 {
22474 PyDict_SetItemString(d,"LANGUAGE_FRENCH_SWISS", SWIG_From_int((int)(wxLANGUAGE_FRENCH_SWISS)));
22475 }
22476 {
22477 PyDict_SetItemString(d,"LANGUAGE_FRISIAN", SWIG_From_int((int)(wxLANGUAGE_FRISIAN)));
22478 }
22479 {
22480 PyDict_SetItemString(d,"LANGUAGE_GALICIAN", SWIG_From_int((int)(wxLANGUAGE_GALICIAN)));
22481 }
22482 {
22483 PyDict_SetItemString(d,"LANGUAGE_GEORGIAN", SWIG_From_int((int)(wxLANGUAGE_GEORGIAN)));
22484 }
22485 {
22486 PyDict_SetItemString(d,"LANGUAGE_GERMAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN)));
22487 }
22488 {
22489 PyDict_SetItemString(d,"LANGUAGE_GERMAN_AUSTRIAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_AUSTRIAN)));
22490 }
22491 {
22492 PyDict_SetItemString(d,"LANGUAGE_GERMAN_BELGIUM", SWIG_From_int((int)(wxLANGUAGE_GERMAN_BELGIUM)));
22493 }
22494 {
22495 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LIECHTENSTEIN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LIECHTENSTEIN)));
22496 }
22497 {
22498 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LUXEMBOURG)));
22499 }
22500 {
22501 PyDict_SetItemString(d,"LANGUAGE_GERMAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_GERMAN_SWISS)));
22502 }
22503 {
22504 PyDict_SetItemString(d,"LANGUAGE_GREEK", SWIG_From_int((int)(wxLANGUAGE_GREEK)));
22505 }
22506 {
22507 PyDict_SetItemString(d,"LANGUAGE_GREENLANDIC", SWIG_From_int((int)(wxLANGUAGE_GREENLANDIC)));
22508 }
22509 {
22510 PyDict_SetItemString(d,"LANGUAGE_GUARANI", SWIG_From_int((int)(wxLANGUAGE_GUARANI)));
22511 }
22512 {
22513 PyDict_SetItemString(d,"LANGUAGE_GUJARATI", SWIG_From_int((int)(wxLANGUAGE_GUJARATI)));
22514 }
22515 {
22516 PyDict_SetItemString(d,"LANGUAGE_HAUSA", SWIG_From_int((int)(wxLANGUAGE_HAUSA)));
22517 }
22518 {
22519 PyDict_SetItemString(d,"LANGUAGE_HEBREW", SWIG_From_int((int)(wxLANGUAGE_HEBREW)));
22520 }
22521 {
22522 PyDict_SetItemString(d,"LANGUAGE_HINDI", SWIG_From_int((int)(wxLANGUAGE_HINDI)));
22523 }
22524 {
22525 PyDict_SetItemString(d,"LANGUAGE_HUNGARIAN", SWIG_From_int((int)(wxLANGUAGE_HUNGARIAN)));
22526 }
22527 {
22528 PyDict_SetItemString(d,"LANGUAGE_ICELANDIC", SWIG_From_int((int)(wxLANGUAGE_ICELANDIC)));
22529 }
22530 {
22531 PyDict_SetItemString(d,"LANGUAGE_INDONESIAN", SWIG_From_int((int)(wxLANGUAGE_INDONESIAN)));
22532 }
22533 {
22534 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUA", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUA)));
22535 }
22536 {
22537 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUE", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUE)));
22538 }
22539 {
22540 PyDict_SetItemString(d,"LANGUAGE_INUKTITUT", SWIG_From_int((int)(wxLANGUAGE_INUKTITUT)));
22541 }
22542 {
22543 PyDict_SetItemString(d,"LANGUAGE_INUPIAK", SWIG_From_int((int)(wxLANGUAGE_INUPIAK)));
22544 }
22545 {
22546 PyDict_SetItemString(d,"LANGUAGE_IRISH", SWIG_From_int((int)(wxLANGUAGE_IRISH)));
22547 }
22548 {
22549 PyDict_SetItemString(d,"LANGUAGE_ITALIAN", SWIG_From_int((int)(wxLANGUAGE_ITALIAN)));
22550 }
22551 {
22552 PyDict_SetItemString(d,"LANGUAGE_ITALIAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_ITALIAN_SWISS)));
22553 }
22554 {
22555 PyDict_SetItemString(d,"LANGUAGE_JAPANESE", SWIG_From_int((int)(wxLANGUAGE_JAPANESE)));
22556 }
22557 {
22558 PyDict_SetItemString(d,"LANGUAGE_JAVANESE", SWIG_From_int((int)(wxLANGUAGE_JAVANESE)));
22559 }
22560 {
22561 PyDict_SetItemString(d,"LANGUAGE_KANNADA", SWIG_From_int((int)(wxLANGUAGE_KANNADA)));
22562 }
22563 {
22564 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI)));
22565 }
22566 {
22567 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI_INDIA", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI_INDIA)));
22568 }
22569 {
22570 PyDict_SetItemString(d,"LANGUAGE_KAZAKH", SWIG_From_int((int)(wxLANGUAGE_KAZAKH)));
22571 }
22572 {
22573 PyDict_SetItemString(d,"LANGUAGE_KERNEWEK", SWIG_From_int((int)(wxLANGUAGE_KERNEWEK)));
22574 }
22575 {
22576 PyDict_SetItemString(d,"LANGUAGE_KINYARWANDA", SWIG_From_int((int)(wxLANGUAGE_KINYARWANDA)));
22577 }
22578 {
22579 PyDict_SetItemString(d,"LANGUAGE_KIRGHIZ", SWIG_From_int((int)(wxLANGUAGE_KIRGHIZ)));
22580 }
22581 {
22582 PyDict_SetItemString(d,"LANGUAGE_KIRUNDI", SWIG_From_int((int)(wxLANGUAGE_KIRUNDI)));
22583 }
22584 {
22585 PyDict_SetItemString(d,"LANGUAGE_KONKANI", SWIG_From_int((int)(wxLANGUAGE_KONKANI)));
22586 }
22587 {
22588 PyDict_SetItemString(d,"LANGUAGE_KOREAN", SWIG_From_int((int)(wxLANGUAGE_KOREAN)));
22589 }
22590 {
22591 PyDict_SetItemString(d,"LANGUAGE_KURDISH", SWIG_From_int((int)(wxLANGUAGE_KURDISH)));
22592 }
22593 {
22594 PyDict_SetItemString(d,"LANGUAGE_LAOTHIAN", SWIG_From_int((int)(wxLANGUAGE_LAOTHIAN)));
22595 }
22596 {
22597 PyDict_SetItemString(d,"LANGUAGE_LATIN", SWIG_From_int((int)(wxLANGUAGE_LATIN)));
22598 }
22599 {
22600 PyDict_SetItemString(d,"LANGUAGE_LATVIAN", SWIG_From_int((int)(wxLANGUAGE_LATVIAN)));
22601 }
22602 {
22603 PyDict_SetItemString(d,"LANGUAGE_LINGALA", SWIG_From_int((int)(wxLANGUAGE_LINGALA)));
22604 }
22605 {
22606 PyDict_SetItemString(d,"LANGUAGE_LITHUANIAN", SWIG_From_int((int)(wxLANGUAGE_LITHUANIAN)));
22607 }
22608 {
22609 PyDict_SetItemString(d,"LANGUAGE_MACEDONIAN", SWIG_From_int((int)(wxLANGUAGE_MACEDONIAN)));
22610 }
22611 {
22612 PyDict_SetItemString(d,"LANGUAGE_MALAGASY", SWIG_From_int((int)(wxLANGUAGE_MALAGASY)));
22613 }
22614 {
22615 PyDict_SetItemString(d,"LANGUAGE_MALAY", SWIG_From_int((int)(wxLANGUAGE_MALAY)));
22616 }
22617 {
22618 PyDict_SetItemString(d,"LANGUAGE_MALAYALAM", SWIG_From_int((int)(wxLANGUAGE_MALAYALAM)));
22619 }
22620 {
22621 PyDict_SetItemString(d,"LANGUAGE_MALAY_BRUNEI_DARUSSALAM", SWIG_From_int((int)(wxLANGUAGE_MALAY_BRUNEI_DARUSSALAM)));
22622 }
22623 {
22624 PyDict_SetItemString(d,"LANGUAGE_MALAY_MALAYSIA", SWIG_From_int((int)(wxLANGUAGE_MALAY_MALAYSIA)));
22625 }
22626 {
22627 PyDict_SetItemString(d,"LANGUAGE_MALTESE", SWIG_From_int((int)(wxLANGUAGE_MALTESE)));
22628 }
22629 {
22630 PyDict_SetItemString(d,"LANGUAGE_MANIPURI", SWIG_From_int((int)(wxLANGUAGE_MANIPURI)));
22631 }
22632 {
22633 PyDict_SetItemString(d,"LANGUAGE_MAORI", SWIG_From_int((int)(wxLANGUAGE_MAORI)));
22634 }
22635 {
22636 PyDict_SetItemString(d,"LANGUAGE_MARATHI", SWIG_From_int((int)(wxLANGUAGE_MARATHI)));
22637 }
22638 {
22639 PyDict_SetItemString(d,"LANGUAGE_MOLDAVIAN", SWIG_From_int((int)(wxLANGUAGE_MOLDAVIAN)));
22640 }
22641 {
22642 PyDict_SetItemString(d,"LANGUAGE_MONGOLIAN", SWIG_From_int((int)(wxLANGUAGE_MONGOLIAN)));
22643 }
22644 {
22645 PyDict_SetItemString(d,"LANGUAGE_NAURU", SWIG_From_int((int)(wxLANGUAGE_NAURU)));
22646 }
22647 {
22648 PyDict_SetItemString(d,"LANGUAGE_NEPALI", SWIG_From_int((int)(wxLANGUAGE_NEPALI)));
22649 }
22650 {
22651 PyDict_SetItemString(d,"LANGUAGE_NEPALI_INDIA", SWIG_From_int((int)(wxLANGUAGE_NEPALI_INDIA)));
22652 }
22653 {
22654 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_BOKMAL", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_BOKMAL)));
22655 }
22656 {
22657 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_NYNORSK", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_NYNORSK)));
22658 }
22659 {
22660 PyDict_SetItemString(d,"LANGUAGE_OCCITAN", SWIG_From_int((int)(wxLANGUAGE_OCCITAN)));
22661 }
22662 {
22663 PyDict_SetItemString(d,"LANGUAGE_ORIYA", SWIG_From_int((int)(wxLANGUAGE_ORIYA)));
22664 }
22665 {
22666 PyDict_SetItemString(d,"LANGUAGE_OROMO", SWIG_From_int((int)(wxLANGUAGE_OROMO)));
22667 }
22668 {
22669 PyDict_SetItemString(d,"LANGUAGE_PASHTO", SWIG_From_int((int)(wxLANGUAGE_PASHTO)));
22670 }
22671 {
22672 PyDict_SetItemString(d,"LANGUAGE_POLISH", SWIG_From_int((int)(wxLANGUAGE_POLISH)));
22673 }
22674 {
22675 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE)));
22676 }
22677 {
22678 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE_BRAZILIAN", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE_BRAZILIAN)));
22679 }
22680 {
22681 PyDict_SetItemString(d,"LANGUAGE_PUNJABI", SWIG_From_int((int)(wxLANGUAGE_PUNJABI)));
22682 }
22683 {
22684 PyDict_SetItemString(d,"LANGUAGE_QUECHUA", SWIG_From_int((int)(wxLANGUAGE_QUECHUA)));
22685 }
22686 {
22687 PyDict_SetItemString(d,"LANGUAGE_RHAETO_ROMANCE", SWIG_From_int((int)(wxLANGUAGE_RHAETO_ROMANCE)));
22688 }
22689 {
22690 PyDict_SetItemString(d,"LANGUAGE_ROMANIAN", SWIG_From_int((int)(wxLANGUAGE_ROMANIAN)));
22691 }
22692 {
22693 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN)));
22694 }
22695 {
22696 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN_UKRAINE", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN_UKRAINE)));
22697 }
22698 {
22699 PyDict_SetItemString(d,"LANGUAGE_SAMOAN", SWIG_From_int((int)(wxLANGUAGE_SAMOAN)));
22700 }
22701 {
22702 PyDict_SetItemString(d,"LANGUAGE_SANGHO", SWIG_From_int((int)(wxLANGUAGE_SANGHO)));
22703 }
22704 {
22705 PyDict_SetItemString(d,"LANGUAGE_SANSKRIT", SWIG_From_int((int)(wxLANGUAGE_SANSKRIT)));
22706 }
22707 {
22708 PyDict_SetItemString(d,"LANGUAGE_SCOTS_GAELIC", SWIG_From_int((int)(wxLANGUAGE_SCOTS_GAELIC)));
22709 }
22710 {
22711 PyDict_SetItemString(d,"LANGUAGE_SERBIAN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN)));
22712 }
22713 {
22714 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_CYRILLIC)));
22715 }
22716 {
22717 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_LATIN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_LATIN)));
22718 }
22719 {
22720 PyDict_SetItemString(d,"LANGUAGE_SERBO_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_SERBO_CROATIAN)));
22721 }
22722 {
22723 PyDict_SetItemString(d,"LANGUAGE_SESOTHO", SWIG_From_int((int)(wxLANGUAGE_SESOTHO)));
22724 }
22725 {
22726 PyDict_SetItemString(d,"LANGUAGE_SETSWANA", SWIG_From_int((int)(wxLANGUAGE_SETSWANA)));
22727 }
22728 {
22729 PyDict_SetItemString(d,"LANGUAGE_SHONA", SWIG_From_int((int)(wxLANGUAGE_SHONA)));
22730 }
22731 {
22732 PyDict_SetItemString(d,"LANGUAGE_SINDHI", SWIG_From_int((int)(wxLANGUAGE_SINDHI)));
22733 }
22734 {
22735 PyDict_SetItemString(d,"LANGUAGE_SINHALESE", SWIG_From_int((int)(wxLANGUAGE_SINHALESE)));
22736 }
22737 {
22738 PyDict_SetItemString(d,"LANGUAGE_SISWATI", SWIG_From_int((int)(wxLANGUAGE_SISWATI)));
22739 }
22740 {
22741 PyDict_SetItemString(d,"LANGUAGE_SLOVAK", SWIG_From_int((int)(wxLANGUAGE_SLOVAK)));
22742 }
22743 {
22744 PyDict_SetItemString(d,"LANGUAGE_SLOVENIAN", SWIG_From_int((int)(wxLANGUAGE_SLOVENIAN)));
22745 }
22746 {
22747 PyDict_SetItemString(d,"LANGUAGE_SOMALI", SWIG_From_int((int)(wxLANGUAGE_SOMALI)));
22748 }
22749 {
22750 PyDict_SetItemString(d,"LANGUAGE_SPANISH", SWIG_From_int((int)(wxLANGUAGE_SPANISH)));
22751 }
22752 {
22753 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ARGENTINA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ARGENTINA)));
22754 }
22755 {
22756 PyDict_SetItemString(d,"LANGUAGE_SPANISH_BOLIVIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_BOLIVIA)));
22757 }
22758 {
22759 PyDict_SetItemString(d,"LANGUAGE_SPANISH_CHILE", SWIG_From_int((int)(wxLANGUAGE_SPANISH_CHILE)));
22760 }
22761 {
22762 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COLOMBIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COLOMBIA)));
22763 }
22764 {
22765 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COSTA_RICA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COSTA_RICA)));
22766 }
22767 {
22768 PyDict_SetItemString(d,"LANGUAGE_SPANISH_DOMINICAN_REPUBLIC", SWIG_From_int((int)(wxLANGUAGE_SPANISH_DOMINICAN_REPUBLIC)));
22769 }
22770 {
22771 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ECUADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ECUADOR)));
22772 }
22773 {
22774 PyDict_SetItemString(d,"LANGUAGE_SPANISH_EL_SALVADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_EL_SALVADOR)));
22775 }
22776 {
22777 PyDict_SetItemString(d,"LANGUAGE_SPANISH_GUATEMALA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_GUATEMALA)));
22778 }
22779 {
22780 PyDict_SetItemString(d,"LANGUAGE_SPANISH_HONDURAS", SWIG_From_int((int)(wxLANGUAGE_SPANISH_HONDURAS)));
22781 }
22782 {
22783 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MEXICAN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MEXICAN)));
22784 }
22785 {
22786 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MODERN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MODERN)));
22787 }
22788 {
22789 PyDict_SetItemString(d,"LANGUAGE_SPANISH_NICARAGUA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_NICARAGUA)));
22790 }
22791 {
22792 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PANAMA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PANAMA)));
22793 }
22794 {
22795 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PARAGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PARAGUAY)));
22796 }
22797 {
22798 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PERU", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PERU)));
22799 }
22800 {
22801 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PUERTO_RICO", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PUERTO_RICO)));
22802 }
22803 {
22804 PyDict_SetItemString(d,"LANGUAGE_SPANISH_URUGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_URUGUAY)));
22805 }
22806 {
22807 PyDict_SetItemString(d,"LANGUAGE_SPANISH_US", SWIG_From_int((int)(wxLANGUAGE_SPANISH_US)));
22808 }
22809 {
22810 PyDict_SetItemString(d,"LANGUAGE_SPANISH_VENEZUELA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_VENEZUELA)));
22811 }
22812 {
22813 PyDict_SetItemString(d,"LANGUAGE_SUNDANESE", SWIG_From_int((int)(wxLANGUAGE_SUNDANESE)));
22814 }
22815 {
22816 PyDict_SetItemString(d,"LANGUAGE_SWAHILI", SWIG_From_int((int)(wxLANGUAGE_SWAHILI)));
22817 }
22818 {
22819 PyDict_SetItemString(d,"LANGUAGE_SWEDISH", SWIG_From_int((int)(wxLANGUAGE_SWEDISH)));
22820 }
22821 {
22822 PyDict_SetItemString(d,"LANGUAGE_SWEDISH_FINLAND", SWIG_From_int((int)(wxLANGUAGE_SWEDISH_FINLAND)));
22823 }
22824 {
22825 PyDict_SetItemString(d,"LANGUAGE_TAGALOG", SWIG_From_int((int)(wxLANGUAGE_TAGALOG)));
22826 }
22827 {
22828 PyDict_SetItemString(d,"LANGUAGE_TAJIK", SWIG_From_int((int)(wxLANGUAGE_TAJIK)));
22829 }
22830 {
22831 PyDict_SetItemString(d,"LANGUAGE_TAMIL", SWIG_From_int((int)(wxLANGUAGE_TAMIL)));
22832 }
22833 {
22834 PyDict_SetItemString(d,"LANGUAGE_TATAR", SWIG_From_int((int)(wxLANGUAGE_TATAR)));
22835 }
22836 {
22837 PyDict_SetItemString(d,"LANGUAGE_TELUGU", SWIG_From_int((int)(wxLANGUAGE_TELUGU)));
22838 }
22839 {
22840 PyDict_SetItemString(d,"LANGUAGE_THAI", SWIG_From_int((int)(wxLANGUAGE_THAI)));
22841 }
22842 {
22843 PyDict_SetItemString(d,"LANGUAGE_TIBETAN", SWIG_From_int((int)(wxLANGUAGE_TIBETAN)));
22844 }
22845 {
22846 PyDict_SetItemString(d,"LANGUAGE_TIGRINYA", SWIG_From_int((int)(wxLANGUAGE_TIGRINYA)));
22847 }
22848 {
22849 PyDict_SetItemString(d,"LANGUAGE_TONGA", SWIG_From_int((int)(wxLANGUAGE_TONGA)));
22850 }
22851 {
22852 PyDict_SetItemString(d,"LANGUAGE_TSONGA", SWIG_From_int((int)(wxLANGUAGE_TSONGA)));
22853 }
22854 {
22855 PyDict_SetItemString(d,"LANGUAGE_TURKISH", SWIG_From_int((int)(wxLANGUAGE_TURKISH)));
22856 }
22857 {
22858 PyDict_SetItemString(d,"LANGUAGE_TURKMEN", SWIG_From_int((int)(wxLANGUAGE_TURKMEN)));
22859 }
22860 {
22861 PyDict_SetItemString(d,"LANGUAGE_TWI", SWIG_From_int((int)(wxLANGUAGE_TWI)));
22862 }
22863 {
22864 PyDict_SetItemString(d,"LANGUAGE_UIGHUR", SWIG_From_int((int)(wxLANGUAGE_UIGHUR)));
22865 }
22866 {
22867 PyDict_SetItemString(d,"LANGUAGE_UKRAINIAN", SWIG_From_int((int)(wxLANGUAGE_UKRAINIAN)));
22868 }
22869 {
22870 PyDict_SetItemString(d,"LANGUAGE_URDU", SWIG_From_int((int)(wxLANGUAGE_URDU)));
22871 }
22872 {
22873 PyDict_SetItemString(d,"LANGUAGE_URDU_INDIA", SWIG_From_int((int)(wxLANGUAGE_URDU_INDIA)));
22874 }
22875 {
22876 PyDict_SetItemString(d,"LANGUAGE_URDU_PAKISTAN", SWIG_From_int((int)(wxLANGUAGE_URDU_PAKISTAN)));
22877 }
22878 {
22879 PyDict_SetItemString(d,"LANGUAGE_UZBEK", SWIG_From_int((int)(wxLANGUAGE_UZBEK)));
22880 }
22881 {
22882 PyDict_SetItemString(d,"LANGUAGE_UZBEK_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_UZBEK_CYRILLIC)));
22883 }
22884 {
22885 PyDict_SetItemString(d,"LANGUAGE_UZBEK_LATIN", SWIG_From_int((int)(wxLANGUAGE_UZBEK_LATIN)));
22886 }
22887 {
22888 PyDict_SetItemString(d,"LANGUAGE_VIETNAMESE", SWIG_From_int((int)(wxLANGUAGE_VIETNAMESE)));
22889 }
22890 {
22891 PyDict_SetItemString(d,"LANGUAGE_VOLAPUK", SWIG_From_int((int)(wxLANGUAGE_VOLAPUK)));
22892 }
22893 {
22894 PyDict_SetItemString(d,"LANGUAGE_WELSH", SWIG_From_int((int)(wxLANGUAGE_WELSH)));
22895 }
22896 {
22897 PyDict_SetItemString(d,"LANGUAGE_WOLOF", SWIG_From_int((int)(wxLANGUAGE_WOLOF)));
22898 }
22899 {
22900 PyDict_SetItemString(d,"LANGUAGE_XHOSA", SWIG_From_int((int)(wxLANGUAGE_XHOSA)));
22901 }
22902 {
22903 PyDict_SetItemString(d,"LANGUAGE_YIDDISH", SWIG_From_int((int)(wxLANGUAGE_YIDDISH)));
22904 }
22905 {
22906 PyDict_SetItemString(d,"LANGUAGE_YORUBA", SWIG_From_int((int)(wxLANGUAGE_YORUBA)));
22907 }
22908 {
22909 PyDict_SetItemString(d,"LANGUAGE_ZHUANG", SWIG_From_int((int)(wxLANGUAGE_ZHUANG)));
22910 }
22911 {
22912 PyDict_SetItemString(d,"LANGUAGE_ZULU", SWIG_From_int((int)(wxLANGUAGE_ZULU)));
22913 }
22914 {
22915 PyDict_SetItemString(d,"LANGUAGE_USER_DEFINED", SWIG_From_int((int)(wxLANGUAGE_USER_DEFINED)));
22916 }
22917 {
22918 PyDict_SetItemString(d,"LOCALE_CAT_NUMBER", SWIG_From_int((int)(wxLOCALE_CAT_NUMBER)));
22919 }
22920 {
22921 PyDict_SetItemString(d,"LOCALE_CAT_DATE", SWIG_From_int((int)(wxLOCALE_CAT_DATE)));
22922 }
22923 {
22924 PyDict_SetItemString(d,"LOCALE_CAT_MONEY", SWIG_From_int((int)(wxLOCALE_CAT_MONEY)));
22925 }
22926 {
22927 PyDict_SetItemString(d,"LOCALE_CAT_MAX", SWIG_From_int((int)(wxLOCALE_CAT_MAX)));
22928 }
22929 {
22930 PyDict_SetItemString(d,"LOCALE_THOUSANDS_SEP", SWIG_From_int((int)(wxLOCALE_THOUSANDS_SEP)));
22931 }
22932 {
22933 PyDict_SetItemString(d,"LOCALE_DECIMAL_POINT", SWIG_From_int((int)(wxLOCALE_DECIMAL_POINT)));
22934 }
22935 {
22936 PyDict_SetItemString(d,"LOCALE_LOAD_DEFAULT", SWIG_From_int((int)(wxLOCALE_LOAD_DEFAULT)));
22937 }
22938 {
22939 PyDict_SetItemString(d,"LOCALE_CONV_ENCODING", SWIG_From_int((int)(wxLOCALE_CONV_ENCODING)));
22940 }
22941 {
22942 PyDict_SetItemString(d,"CONVERT_STRICT", SWIG_From_int((int)(wxCONVERT_STRICT)));
22943 }
22944 {
22945 PyDict_SetItemString(d,"CONVERT_SUBSTITUTE", SWIG_From_int((int)(wxCONVERT_SUBSTITUTE)));
22946 }
22947 {
22948 PyDict_SetItemString(d,"PLATFORM_CURRENT", SWIG_From_int((int)(wxPLATFORM_CURRENT)));
22949 }
22950 {
22951 PyDict_SetItemString(d,"PLATFORM_UNIX", SWIG_From_int((int)(wxPLATFORM_UNIX)));
22952 }
22953 {
22954 PyDict_SetItemString(d,"PLATFORM_WINDOWS", SWIG_From_int((int)(wxPLATFORM_WINDOWS)));
22955 }
22956 {
22957 PyDict_SetItemString(d,"PLATFORM_OS2", SWIG_From_int((int)(wxPLATFORM_OS2)));
22958 }
22959 {
22960 PyDict_SetItemString(d,"PLATFORM_MAC", SWIG_From_int((int)(wxPLATFORM_MAC)));
22961 }
22962 {
22963 PyDict_SetItemString(d,"IMAGELIST_DRAW_NORMAL", SWIG_From_int((int)(wxIMAGELIST_DRAW_NORMAL)));
22964 }
22965 {
22966 PyDict_SetItemString(d,"IMAGELIST_DRAW_TRANSPARENT", SWIG_From_int((int)(wxIMAGELIST_DRAW_TRANSPARENT)));
22967 }
22968 {
22969 PyDict_SetItemString(d,"IMAGELIST_DRAW_SELECTED", SWIG_From_int((int)(wxIMAGELIST_DRAW_SELECTED)));
22970 }
22971 {
22972 PyDict_SetItemString(d,"IMAGELIST_DRAW_FOCUSED", SWIG_From_int((int)(wxIMAGELIST_DRAW_FOCUSED)));
22973 }
22974 {
22975 PyDict_SetItemString(d,"IMAGE_LIST_NORMAL", SWIG_From_int((int)(wxIMAGE_LIST_NORMAL)));
22976 }
22977 {
22978 PyDict_SetItemString(d,"IMAGE_LIST_SMALL", SWIG_From_int((int)(wxIMAGE_LIST_SMALL)));
22979 }
22980 {
22981 PyDict_SetItemString(d,"IMAGE_LIST_STATE", SWIG_From_int((int)(wxIMAGE_LIST_STATE)));
22982 }
22983 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
22984 SWIG_addvarlink(SWIG_globals,(char*)"NORMAL_FONT",_wrap_NORMAL_FONT_get, _wrap_NORMAL_FONT_set);
22985 SWIG_addvarlink(SWIG_globals,(char*)"SMALL_FONT",_wrap_SMALL_FONT_get, _wrap_SMALL_FONT_set);
22986 SWIG_addvarlink(SWIG_globals,(char*)"ITALIC_FONT",_wrap_ITALIC_FONT_get, _wrap_ITALIC_FONT_set);
22987 SWIG_addvarlink(SWIG_globals,(char*)"SWISS_FONT",_wrap_SWISS_FONT_get, _wrap_SWISS_FONT_set);
22988 SWIG_addvarlink(SWIG_globals,(char*)"RED_PEN",_wrap_RED_PEN_get, _wrap_RED_PEN_set);
22989 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_PEN",_wrap_CYAN_PEN_get, _wrap_CYAN_PEN_set);
22990 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_PEN",_wrap_GREEN_PEN_get, _wrap_GREEN_PEN_set);
22991 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_PEN",_wrap_BLACK_PEN_get, _wrap_BLACK_PEN_set);
22992 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_PEN",_wrap_WHITE_PEN_get, _wrap_WHITE_PEN_set);
22993 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_PEN",_wrap_TRANSPARENT_PEN_get, _wrap_TRANSPARENT_PEN_set);
22994 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_DASHED_PEN",_wrap_BLACK_DASHED_PEN_get, _wrap_BLACK_DASHED_PEN_set);
22995 SWIG_addvarlink(SWIG_globals,(char*)"GREY_PEN",_wrap_GREY_PEN_get, _wrap_GREY_PEN_set);
22996 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_PEN",_wrap_MEDIUM_GREY_PEN_get, _wrap_MEDIUM_GREY_PEN_set);
22997 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_PEN",_wrap_LIGHT_GREY_PEN_get, _wrap_LIGHT_GREY_PEN_set);
22998 SWIG_addvarlink(SWIG_globals,(char*)"BLUE_BRUSH",_wrap_BLUE_BRUSH_get, _wrap_BLUE_BRUSH_set);
22999 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_BRUSH",_wrap_GREEN_BRUSH_get, _wrap_GREEN_BRUSH_set);
23000 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_BRUSH",_wrap_WHITE_BRUSH_get, _wrap_WHITE_BRUSH_set);
23001 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_BRUSH",_wrap_BLACK_BRUSH_get, _wrap_BLACK_BRUSH_set);
23002 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_BRUSH",_wrap_TRANSPARENT_BRUSH_get, _wrap_TRANSPARENT_BRUSH_set);
23003 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_BRUSH",_wrap_CYAN_BRUSH_get, _wrap_CYAN_BRUSH_set);
23004 SWIG_addvarlink(SWIG_globals,(char*)"RED_BRUSH",_wrap_RED_BRUSH_get, _wrap_RED_BRUSH_set);
23005 SWIG_addvarlink(SWIG_globals,(char*)"GREY_BRUSH",_wrap_GREY_BRUSH_get, _wrap_GREY_BRUSH_set);
23006 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_BRUSH",_wrap_MEDIUM_GREY_BRUSH_get, _wrap_MEDIUM_GREY_BRUSH_set);
23007 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_BRUSH",_wrap_LIGHT_GREY_BRUSH_get, _wrap_LIGHT_GREY_BRUSH_set);
23008 SWIG_addvarlink(SWIG_globals,(char*)"BLACK",_wrap_BLACK_get, _wrap_BLACK_set);
23009 SWIG_addvarlink(SWIG_globals,(char*)"WHITE",_wrap_WHITE_get, _wrap_WHITE_set);
23010 SWIG_addvarlink(SWIG_globals,(char*)"RED",_wrap_RED_get, _wrap_RED_set);
23011 SWIG_addvarlink(SWIG_globals,(char*)"BLUE",_wrap_BLUE_get, _wrap_BLUE_set);
23012 SWIG_addvarlink(SWIG_globals,(char*)"GREEN",_wrap_GREEN_get, _wrap_GREEN_set);
23013 SWIG_addvarlink(SWIG_globals,(char*)"CYAN",_wrap_CYAN_get, _wrap_CYAN_set);
23014 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY",_wrap_LIGHT_GREY_get, _wrap_LIGHT_GREY_set);
23015 SWIG_addvarlink(SWIG_globals,(char*)"STANDARD_CURSOR",_wrap_STANDARD_CURSOR_get, _wrap_STANDARD_CURSOR_set);
23016 SWIG_addvarlink(SWIG_globals,(char*)"HOURGLASS_CURSOR",_wrap_HOURGLASS_CURSOR_get, _wrap_HOURGLASS_CURSOR_set);
23017 SWIG_addvarlink(SWIG_globals,(char*)"CROSS_CURSOR",_wrap_CROSS_CURSOR_get, _wrap_CROSS_CURSOR_set);
23018 SWIG_addvarlink(SWIG_globals,(char*)"NullBitmap",_wrap_NullBitmap_get, _wrap_NullBitmap_set);
23019 SWIG_addvarlink(SWIG_globals,(char*)"NullIcon",_wrap_NullIcon_get, _wrap_NullIcon_set);
23020 SWIG_addvarlink(SWIG_globals,(char*)"NullCursor",_wrap_NullCursor_get, _wrap_NullCursor_set);
23021 SWIG_addvarlink(SWIG_globals,(char*)"NullPen",_wrap_NullPen_get, _wrap_NullPen_set);
23022 SWIG_addvarlink(SWIG_globals,(char*)"NullBrush",_wrap_NullBrush_get, _wrap_NullBrush_set);
23023 SWIG_addvarlink(SWIG_globals,(char*)"NullPalette",_wrap_NullPalette_get, _wrap_NullPalette_set);
23024 SWIG_addvarlink(SWIG_globals,(char*)"NullFont",_wrap_NullFont_get, _wrap_NullFont_set);
23025 SWIG_addvarlink(SWIG_globals,(char*)"NullColour",_wrap_NullColour_get, _wrap_NullColour_set);
23026 SWIG_addvarlink(SWIG_globals,(char*)"TheFontList",_wrap_TheFontList_get, _wrap_TheFontList_set);
23027 SWIG_addvarlink(SWIG_globals,(char*)"ThePenList",_wrap_ThePenList_get, _wrap_ThePenList_set);
23028 SWIG_addvarlink(SWIG_globals,(char*)"TheBrushList",_wrap_TheBrushList_get, _wrap_TheBrushList_set);
23029 SWIG_addvarlink(SWIG_globals,(char*)"TheColourDatabase",_wrap_TheColourDatabase_get, _wrap_TheColourDatabase_set);
23030
23031 // Work around a chicken/egg problem in drawlist.cpp
23032 wxPyDrawList_SetAPIPtr();
23033
23034 }
23035
wxWidgets (Impactor)