]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_gdi_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Add support for launching APPL bundles with wxExecute
[wxWidgets.git] / wxPython / src / mac / _gdi_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 if (str)
1041 Py_DECREF(str);
1042 return;
1043 }
1044 }
1045 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1046 } else {
1047 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1048 }
1049 }
1050
1051 SWIGRUNTIMEINLINE void
1052 SWIG_Python_NullRef(const char *type)
1053 {
1054 if (type) {
1055 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1056 } else {
1057 PyErr_Format(PyExc_TypeError, "null reference was received");
1058 }
1059 }
1060
1061 SWIGRUNTIME int
1062 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1063 {
1064 if (PyErr_Occurred()) {
1065 PyObject *type = 0;
1066 PyObject *value = 0;
1067 PyObject *traceback = 0;
1068 PyErr_Fetch(&type, &value, &traceback);
1069 if (value) {
1070 PyObject *old_str = PyObject_Str(value);
1071 Py_XINCREF(type);
1072 PyErr_Clear();
1073 if (infront) {
1074 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1075 } else {
1076 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1077 }
1078 Py_DECREF(old_str);
1079 }
1080 return 1;
1081 } else {
1082 return 0;
1083 }
1084 }
1085
1086 SWIGRUNTIME int
1087 SWIG_Python_ArgFail(int argnum)
1088 {
1089 if (PyErr_Occurred()) {
1090 /* add information about failing argument */
1091 char mesg[256];
1092 sprintf(mesg, "argument number %d:", argnum);
1093 return SWIG_Python_AddErrMesg(mesg, 1);
1094 } else {
1095 return 0;
1096 }
1097 }
1098
1099
1100 /* -----------------------------------------------------------------------------
1101 * pointers/data manipulation
1102 * ----------------------------------------------------------------------------- */
1103
1104 /* Convert a pointer value */
1105 SWIGRUNTIME int
1106 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1107 swig_type_info *tc;
1108 const char *c = 0;
1109 static PyObject *SWIG_this = 0;
1110 int newref = 0;
1111 PyObject *pyobj = 0;
1112 void *vptr;
1113
1114 if (!obj) return 0;
1115 if (obj == Py_None) {
1116 *ptr = 0;
1117 return 0;
1118 }
1119
1120 #ifdef SWIG_COBJECT_TYPES
1121 if (!(PySwigObject_Check(obj))) {
1122 if (!SWIG_this)
1123 SWIG_this = PyString_FromString("this");
1124 pyobj = obj;
1125 obj = PyObject_GetAttr(obj,SWIG_this);
1126 newref = 1;
1127 if (!obj) goto type_error;
1128 if (!PySwigObject_Check(obj)) {
1129 Py_DECREF(obj);
1130 goto type_error;
1131 }
1132 }
1133 vptr = PySwigObject_AsVoidPtr(obj);
1134 c = (const char *) PySwigObject_GetDesc(obj);
1135 if (newref) { Py_DECREF(obj); }
1136 goto type_check;
1137 #else
1138 if (!(PyString_Check(obj))) {
1139 if (!SWIG_this)
1140 SWIG_this = PyString_FromString("this");
1141 pyobj = obj;
1142 obj = PyObject_GetAttr(obj,SWIG_this);
1143 newref = 1;
1144 if (!obj) goto type_error;
1145 if (!PyString_Check(obj)) {
1146 Py_DECREF(obj);
1147 goto type_error;
1148 }
1149 }
1150 c = PyString_AS_STRING(obj);
1151 /* Pointer values must start with leading underscore */
1152 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1153 if (newref) { Py_DECREF(obj); }
1154 if (!c) goto type_error;
1155 #endif
1156
1157 type_check:
1158
1159 if (ty) {
1160 tc = SWIG_TypeCheck(c,ty);
1161 if (!tc) goto type_error;
1162 *ptr = SWIG_TypeCast(tc,vptr);
1163 } else {
1164 *ptr = vptr;
1165 }
1166
1167 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1168 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1169 }
1170 return 0;
1171
1172 type_error:
1173 PyErr_Clear();
1174 if (pyobj && !obj) {
1175 obj = pyobj;
1176 if (PyCFunction_Check(obj)) {
1177 /* here we get the method pointer for callbacks */
1178 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1179 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1180 if (c) {
1181 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1182 if (!c) goto type_error;
1183 goto type_check;
1184 }
1185 }
1186 }
1187 if (flags & SWIG_POINTER_EXCEPTION) {
1188 if (ty) {
1189 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1190 } else {
1191 SWIG_Python_TypeError("C/C++ pointer", obj);
1192 }
1193 }
1194 return -1;
1195 }
1196
1197 /* Convert a pointer value, signal an exception on a type mismatch */
1198 SWIGRUNTIME void *
1199 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1200 void *result;
1201 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1202 PyErr_Clear();
1203 if (flags & SWIG_POINTER_EXCEPTION) {
1204 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1205 SWIG_Python_ArgFail(argnum);
1206 }
1207 }
1208 return result;
1209 }
1210
1211 /* Convert a packed value value */
1212 SWIGRUNTIME int
1213 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1214 swig_type_info *tc;
1215 const char *c = 0;
1216
1217 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1218 c = PySwigPacked_UnpackData(obj, ptr, sz);
1219 #else
1220 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1221 c = PyString_AS_STRING(obj);
1222 /* Pointer values must start with leading underscore */
1223 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1224 #endif
1225 if (!c) goto type_error;
1226 if (ty) {
1227 tc = SWIG_TypeCheck(c,ty);
1228 if (!tc) goto type_error;
1229 }
1230 return 0;
1231
1232 type_error:
1233 PyErr_Clear();
1234 if (flags & SWIG_POINTER_EXCEPTION) {
1235 if (ty) {
1236 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1237 } else {
1238 SWIG_Python_TypeError("C/C++ packed data", obj);
1239 }
1240 }
1241 return -1;
1242 }
1243
1244 /* Create a new array object */
1245 SWIGRUNTIME PyObject *
1246 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1247 PyObject *robj = 0;
1248 if (!ptr) {
1249 Py_INCREF(Py_None);
1250 return Py_None;
1251 }
1252 #ifdef SWIG_COBJECT_TYPES
1253 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1254 #else
1255 {
1256 char result[SWIG_BUFFER_SIZE];
1257 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1258 PyString_FromString(result) : 0;
1259 }
1260 #endif
1261 if (!robj || (robj == Py_None)) return robj;
1262 if (type->clientdata) {
1263 PyObject *inst;
1264 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1265 Py_DECREF(robj);
1266 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1267 Py_DECREF(args);
1268 if (inst) {
1269 if (own) {
1270 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1271 }
1272 robj = inst;
1273 }
1274 }
1275 return robj;
1276 }
1277
1278 SWIGRUNTIME PyObject *
1279 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1280 PyObject *robj = 0;
1281 if (!ptr) {
1282 Py_INCREF(Py_None);
1283 return Py_None;
1284 }
1285 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1286 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1287 #else
1288 {
1289 char result[SWIG_BUFFER_SIZE];
1290 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1291 PyString_FromString(result) : 0;
1292 }
1293 #endif
1294 return robj;
1295 }
1296
1297 /* -----------------------------------------------------------------------------*
1298 * Get type list
1299 * -----------------------------------------------------------------------------*/
1300
1301 #ifdef SWIG_LINK_RUNTIME
1302 void *SWIG_ReturnGlobalTypeList(void *);
1303 #endif
1304
1305 SWIGRUNTIME swig_type_info **
1306 SWIG_Python_GetTypeListHandle() {
1307 static void *type_pointer = (void *)0;
1308 /* first check if module already created */
1309 if (!type_pointer) {
1310 #ifdef SWIG_LINK_RUNTIME
1311 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1312 #else
1313 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1314 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1315 if (PyErr_Occurred()) {
1316 PyErr_Clear();
1317 type_pointer = (void *)0;
1318 }
1319 }
1320 #endif
1321 return (swig_type_info **) type_pointer;
1322 }
1323
1324 /*
1325 Search for a swig_type_info structure
1326 */
1327 SWIGRUNTIMEINLINE swig_type_info *
1328 SWIG_Python_GetTypeList() {
1329 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1330 return tlh ? *tlh : (swig_type_info*)0;
1331 }
1332
1333 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1334
1335 #ifdef __cplusplus
1336 }
1337 #endif
1338
1339
1340 /* -------- TYPES TABLE (BEGIN) -------- */
1341
1342 #define SWIGTYPE_p_wxPostScriptDC swig_types[0]
1343 #define SWIGTYPE_p_wxBrush swig_types[1]
1344 #define SWIGTYPE_p_wxColour swig_types[2]
1345 #define SWIGTYPE_p_wxDC swig_types[3]
1346 #define SWIGTYPE_p_wxMirrorDC swig_types[4]
1347 #define SWIGTYPE_p_form_ops_t swig_types[5]
1348 #define SWIGTYPE_p_wxDuplexMode swig_types[6]
1349 #define SWIGTYPE_p_wxPyFontEnumerator swig_types[7]
1350 #define SWIGTYPE_p_char swig_types[8]
1351 #define SWIGTYPE_p_wxIconLocation swig_types[9]
1352 #define SWIGTYPE_p_wxImage swig_types[10]
1353 #define SWIGTYPE_p_wxMetaFileDC swig_types[11]
1354 #define SWIGTYPE_p_wxMask swig_types[12]
1355 #define SWIGTYPE_p_wxSize swig_types[13]
1356 #define SWIGTYPE_p_wxFont swig_types[14]
1357 #define SWIGTYPE_p_wxWindow swig_types[15]
1358 #define SWIGTYPE_p_double swig_types[16]
1359 #define SWIGTYPE_p_wxMemoryDC swig_types[17]
1360 #define SWIGTYPE_p_wxFontMapper swig_types[18]
1361 #define SWIGTYPE_p_wxEffects swig_types[19]
1362 #define SWIGTYPE_p_wxNativeEncodingInfo swig_types[20]
1363 #define SWIGTYPE_p_wxPalette swig_types[21]
1364 #define SWIGTYPE_p_wxBitmap swig_types[22]
1365 #define SWIGTYPE_p_wxObject swig_types[23]
1366 #define SWIGTYPE_p_wxRegionIterator swig_types[24]
1367 #define SWIGTYPE_p_wxRect swig_types[25]
1368 #define SWIGTYPE_p_wxPaperSize swig_types[26]
1369 #define SWIGTYPE_p_wxString swig_types[27]
1370 #define SWIGTYPE_unsigned_int swig_types[28]
1371 #define SWIGTYPE_p_unsigned_int swig_types[29]
1372 #define SWIGTYPE_p_wxPrinterDC swig_types[30]
1373 #define SWIGTYPE_p_wxIconBundle swig_types[31]
1374 #define SWIGTYPE_p_wxPoint swig_types[32]
1375 #define SWIGTYPE_p_wxDash swig_types[33]
1376 #define SWIGTYPE_p_wxScreenDC swig_types[34]
1377 #define SWIGTYPE_p_wxCursor swig_types[35]
1378 #define SWIGTYPE_p_wxClientDC swig_types[36]
1379 #define SWIGTYPE_p_wxBufferedDC swig_types[37]
1380 #define SWIGTYPE_p_wxImageList swig_types[38]
1381 #define SWIGTYPE_p_unsigned_char swig_types[39]
1382 #define SWIGTYPE_p_wxGDIObject swig_types[40]
1383 #define SWIGTYPE_p_wxIcon swig_types[41]
1384 #define SWIGTYPE_p_wxLocale swig_types[42]
1385 #define SWIGTYPE_ptrdiff_t swig_types[43]
1386 #define SWIGTYPE_std__ptrdiff_t swig_types[44]
1387 #define SWIGTYPE_p_wxRegion swig_types[45]
1388 #define SWIGTYPE_p_wxConfigBase swig_types[46]
1389 #define SWIGTYPE_p_wxLanguageInfo swig_types[47]
1390 #define SWIGTYPE_p_wxWindowDC swig_types[48]
1391 #define SWIGTYPE_p_wxPrintData swig_types[49]
1392 #define SWIGTYPE_p_wxBrushList swig_types[50]
1393 #define SWIGTYPE_p_wxFontList swig_types[51]
1394 #define SWIGTYPE_p_wxPen swig_types[52]
1395 #define SWIGTYPE_p_wxBufferedPaintDC swig_types[53]
1396 #define SWIGTYPE_p_wxPaintDC swig_types[54]
1397 #define SWIGTYPE_p_wxPenList swig_types[55]
1398 #define SWIGTYPE_p_int swig_types[56]
1399 #define SWIGTYPE_p_wxMetaFile swig_types[57]
1400 #define SWIGTYPE_p_unsigned_long swig_types[58]
1401 #define SWIGTYPE_p_wxNativeFontInfo swig_types[59]
1402 #define SWIGTYPE_p_wxEncodingConverter swig_types[60]
1403 #define SWIGTYPE_p_wxColourDatabase swig_types[61]
1404 static swig_type_info *swig_types[63];
1405
1406 /* -------- TYPES TABLE (END) -------- */
1407
1408
1409 /*-----------------------------------------------
1410 @(target):= _gdi_.so
1411 ------------------------------------------------*/
1412 #define SWIG_init init_gdi_
1413
1414 #define SWIG_name "_gdi_"
1415
1416 #include "wx/wxPython/wxPython.h"
1417 #include "wx/wxPython/pyclasses.h"
1418
1419
1420 static const wxString wxPyEmptyString(wxEmptyString);
1421
1422 #include <limits.h>
1423
1424
1425 SWIGINTERN int
1426 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1427 const char *errmsg)
1428 {
1429 if (value < min_value) {
1430 if (errmsg) {
1431 PyErr_Format(PyExc_OverflowError,
1432 "value %ld is less than '%s' minimum %ld",
1433 value, errmsg, min_value);
1434 }
1435 return 0;
1436 } else if (value > max_value) {
1437 if (errmsg) {
1438 PyErr_Format(PyExc_OverflowError,
1439 "value %ld is greater than '%s' maximum %ld",
1440 value, errmsg, max_value);
1441 }
1442 return 0;
1443 }
1444 return 1;
1445 }
1446
1447
1448 SWIGINTERN int
1449 SWIG_AsVal_long(PyObject* obj, long* val)
1450 {
1451 if (PyNumber_Check(obj)) {
1452 if (val) *val = PyInt_AsLong(obj);
1453 return 1;
1454 }
1455 else {
1456 SWIG_type_error("number", obj);
1457 }
1458 return 0;
1459 }
1460
1461
1462 #if INT_MAX != LONG_MAX
1463 SWIGINTERN int
1464 SWIG_AsVal_int(PyObject *obj, int *val)
1465 {
1466 const char* errmsg = val ? "int" : (char*)0;
1467 long v;
1468 if (SWIG_AsVal_long(obj, &v)) {
1469 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1470 if (val) *val = (int)(v);
1471 return 1;
1472 } else {
1473 return 0;
1474 }
1475 } else {
1476 PyErr_Clear();
1477 }
1478 if (val) {
1479 SWIG_type_error(errmsg, obj);
1480 }
1481 return 0;
1482 }
1483 #else
1484 SWIGINTERNSHORT int
1485 SWIG_AsVal_int(PyObject *obj, int *val)
1486 {
1487 return SWIG_AsVal_long(obj,(long*)val);
1488 }
1489 #endif
1490
1491
1492 SWIGINTERN int
1493 SWIG_AsVal_bool(PyObject *obj, bool *val)
1494 {
1495 if (obj == Py_True) {
1496 if (val) *val = true;
1497 return 1;
1498 }
1499 if (obj == Py_False) {
1500 if (val) *val = false;
1501 return 1;
1502 }
1503 int res = 0;
1504 if (SWIG_AsVal_int(obj, &res)) {
1505 if (val) *val = res ? true : false;
1506 return 1;
1507 } else {
1508 PyErr_Clear();
1509 }
1510 if (val) {
1511 SWIG_type_error("bool", obj);
1512 }
1513 return 0;
1514 }
1515
1516
1517 SWIGINTERNSHORT bool
1518 SWIG_As_bool(PyObject* obj)
1519 {
1520 bool v;
1521 if (!SWIG_AsVal_bool(obj, &v)) {
1522 /*
1523 this is needed to make valgrind/purify happier.
1524 */
1525 memset((void*)&v, 0, sizeof(bool));
1526 }
1527 return v;
1528 }
1529
1530
1531 SWIGINTERNSHORT int
1532 SWIG_Check_bool(PyObject* obj)
1533 {
1534 return SWIG_AsVal_bool(obj, (bool*)0);
1535 }
1536
1537
1538 SWIGINTERN int
1539 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1540 {
1541 long v = 0;
1542 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1543 SWIG_type_error("unsigned number", obj);
1544 }
1545 else if (val)
1546 *val = (unsigned long)v;
1547 return 1;
1548 }
1549
1550
1551 SWIGINTERNSHORT int
1552 SWIG_CheckUnsignedLongInRange(unsigned long value,
1553 unsigned long max_value,
1554 const char *errmsg)
1555 {
1556 if (value > max_value) {
1557 if (errmsg) {
1558 PyErr_Format(PyExc_OverflowError,
1559 "value %lu is greater than '%s' minimum %lu",
1560 value, errmsg, max_value);
1561 }
1562 return 0;
1563 }
1564 return 1;
1565 }
1566
1567
1568 SWIGINTERN int
1569 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
1570 {
1571 const char* errmsg = val ? "unsigned char" : (char*)0;
1572 unsigned long v;
1573 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1574 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
1575 if (val) *val = (unsigned char)(v);
1576 return 1;
1577 } else {
1578 return 0;
1579 }
1580 } else {
1581 PyErr_Clear();
1582 }
1583 if (val) {
1584 SWIG_type_error(errmsg, obj);
1585 }
1586 return 0;
1587 }
1588
1589
1590 SWIGINTERNSHORT unsigned char
1591 SWIG_As_unsigned_SS_char(PyObject* obj)
1592 {
1593 unsigned char v;
1594 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
1595 /*
1596 this is needed to make valgrind/purify happier.
1597 */
1598 memset((void*)&v, 0, sizeof(unsigned char));
1599 }
1600 return v;
1601 }
1602
1603
1604 SWIGINTERNSHORT int
1605 SWIG_Check_unsigned_SS_char(PyObject* obj)
1606 {
1607 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
1608 }
1609
1610
1611 SWIGINTERNSHORT unsigned long
1612 SWIG_As_unsigned_SS_long(PyObject* obj)
1613 {
1614 unsigned long v;
1615 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1616 /*
1617 this is needed to make valgrind/purify happier.
1618 */
1619 memset((void*)&v, 0, sizeof(unsigned long));
1620 }
1621 return v;
1622 }
1623
1624
1625 SWIGINTERNSHORT int
1626 SWIG_Check_unsigned_SS_long(PyObject* obj)
1627 {
1628 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1629 }
1630
1631
1632 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1633 #define SWIG_From_unsigned_SS_char PyInt_FromLong
1634 /*@@*/
1635
1636
1637 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1638 #define SWIG_From_long PyInt_FromLong
1639 /*@@*/
1640
1641 static PyObject *wxColour_Get(wxColour *self){
1642 PyObject* rv = PyTuple_New(3);
1643 int red = -1;
1644 int green = -1;
1645 int blue = -1;
1646 if (self->Ok()) {
1647 red = self->Red();
1648 green = self->Green();
1649 blue = self->Blue();
1650 }
1651 PyTuple_SetItem(rv, 0, PyInt_FromLong(red));
1652 PyTuple_SetItem(rv, 1, PyInt_FromLong(green));
1653 PyTuple_SetItem(rv, 2, PyInt_FromLong(blue));
1654 return rv;
1655 }
1656 static unsigned long wxColour_GetRGB(wxColour *self){
1657 return self->Red() | (self->Green() << 8) | (self->Blue() << 16);
1658 }
1659
1660 SWIGINTERNSHORT PyObject*
1661 SWIG_From_unsigned_SS_long(unsigned long value)
1662 {
1663 return (value > LONG_MAX) ?
1664 PyLong_FromUnsignedLong(value)
1665 : PyInt_FromLong((long)(value));
1666 }
1667
1668
1669 SWIGINTERNSHORT int
1670 SWIG_As_int(PyObject* obj)
1671 {
1672 int v;
1673 if (!SWIG_AsVal_int(obj, &v)) {
1674 /*
1675 this is needed to make valgrind/purify happier.
1676 */
1677 memset((void*)&v, 0, sizeof(int));
1678 }
1679 return v;
1680 }
1681
1682
1683 SWIGINTERNSHORT int
1684 SWIG_Check_int(PyObject* obj)
1685 {
1686 return SWIG_AsVal_int(obj, (int*)0);
1687 }
1688
1689
1690 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1691 #define SWIG_From_int PyInt_FromLong
1692 /*@@*/
1693
1694
1695 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1696 PyObject* o2;
1697 PyObject* o3;
1698
1699 if (!target) {
1700 target = o;
1701 } else if (target == Py_None) {
1702 Py_DECREF(Py_None);
1703 target = o;
1704 } else {
1705 if (!PyTuple_Check(target)) {
1706 o2 = target;
1707 target = PyTuple_New(1);
1708 PyTuple_SetItem(target, 0, o2);
1709 }
1710 o3 = PyTuple_New(1);
1711 PyTuple_SetItem(o3, 0, o);
1712
1713 o2 = target;
1714 target = PySequence_Concat(o2, o3);
1715 Py_DECREF(o2);
1716 Py_DECREF(o3);
1717 }
1718 return target;
1719 }
1720
1721
1722 static PyObject *wxPen_GetDashes(wxPen *self){
1723 wxDash* dashes;
1724 int count = self->GetDashes(&dashes);
1725 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1726 PyObject* retval = PyList_New(0);
1727 for (int x=0; x<count; x++) {
1728 PyObject* pyint = PyInt_FromLong(dashes[x]);
1729 PyList_Append(retval, pyint);
1730 Py_DECREF(pyint);
1731 }
1732 wxPyEndBlockThreads(blocked);
1733 return retval;
1734 }
1735 static void wxPen__SetDashes(wxPen *self,PyObject *_self,PyObject *pyDashes){
1736 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1737 int size = PyList_Size(pyDashes);
1738 wxDash* dashes = (wxDash*)byte_LIST_helper(pyDashes);
1739
1740 // black magic warning! The array of wxDashes needs to exist as
1741 // long as the pen does because wxPen does not copy the array. So
1742 // stick a copy in a Python string object and attach it to _self,
1743 // and then call SetDashes with a pointer to that array. Then
1744 // when the Python pen object is destroyed the array will be
1745 // cleaned up too.
1746 PyObject* strDashes = PyString_FromStringAndSize((char*)dashes, size*sizeof(wxDash));
1747 PyObject_SetAttrString(_self, "_dashes", strDashes);
1748
1749 self->SetDashes(size, (wxDash*)PyString_AS_STRING(strDashes));
1750 delete [] dashes;
1751 Py_DECREF(strDashes);
1752 wxPyEndBlockThreads(blocked);
1753 }
1754 static bool wxPen___eq__(wxPen *self,wxPen const *other){ return other ? (*self == *other) : false; }
1755 static bool wxPen___ne__(wxPen *self,wxPen const *other){ return other ? (*self != *other) : true; }
1756
1757 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1758 #define SWIG_From_short PyInt_FromLong
1759 /*@@*/
1760
1761
1762 SWIGINTERN int
1763 SWIG_AsVal_short(PyObject *obj, short *val)
1764 {
1765 const char* errmsg = val ? "short" : (char*)0;
1766 long v;
1767 if (SWIG_AsVal_long(obj, &v)) {
1768 if (SWIG_CheckLongInRange(v, SHRT_MIN, SHRT_MAX, errmsg)) {
1769 if (val) *val = (short)(v);
1770 return 1;
1771 } else {
1772 return 0;
1773 }
1774 } else {
1775 PyErr_Clear();
1776 }
1777 if (val) {
1778 SWIG_type_error(errmsg, obj);
1779 }
1780 return 0;
1781 }
1782
1783
1784 SWIGINTERNSHORT short
1785 SWIG_As_short(PyObject* obj)
1786 {
1787 short v;
1788 if (!SWIG_AsVal_short(obj, &v)) {
1789 /*
1790 this is needed to make valgrind/purify happier.
1791 */
1792 memset((void*)&v, 0, sizeof(short));
1793 }
1794 return v;
1795 }
1796
1797
1798 SWIGINTERNSHORT int
1799 SWIG_Check_short(PyObject* obj)
1800 {
1801 return SWIG_AsVal_short(obj, (short*)0);
1802 }
1803
1804
1805 #include <wx/image.h>
1806
1807 static char** ConvertListOfStrings(PyObject* listOfStrings) {
1808 char** cArray = NULL;
1809 int count;
1810
1811 if (!PyList_Check(listOfStrings)) {
1812 PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
1813 return NULL;
1814 }
1815 count = PyList_Size(listOfStrings);
1816 cArray = new char*[count];
1817
1818 for(int x=0; x<count; x++) {
1819 // TODO: Need some validation and error checking here
1820 cArray[x] = PyString_AsString(PyList_GET_ITEM(listOfStrings, x));
1821 }
1822 return cArray;
1823 }
1824
1825
1826 static wxBitmap *new_wxBitmap(PyObject *listOfStrings){
1827 char** cArray = NULL;
1828 wxBitmap* bmp;
1829
1830 cArray = ConvertListOfStrings(listOfStrings);
1831 if (! cArray)
1832 return NULL;
1833 bmp = new wxBitmap(cArray);
1834 delete [] cArray;
1835 return bmp;
1836 }
1837 static wxBitmap *new_wxBitmap(PyObject *bits,int width,int height,int depth=1){
1838 char* buf;
1839 int length;
1840 PyString_AsStringAndSize(bits, &buf, &length);
1841 return new wxBitmap(buf, width, height, depth);
1842 }
1843 static wxSize wxBitmap_GetSize(wxBitmap *self){
1844 wxSize size(self->GetWidth(), self->GetHeight());
1845 return size;
1846 }
1847 static void wxBitmap_SetMaskColour(wxBitmap *self,wxColour const &colour){
1848 wxMask *mask = new wxMask(*self, colour);
1849 self->SetMask(mask);
1850 }
1851 static void wxBitmap_SetSize(wxBitmap *self,wxSize const &size){
1852 self->SetWidth(size.x);
1853 self->SetHeight(size.y);
1854 }
1855 static bool wxBitmap___eq__(wxBitmap *self,wxBitmap const *other){ return other ? (*self == *other) : false; }
1856 static bool wxBitmap___ne__(wxBitmap *self,wxBitmap const *other){ return other ? (*self != *other) : true; }
1857 static wxMask *new_wxMask(wxBitmap const &bitmap,wxColour const &colour=wxNullColour){
1858 if ( !colour.Ok() )
1859 return new wxMask(bitmap, *wxBLACK);
1860 else
1861 return new wxMask(bitmap, colour);
1862 }
1863
1864 #include <wx/iconbndl.h>
1865
1866 static wxIcon *new_wxIcon(wxBitmap const &bmp){
1867 wxIcon* icon = new wxIcon();
1868 icon->CopyFromBitmap(bmp);
1869 return icon;
1870 }
1871 static wxIcon *new_wxIcon(PyObject *listOfStrings){
1872 char** cArray = NULL;
1873 wxIcon* icon;
1874
1875 cArray = ConvertListOfStrings(listOfStrings);
1876 if (! cArray)
1877 return NULL;
1878 icon = new wxIcon(cArray);
1879 delete [] cArray;
1880 return icon;
1881 }
1882 static wxIconLocation *new_wxIconLocation(wxString const *filename=&wxPyEmptyString,int num=0){
1883
1884
1885
1886 return new wxIconLocation(*filename);
1887
1888 }
1889 static void wxIconLocation_SetIndex(wxIconLocation *self,int num){
1890
1891
1892
1893 // do nothing
1894
1895 }
1896 static int wxIconLocation_GetIndex(wxIconLocation *self){
1897
1898
1899
1900 return -1;
1901
1902 }
1903
1904 SWIGINTERNSHORT long
1905 SWIG_As_long(PyObject* obj)
1906 {
1907 long v;
1908 if (!SWIG_AsVal_long(obj, &v)) {
1909 /*
1910 this is needed to make valgrind/purify happier.
1911 */
1912 memset((void*)&v, 0, sizeof(long));
1913 }
1914 return v;
1915 }
1916
1917
1918 SWIGINTERNSHORT int
1919 SWIG_Check_long(PyObject* obj)
1920 {
1921 return SWIG_AsVal_long(obj, (long*)0);
1922 }
1923
1924 static wxCursor *new_wxCursor(wxString const &cursorName,long type,int hotSpotX=0,int hotSpotY=0){
1925 #ifdef __WXGTK__
1926 wxImage img(cursorName, type);
1927 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X, hotSpotX);
1928 img.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y, hotSpotY);
1929 return new wxCursor(img);
1930 #else
1931 return new wxCursor(cursorName, type, hotSpotX, hotSpotY);
1932 #endif
1933 }
1934
1935
1936 static void wxRegionIterator_Next(wxRegionIterator *self){
1937 (*self) ++;
1938 }
1939 static bool wxRegionIterator___nonzero__(wxRegionIterator *self){
1940 return self->operator bool();
1941 }
1942
1943 #include <wx/fontutil.h>
1944 #include <wx/fontmap.h>
1945 #include <wx/fontenum.h>
1946
1947 static wxString wxNativeFontInfo___str__(wxNativeFontInfo *self){
1948 return self->ToString();
1949 }
1950
1951 wxNativeEncodingInfo* wxGetNativeFontEncoding(wxFontEncoding encoding) {
1952 static wxNativeEncodingInfo info;
1953 if ( wxGetNativeFontEncoding(encoding, &info) )
1954 return &info;
1955 else
1956 return NULL;
1957 }
1958
1959 static PyObject *wxFontMapper_GetAltForEncoding(wxFontMapper *self,wxFontEncoding encoding,wxString const &facename=wxPyEmptyString,bool interactive=true){
1960 wxFontEncoding alt_enc;
1961 if (self->GetAltForEncoding(encoding, &alt_enc, facename, interactive))
1962 return PyInt_FromLong(alt_enc);
1963 else {
1964 Py_INCREF(Py_None);
1965 return Py_None;
1966 }
1967 }
1968 static wxFont *new_wxFont(wxString const &info){
1969 wxNativeFontInfo nfi;
1970 nfi.FromString(info);
1971 return new wxFont(nfi);
1972 }
1973 static wxFont *new_wxFont(int pointSize,wxFontFamily family,int flags=wxFONTFLAG_DEFAULT,wxString const &face=wxPyEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1974 return wxFont::New(pointSize, family, flags, face, encoding);
1975 }
1976 static wxFont *new_wxFont(wxSize const &pixelSize,int family,int style,int weight,bool underlined=false,wxString const &face=wxEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1977 return wxFontBase::New(pixelSize, family,
1978 style, weight, underlined,
1979 face, encoding);
1980 }
1981 static bool wxFont___eq__(wxFont *self,wxFont const *other){ return other ? (*self == *other) : false; }
1982 static bool wxFont___ne__(wxFont *self,wxFont const *other){ return other ? (*self != *other) : true; }
1983
1984 class wxPyFontEnumerator : public wxFontEnumerator {
1985 public:
1986 wxPyFontEnumerator() {}
1987 ~wxPyFontEnumerator() {}
1988
1989 DEC_PYCALLBACK_BOOL_STRING(OnFacename);
1990 DEC_PYCALLBACK_BOOL_STRINGSTRING(OnFontEncoding);
1991
1992 PYPRIVATE;
1993 };
1994
1995 IMP_PYCALLBACK_BOOL_STRING(wxPyFontEnumerator, wxFontEnumerator, OnFacename);
1996 IMP_PYCALLBACK_BOOL_STRINGSTRING(wxPyFontEnumerator, wxFontEnumerator, OnFontEncoding);
1997
1998
1999 static PyObject *wxPyFontEnumerator_GetEncodings(wxPyFontEnumerator *self){
2000 wxArrayString* arr = self->GetEncodings();
2001 if (arr)
2002 return wxArrayString2PyList_helper(*arr);
2003 else
2004 return PyList_New(0);
2005 }
2006 static PyObject *wxPyFontEnumerator_GetFacenames(wxPyFontEnumerator *self){
2007 wxArrayString* arr = self->GetFacenames();
2008 if (arr)
2009 return wxArrayString2PyList_helper(*arr);
2010 else
2011 return PyList_New(0);
2012 }
2013
2014 #include <locale.h>
2015
2016 static wxLocale *new_wxLocale(int language=-1,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
2017 wxLocale* loc;
2018 if (language == -1)
2019 loc = new wxLocale();
2020 else
2021 loc = new wxLocale(language, flags);
2022 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
2023 // for the floating point conversions and such to work right.
2024 #if PY_VERSION_HEX < 0x02040000
2025 setlocale(LC_NUMERIC, "C");
2026 #endif
2027 return loc;
2028 }
2029 static bool wxLocale_Init1(wxLocale *self,wxString const &szName,wxString const &szShort=wxPyEmptyString,wxString const &szLocale=wxPyEmptyString,bool bLoadDefault=true,bool bConvertEncoding=false){
2030 bool rc = self->Init(szName, szShort, szLocale, bLoadDefault, bConvertEncoding);
2031 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
2032 // for the floating point conversions and such to work right.
2033 #if PY_VERSION_HEX < 0x02040000
2034 setlocale(LC_NUMERIC, "C");
2035 #endif
2036 return rc;
2037 }
2038 static bool wxLocale_Init2(wxLocale *self,int language=wxLANGUAGE_DEFAULT,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
2039 bool rc = self->Init(language, flags);
2040 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
2041 // for the floating point conversions and such to work right.
2042 #if PY_VERSION_HEX < 0x02040000
2043 setlocale(LC_NUMERIC, "C");
2044 #endif
2045 return rc;
2046 }
2047
2048 #include "wx/wxPython/pydrawxxx.h"
2049
2050 static wxColour wxDC_GetPixel(wxDC *self,int x,int y){
2051 wxColour col;
2052 self->GetPixel(x, y, &col);
2053 return col;
2054 }
2055 static wxColour wxDC_GetPixelPoint(wxDC *self,wxPoint const &pt){
2056 wxColour col;
2057 self->GetPixel(pt, &col);
2058 return col;
2059 }
2060
2061 SWIGINTERN int
2062 SWIG_AsVal_double(PyObject *obj, double* val)
2063 {
2064 if (PyNumber_Check(obj)) {
2065 if (val) *val = PyFloat_AsDouble(obj);
2066 return 1;
2067 }
2068 else {
2069 SWIG_type_error("number", obj);
2070 }
2071 return 0;
2072 }
2073
2074
2075 SWIGINTERNSHORT double
2076 SWIG_As_double(PyObject* obj)
2077 {
2078 double v;
2079 if (!SWIG_AsVal_double(obj, &v)) {
2080 /*
2081 this is needed to make valgrind/purify happier.
2082 */
2083 memset((void*)&v, 0, sizeof(double));
2084 }
2085 return v;
2086 }
2087
2088
2089 SWIGINTERNSHORT int
2090 SWIG_Check_double(PyObject* obj)
2091 {
2092 return SWIG_AsVal_double(obj, (double*)0);
2093 }
2094
2095 static wxRect wxDC_DrawImageLabel(wxDC *self,wxString const &text,wxBitmap const &image,wxRect const &rect,int alignment=wxALIGN_LEFT|wxALIGN_TOP,int indexAccel=-1){
2096 wxRect rv;
2097 self->DrawLabel(text, image, rect, alignment, indexAccel, &rv);
2098 return rv;
2099 }
2100
2101 static wxRect wxDC_GetClippingRect(wxDC *self){
2102 wxRect rect;
2103 self->GetClippingBox(rect);
2104 return rect;
2105 }
2106 static wxArrayInt wxDC_GetPartialTextExtents(wxDC *self,wxString const &text){
2107 wxArrayInt widths;
2108 self->GetPartialTextExtents(text, widths);
2109 return widths;
2110 }
2111
2112 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2113 #define SWIG_From_double PyFloat_FromDouble
2114 /*@@*/
2115
2116
2117 static void wxDC_SetLogicalOriginPoint(wxDC *self,wxPoint const &point){
2118 self->SetLogicalOrigin(point.x, point.y);
2119 }
2120 static void wxDC_SetDeviceOriginPoint(wxDC *self,wxPoint const &point){
2121 self->SetDeviceOrigin(point.x, point.y);
2122 }
2123 static void wxDC_CalcBoundingBoxPoint(wxDC *self,wxPoint const &point){
2124 self->CalcBoundingBox(point.x, point.y);
2125 }
2126 static PyObject *wxDC__DrawPointList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2127 return wxPyDrawXXXList(*self, wxPyDrawXXXPoint, pyCoords, pyPens, pyBrushes);
2128 }
2129 static PyObject *wxDC__DrawLineList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2130 return wxPyDrawXXXList(*self, wxPyDrawXXXLine, pyCoords, pyPens, pyBrushes);
2131 }
2132 static PyObject *wxDC__DrawRectangleList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2133 return wxPyDrawXXXList(*self, wxPyDrawXXXRectangle, pyCoords, pyPens, pyBrushes);
2134 }
2135 static PyObject *wxDC__DrawEllipseList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2136 return wxPyDrawXXXList(*self, wxPyDrawXXXEllipse, pyCoords, pyPens, pyBrushes);
2137 }
2138 static PyObject *wxDC__DrawPolygonList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2139 return wxPyDrawXXXList(*self, wxPyDrawXXXPolygon, pyCoords, pyPens, pyBrushes);
2140 }
2141 static PyObject *wxDC__DrawTextList(wxDC *self,PyObject *textList,PyObject *pyPoints,PyObject *foregroundList,PyObject *backgroundList){
2142 return wxPyDrawTextList(*self, textList, pyPoints, foregroundList, backgroundList);
2143 }
2144
2145 static void wxDC_GetBoundingBox(wxDC* dc, int* x1, int* y1, int* x2, int* y2) {
2146 *x1 = dc->MinX();
2147 *y1 = dc->MinY();
2148 *x2 = dc->MaxX();
2149 *y2 = dc->MaxY();
2150 }
2151
2152
2153 #include <wx/dcbuffer.h>
2154
2155
2156 #include <wx/dcps.h>
2157
2158
2159 #include <wx/metafile.h>
2160
2161
2162
2163 static void wxColourDatabase_Append(wxColourDatabase *self,wxString const &name,int red,int green,int blue){
2164 self->AddColour(name, wxColour(red, green, blue));
2165 }
2166
2167 #include <wx/effects.h>
2168
2169 #ifdef __cplusplus
2170 extern "C" {
2171 #endif
2172 static PyObject *_wrap_new_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2173 PyObject *resultobj;
2174 wxGDIObject *result;
2175 char *kwnames[] = {
2176 NULL
2177 };
2178
2179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GDIObject",kwnames)) goto fail;
2180 {
2181 if (!wxPyCheckForApp()) SWIG_fail;
2182 PyThreadState* __tstate = wxPyBeginAllowThreads();
2183 result = (wxGDIObject *)new wxGDIObject();
2184
2185 wxPyEndAllowThreads(__tstate);
2186 if (PyErr_Occurred()) SWIG_fail;
2187 }
2188 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGDIObject, 1);
2189 return resultobj;
2190 fail:
2191 return NULL;
2192 }
2193
2194
2195 static PyObject *_wrap_delete_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2196 PyObject *resultobj;
2197 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2198 PyObject * obj0 = 0 ;
2199 char *kwnames[] = {
2200 (char *) "self", NULL
2201 };
2202
2203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GDIObject",kwnames,&obj0)) goto fail;
2204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2205 if (SWIG_arg_fail(1)) SWIG_fail;
2206 {
2207 PyThreadState* __tstate = wxPyBeginAllowThreads();
2208 delete arg1;
2209
2210 wxPyEndAllowThreads(__tstate);
2211 if (PyErr_Occurred()) SWIG_fail;
2212 }
2213 Py_INCREF(Py_None); resultobj = Py_None;
2214 return resultobj;
2215 fail:
2216 return NULL;
2217 }
2218
2219
2220 static PyObject *_wrap_GDIObject_GetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2221 PyObject *resultobj;
2222 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2223 bool result;
2224 PyObject * obj0 = 0 ;
2225 char *kwnames[] = {
2226 (char *) "self", NULL
2227 };
2228
2229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_GetVisible",kwnames,&obj0)) goto fail;
2230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2231 if (SWIG_arg_fail(1)) SWIG_fail;
2232 {
2233 PyThreadState* __tstate = wxPyBeginAllowThreads();
2234 result = (bool)(arg1)->GetVisible();
2235
2236 wxPyEndAllowThreads(__tstate);
2237 if (PyErr_Occurred()) SWIG_fail;
2238 }
2239 {
2240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2241 }
2242 return resultobj;
2243 fail:
2244 return NULL;
2245 }
2246
2247
2248 static PyObject *_wrap_GDIObject_SetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2249 PyObject *resultobj;
2250 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2251 bool arg2 ;
2252 PyObject * obj0 = 0 ;
2253 PyObject * obj1 = 0 ;
2254 char *kwnames[] = {
2255 (char *) "self",(char *) "visible", NULL
2256 };
2257
2258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GDIObject_SetVisible",kwnames,&obj0,&obj1)) 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 arg2 = (bool)(SWIG_As_bool(obj1));
2263 if (SWIG_arg_fail(2)) SWIG_fail;
2264 }
2265 {
2266 PyThreadState* __tstate = wxPyBeginAllowThreads();
2267 (arg1)->SetVisible(arg2);
2268
2269 wxPyEndAllowThreads(__tstate);
2270 if (PyErr_Occurred()) SWIG_fail;
2271 }
2272 Py_INCREF(Py_None); resultobj = Py_None;
2273 return resultobj;
2274 fail:
2275 return NULL;
2276 }
2277
2278
2279 static PyObject *_wrap_GDIObject_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
2280 PyObject *resultobj;
2281 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2282 bool result;
2283 PyObject * obj0 = 0 ;
2284 char *kwnames[] = {
2285 (char *) "self", NULL
2286 };
2287
2288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_IsNull",kwnames,&obj0)) goto fail;
2289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2290 if (SWIG_arg_fail(1)) SWIG_fail;
2291 {
2292 PyThreadState* __tstate = wxPyBeginAllowThreads();
2293 result = (bool)(arg1)->IsNull();
2294
2295 wxPyEndAllowThreads(__tstate);
2296 if (PyErr_Occurred()) SWIG_fail;
2297 }
2298 {
2299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2300 }
2301 return resultobj;
2302 fail:
2303 return NULL;
2304 }
2305
2306
2307 static PyObject * GDIObject_swigregister(PyObject *, PyObject *args) {
2308 PyObject *obj;
2309 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2310 SWIG_TypeClientData(SWIGTYPE_p_wxGDIObject, obj);
2311 Py_INCREF(obj);
2312 return Py_BuildValue((char *)"");
2313 }
2314 static PyObject *_wrap_new_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2315 PyObject *resultobj;
2316 byte arg1 = (byte) 0 ;
2317 byte arg2 = (byte) 0 ;
2318 byte arg3 = (byte) 0 ;
2319 wxColour *result;
2320 PyObject * obj0 = 0 ;
2321 PyObject * obj1 = 0 ;
2322 PyObject * obj2 = 0 ;
2323 char *kwnames[] = {
2324 (char *) "red",(char *) "green",(char *) "blue", NULL
2325 };
2326
2327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Colour",kwnames,&obj0,&obj1,&obj2)) goto fail;
2328 if (obj0) {
2329 {
2330 arg1 = (byte)(SWIG_As_unsigned_SS_char(obj0));
2331 if (SWIG_arg_fail(1)) SWIG_fail;
2332 }
2333 }
2334 if (obj1) {
2335 {
2336 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2337 if (SWIG_arg_fail(2)) SWIG_fail;
2338 }
2339 }
2340 if (obj2) {
2341 {
2342 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2343 if (SWIG_arg_fail(3)) SWIG_fail;
2344 }
2345 }
2346 {
2347 PyThreadState* __tstate = wxPyBeginAllowThreads();
2348 result = (wxColour *)new wxColour(arg1,arg2,arg3);
2349
2350 wxPyEndAllowThreads(__tstate);
2351 if (PyErr_Occurred()) SWIG_fail;
2352 }
2353 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2354 return resultobj;
2355 fail:
2356 return NULL;
2357 }
2358
2359
2360 static PyObject *_wrap_new_NamedColour(PyObject *, PyObject *args, PyObject *kwargs) {
2361 PyObject *resultobj;
2362 wxString *arg1 = 0 ;
2363 wxColour *result;
2364 bool temp1 = false ;
2365 PyObject * obj0 = 0 ;
2366 char *kwnames[] = {
2367 (char *) "colorName", NULL
2368 };
2369
2370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_NamedColour",kwnames,&obj0)) goto fail;
2371 {
2372 arg1 = wxString_in_helper(obj0);
2373 if (arg1 == NULL) SWIG_fail;
2374 temp1 = true;
2375 }
2376 {
2377 if (!wxPyCheckForApp()) SWIG_fail;
2378 PyThreadState* __tstate = wxPyBeginAllowThreads();
2379 result = (wxColour *)new wxColour((wxString const &)*arg1);
2380
2381 wxPyEndAllowThreads(__tstate);
2382 if (PyErr_Occurred()) SWIG_fail;
2383 }
2384 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2385 {
2386 if (temp1)
2387 delete arg1;
2388 }
2389 return resultobj;
2390 fail:
2391 {
2392 if (temp1)
2393 delete arg1;
2394 }
2395 return NULL;
2396 }
2397
2398
2399 static PyObject *_wrap_new_ColourRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2400 PyObject *resultobj;
2401 unsigned long arg1 ;
2402 wxColour *result;
2403 PyObject * obj0 = 0 ;
2404 char *kwnames[] = {
2405 (char *) "colRGB", NULL
2406 };
2407
2408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ColourRGB",kwnames,&obj0)) goto fail;
2409 {
2410 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
2411 if (SWIG_arg_fail(1)) SWIG_fail;
2412 }
2413 {
2414 PyThreadState* __tstate = wxPyBeginAllowThreads();
2415 result = (wxColour *)new wxColour(arg1);
2416
2417 wxPyEndAllowThreads(__tstate);
2418 if (PyErr_Occurred()) SWIG_fail;
2419 }
2420 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2421 return resultobj;
2422 fail:
2423 return NULL;
2424 }
2425
2426
2427 static PyObject *_wrap_delete_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2428 PyObject *resultobj;
2429 wxColour *arg1 = (wxColour *) 0 ;
2430 PyObject * obj0 = 0 ;
2431 char *kwnames[] = {
2432 (char *) "self", NULL
2433 };
2434
2435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Colour",kwnames,&obj0)) goto fail;
2436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2437 if (SWIG_arg_fail(1)) SWIG_fail;
2438 {
2439 PyThreadState* __tstate = wxPyBeginAllowThreads();
2440 delete arg1;
2441
2442 wxPyEndAllowThreads(__tstate);
2443 if (PyErr_Occurred()) SWIG_fail;
2444 }
2445 Py_INCREF(Py_None); resultobj = Py_None;
2446 return resultobj;
2447 fail:
2448 return NULL;
2449 }
2450
2451
2452 static PyObject *_wrap_Colour_Red(PyObject *, PyObject *args, PyObject *kwargs) {
2453 PyObject *resultobj;
2454 wxColour *arg1 = (wxColour *) 0 ;
2455 byte result;
2456 PyObject * obj0 = 0 ;
2457 char *kwnames[] = {
2458 (char *) "self", NULL
2459 };
2460
2461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Red",kwnames,&obj0)) goto fail;
2462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2463 if (SWIG_arg_fail(1)) SWIG_fail;
2464 {
2465 PyThreadState* __tstate = wxPyBeginAllowThreads();
2466 result = (byte)(arg1)->Red();
2467
2468 wxPyEndAllowThreads(__tstate);
2469 if (PyErr_Occurred()) SWIG_fail;
2470 }
2471 {
2472 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2473 }
2474 return resultobj;
2475 fail:
2476 return NULL;
2477 }
2478
2479
2480 static PyObject *_wrap_Colour_Green(PyObject *, PyObject *args, PyObject *kwargs) {
2481 PyObject *resultobj;
2482 wxColour *arg1 = (wxColour *) 0 ;
2483 byte result;
2484 PyObject * obj0 = 0 ;
2485 char *kwnames[] = {
2486 (char *) "self", NULL
2487 };
2488
2489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Green",kwnames,&obj0)) goto fail;
2490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2491 if (SWIG_arg_fail(1)) SWIG_fail;
2492 {
2493 PyThreadState* __tstate = wxPyBeginAllowThreads();
2494 result = (byte)(arg1)->Green();
2495
2496 wxPyEndAllowThreads(__tstate);
2497 if (PyErr_Occurred()) SWIG_fail;
2498 }
2499 {
2500 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2501 }
2502 return resultobj;
2503 fail:
2504 return NULL;
2505 }
2506
2507
2508 static PyObject *_wrap_Colour_Blue(PyObject *, PyObject *args, PyObject *kwargs) {
2509 PyObject *resultobj;
2510 wxColour *arg1 = (wxColour *) 0 ;
2511 byte result;
2512 PyObject * obj0 = 0 ;
2513 char *kwnames[] = {
2514 (char *) "self", NULL
2515 };
2516
2517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Blue",kwnames,&obj0)) goto fail;
2518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2519 if (SWIG_arg_fail(1)) SWIG_fail;
2520 {
2521 PyThreadState* __tstate = wxPyBeginAllowThreads();
2522 result = (byte)(arg1)->Blue();
2523
2524 wxPyEndAllowThreads(__tstate);
2525 if (PyErr_Occurred()) SWIG_fail;
2526 }
2527 {
2528 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2529 }
2530 return resultobj;
2531 fail:
2532 return NULL;
2533 }
2534
2535
2536 static PyObject *_wrap_Colour_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
2537 PyObject *resultobj;
2538 wxColour *arg1 = (wxColour *) 0 ;
2539 bool result;
2540 PyObject * obj0 = 0 ;
2541 char *kwnames[] = {
2542 (char *) "self", NULL
2543 };
2544
2545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Ok",kwnames,&obj0)) goto fail;
2546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2547 if (SWIG_arg_fail(1)) SWIG_fail;
2548 {
2549 PyThreadState* __tstate = wxPyBeginAllowThreads();
2550 result = (bool)(arg1)->Ok();
2551
2552 wxPyEndAllowThreads(__tstate);
2553 if (PyErr_Occurred()) SWIG_fail;
2554 }
2555 {
2556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2557 }
2558 return resultobj;
2559 fail:
2560 return NULL;
2561 }
2562
2563
2564 static PyObject *_wrap_Colour_Set(PyObject *, PyObject *args, PyObject *kwargs) {
2565 PyObject *resultobj;
2566 wxColour *arg1 = (wxColour *) 0 ;
2567 byte arg2 ;
2568 byte arg3 ;
2569 byte arg4 ;
2570 PyObject * obj0 = 0 ;
2571 PyObject * obj1 = 0 ;
2572 PyObject * obj2 = 0 ;
2573 PyObject * obj3 = 0 ;
2574 char *kwnames[] = {
2575 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2576 };
2577
2578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Colour_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2580 if (SWIG_arg_fail(1)) SWIG_fail;
2581 {
2582 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2583 if (SWIG_arg_fail(2)) SWIG_fail;
2584 }
2585 {
2586 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2587 if (SWIG_arg_fail(3)) SWIG_fail;
2588 }
2589 {
2590 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2591 if (SWIG_arg_fail(4)) SWIG_fail;
2592 }
2593 {
2594 PyThreadState* __tstate = wxPyBeginAllowThreads();
2595 (arg1)->Set(arg2,arg3,arg4);
2596
2597 wxPyEndAllowThreads(__tstate);
2598 if (PyErr_Occurred()) SWIG_fail;
2599 }
2600 Py_INCREF(Py_None); resultobj = Py_None;
2601 return resultobj;
2602 fail:
2603 return NULL;
2604 }
2605
2606
2607 static PyObject *_wrap_Colour_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2608 PyObject *resultobj;
2609 wxColour *arg1 = (wxColour *) 0 ;
2610 unsigned long arg2 ;
2611 PyObject * obj0 = 0 ;
2612 PyObject * obj1 = 0 ;
2613 char *kwnames[] = {
2614 (char *) "self",(char *) "colRGB", NULL
2615 };
2616
2617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetRGB",kwnames,&obj0,&obj1)) goto fail;
2618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2619 if (SWIG_arg_fail(1)) SWIG_fail;
2620 {
2621 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
2622 if (SWIG_arg_fail(2)) SWIG_fail;
2623 }
2624 {
2625 PyThreadState* __tstate = wxPyBeginAllowThreads();
2626 (arg1)->Set(arg2);
2627
2628 wxPyEndAllowThreads(__tstate);
2629 if (PyErr_Occurred()) SWIG_fail;
2630 }
2631 Py_INCREF(Py_None); resultobj = Py_None;
2632 return resultobj;
2633 fail:
2634 return NULL;
2635 }
2636
2637
2638 static PyObject *_wrap_Colour_SetFromName(PyObject *, PyObject *args, PyObject *kwargs) {
2639 PyObject *resultobj;
2640 wxColour *arg1 = (wxColour *) 0 ;
2641 wxString *arg2 = 0 ;
2642 bool temp2 = false ;
2643 PyObject * obj0 = 0 ;
2644 PyObject * obj1 = 0 ;
2645 char *kwnames[] = {
2646 (char *) "self",(char *) "colourName", NULL
2647 };
2648
2649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetFromName",kwnames,&obj0,&obj1)) goto fail;
2650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2651 if (SWIG_arg_fail(1)) SWIG_fail;
2652 {
2653 arg2 = wxString_in_helper(obj1);
2654 if (arg2 == NULL) SWIG_fail;
2655 temp2 = true;
2656 }
2657 {
2658 PyThreadState* __tstate = wxPyBeginAllowThreads();
2659 (arg1)->InitFromName((wxString const &)*arg2);
2660
2661 wxPyEndAllowThreads(__tstate);
2662 if (PyErr_Occurred()) SWIG_fail;
2663 }
2664 Py_INCREF(Py_None); resultobj = Py_None;
2665 {
2666 if (temp2)
2667 delete arg2;
2668 }
2669 return resultobj;
2670 fail:
2671 {
2672 if (temp2)
2673 delete arg2;
2674 }
2675 return NULL;
2676 }
2677
2678
2679 static PyObject *_wrap_Colour_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2680 PyObject *resultobj;
2681 wxColour *arg1 = (wxColour *) 0 ;
2682 long result;
2683 PyObject * obj0 = 0 ;
2684 char *kwnames[] = {
2685 (char *) "self", NULL
2686 };
2687
2688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetPixel",kwnames,&obj0)) goto fail;
2689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2690 if (SWIG_arg_fail(1)) SWIG_fail;
2691 {
2692 PyThreadState* __tstate = wxPyBeginAllowThreads();
2693 result = (long)((wxColour const *)arg1)->GetPixel();
2694
2695 wxPyEndAllowThreads(__tstate);
2696 if (PyErr_Occurred()) SWIG_fail;
2697 }
2698 {
2699 resultobj = SWIG_From_long((long)(result));
2700 }
2701 return resultobj;
2702 fail:
2703 return NULL;
2704 }
2705
2706
2707 static PyObject *_wrap_Colour___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
2708 PyObject *resultobj;
2709 wxColour *arg1 = (wxColour *) 0 ;
2710 wxColour *arg2 = 0 ;
2711 bool result;
2712 wxColour temp2 ;
2713 PyObject * obj0 = 0 ;
2714 PyObject * obj1 = 0 ;
2715 char *kwnames[] = {
2716 (char *) "self",(char *) "colour", NULL
2717 };
2718
2719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___eq__",kwnames,&obj0,&obj1)) goto fail;
2720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2721 if (SWIG_arg_fail(1)) SWIG_fail;
2722 {
2723 arg2 = &temp2;
2724 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2725 }
2726 {
2727 PyThreadState* __tstate = wxPyBeginAllowThreads();
2728 result = (bool)((wxColour const *)arg1)->operator ==((wxColour const &)*arg2);
2729
2730 wxPyEndAllowThreads(__tstate);
2731 if (PyErr_Occurred()) SWIG_fail;
2732 }
2733 {
2734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2735 }
2736 return resultobj;
2737 fail:
2738 return NULL;
2739 }
2740
2741
2742 static PyObject *_wrap_Colour___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
2743 PyObject *resultobj;
2744 wxColour *arg1 = (wxColour *) 0 ;
2745 wxColour *arg2 = 0 ;
2746 bool result;
2747 wxColour temp2 ;
2748 PyObject * obj0 = 0 ;
2749 PyObject * obj1 = 0 ;
2750 char *kwnames[] = {
2751 (char *) "self",(char *) "colour", NULL
2752 };
2753
2754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___ne__",kwnames,&obj0,&obj1)) goto fail;
2755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2756 if (SWIG_arg_fail(1)) SWIG_fail;
2757 {
2758 arg2 = &temp2;
2759 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2760 }
2761 {
2762 PyThreadState* __tstate = wxPyBeginAllowThreads();
2763 result = (bool)((wxColour const *)arg1)->operator !=((wxColour const &)*arg2);
2764
2765 wxPyEndAllowThreads(__tstate);
2766 if (PyErr_Occurred()) SWIG_fail;
2767 }
2768 {
2769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2770 }
2771 return resultobj;
2772 fail:
2773 return NULL;
2774 }
2775
2776
2777 static PyObject *_wrap_Colour_Get(PyObject *, PyObject *args, PyObject *kwargs) {
2778 PyObject *resultobj;
2779 wxColour *arg1 = (wxColour *) 0 ;
2780 PyObject *result;
2781 PyObject * obj0 = 0 ;
2782 char *kwnames[] = {
2783 (char *) "self", NULL
2784 };
2785
2786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Get",kwnames,&obj0)) goto fail;
2787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2788 if (SWIG_arg_fail(1)) SWIG_fail;
2789 {
2790 PyThreadState* __tstate = wxPyBeginAllowThreads();
2791 result = (PyObject *)wxColour_Get(arg1);
2792
2793 wxPyEndAllowThreads(__tstate);
2794 if (PyErr_Occurred()) SWIG_fail;
2795 }
2796 resultobj = result;
2797 return resultobj;
2798 fail:
2799 return NULL;
2800 }
2801
2802
2803 static PyObject *_wrap_Colour_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2804 PyObject *resultobj;
2805 wxColour *arg1 = (wxColour *) 0 ;
2806 unsigned long result;
2807 PyObject * obj0 = 0 ;
2808 char *kwnames[] = {
2809 (char *) "self", NULL
2810 };
2811
2812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetRGB",kwnames,&obj0)) goto fail;
2813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2814 if (SWIG_arg_fail(1)) SWIG_fail;
2815 {
2816 PyThreadState* __tstate = wxPyBeginAllowThreads();
2817 result = (unsigned long)wxColour_GetRGB(arg1);
2818
2819 wxPyEndAllowThreads(__tstate);
2820 if (PyErr_Occurred()) SWIG_fail;
2821 }
2822 {
2823 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
2824 }
2825 return resultobj;
2826 fail:
2827 return NULL;
2828 }
2829
2830
2831 static PyObject * Colour_swigregister(PyObject *, PyObject *args) {
2832 PyObject *obj;
2833 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2834 SWIG_TypeClientData(SWIGTYPE_p_wxColour, obj);
2835 Py_INCREF(obj);
2836 return Py_BuildValue((char *)"");
2837 }
2838 static PyObject *_wrap_new_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2839 PyObject *resultobj;
2840 int arg1 ;
2841 unsigned char *arg2 = (unsigned char *) 0 ;
2842 unsigned char *arg3 = (unsigned char *) 0 ;
2843 unsigned char *arg4 = (unsigned char *) 0 ;
2844 wxPalette *result;
2845 PyObject * obj0 = 0 ;
2846 PyObject * obj1 = 0 ;
2847 PyObject * obj2 = 0 ;
2848 PyObject * obj3 = 0 ;
2849 char *kwnames[] = {
2850 (char *) "n",(char *) "red",(char *) "green",(char *) "blue", NULL
2851 };
2852
2853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_Palette",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2854 {
2855 arg1 = (int)(SWIG_As_int(obj0));
2856 if (SWIG_arg_fail(1)) SWIG_fail;
2857 }
2858 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2859 if (SWIG_arg_fail(2)) SWIG_fail;
2860 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2861 if (SWIG_arg_fail(3)) SWIG_fail;
2862 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2863 if (SWIG_arg_fail(4)) SWIG_fail;
2864 {
2865 if (!wxPyCheckForApp()) SWIG_fail;
2866 PyThreadState* __tstate = wxPyBeginAllowThreads();
2867 result = (wxPalette *)new wxPalette(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
2868
2869 wxPyEndAllowThreads(__tstate);
2870 if (PyErr_Occurred()) SWIG_fail;
2871 }
2872 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 1);
2873 return resultobj;
2874 fail:
2875 return NULL;
2876 }
2877
2878
2879 static PyObject *_wrap_delete_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2880 PyObject *resultobj;
2881 wxPalette *arg1 = (wxPalette *) 0 ;
2882 PyObject * obj0 = 0 ;
2883 char *kwnames[] = {
2884 (char *) "self", NULL
2885 };
2886
2887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Palette",kwnames,&obj0)) goto fail;
2888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2889 if (SWIG_arg_fail(1)) SWIG_fail;
2890 {
2891 PyThreadState* __tstate = wxPyBeginAllowThreads();
2892 delete arg1;
2893
2894 wxPyEndAllowThreads(__tstate);
2895 if (PyErr_Occurred()) SWIG_fail;
2896 }
2897 Py_INCREF(Py_None); resultobj = Py_None;
2898 return resultobj;
2899 fail:
2900 return NULL;
2901 }
2902
2903
2904 static PyObject *_wrap_Palette_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2905 PyObject *resultobj;
2906 wxPalette *arg1 = (wxPalette *) 0 ;
2907 byte arg2 ;
2908 byte arg3 ;
2909 byte arg4 ;
2910 int result;
2911 PyObject * obj0 = 0 ;
2912 PyObject * obj1 = 0 ;
2913 PyObject * obj2 = 0 ;
2914 PyObject * obj3 = 0 ;
2915 char *kwnames[] = {
2916 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2917 };
2918
2919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Palette_GetPixel",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2921 if (SWIG_arg_fail(1)) SWIG_fail;
2922 {
2923 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2924 if (SWIG_arg_fail(2)) SWIG_fail;
2925 }
2926 {
2927 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2928 if (SWIG_arg_fail(3)) SWIG_fail;
2929 }
2930 {
2931 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2932 if (SWIG_arg_fail(4)) SWIG_fail;
2933 }
2934 {
2935 PyThreadState* __tstate = wxPyBeginAllowThreads();
2936 result = (int)(arg1)->GetPixel(arg2,arg3,arg4);
2937
2938 wxPyEndAllowThreads(__tstate);
2939 if (PyErr_Occurred()) SWIG_fail;
2940 }
2941 {
2942 resultobj = SWIG_From_int((int)(result));
2943 }
2944 return resultobj;
2945 fail:
2946 return NULL;
2947 }
2948
2949
2950 static PyObject *_wrap_Palette_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2951 PyObject *resultobj;
2952 wxPalette *arg1 = (wxPalette *) 0 ;
2953 int arg2 ;
2954 byte *arg3 = (byte *) 0 ;
2955 byte *arg4 = (byte *) 0 ;
2956 byte *arg5 = (byte *) 0 ;
2957 bool result;
2958 byte temp3 ;
2959 int res3 = 0 ;
2960 byte temp4 ;
2961 int res4 = 0 ;
2962 byte temp5 ;
2963 int res5 = 0 ;
2964 PyObject * obj0 = 0 ;
2965 PyObject * obj1 = 0 ;
2966 char *kwnames[] = {
2967 (char *) "self",(char *) "pixel", NULL
2968 };
2969
2970 arg3 = &temp3; res3 = SWIG_NEWOBJ;
2971 arg4 = &temp4; res4 = SWIG_NEWOBJ;
2972 arg5 = &temp5; res5 = SWIG_NEWOBJ;
2973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Palette_GetRGB",kwnames,&obj0,&obj1)) goto fail;
2974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2975 if (SWIG_arg_fail(1)) SWIG_fail;
2976 {
2977 arg2 = (int)(SWIG_As_int(obj1));
2978 if (SWIG_arg_fail(2)) SWIG_fail;
2979 }
2980 {
2981 PyThreadState* __tstate = wxPyBeginAllowThreads();
2982 result = (bool)(arg1)->GetRGB(arg2,arg3,arg4,arg5);
2983
2984 wxPyEndAllowThreads(__tstate);
2985 if (PyErr_Occurred()) SWIG_fail;
2986 }
2987 {
2988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2989 }
2990 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
2991 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
2992 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
2993 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
2994 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
2995 SWIG_From_unsigned_SS_char((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_unsigned_char, 0)));
2996 return resultobj;
2997 fail:
2998 return NULL;
2999 }
3000
3001
3002 static PyObject *_wrap_Palette_GetColoursCount(PyObject *, PyObject *args, PyObject *kwargs) {
3003 PyObject *resultobj;
3004 wxPalette *arg1 = (wxPalette *) 0 ;
3005 int result;
3006 PyObject * obj0 = 0 ;
3007 char *kwnames[] = {
3008 (char *) "self", NULL
3009 };
3010
3011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_GetColoursCount",kwnames,&obj0)) goto fail;
3012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
3013 if (SWIG_arg_fail(1)) SWIG_fail;
3014 {
3015 PyThreadState* __tstate = wxPyBeginAllowThreads();
3016 result = (int)((wxPalette const *)arg1)->GetColoursCount();
3017
3018 wxPyEndAllowThreads(__tstate);
3019 if (PyErr_Occurred()) SWIG_fail;
3020 }
3021 {
3022 resultobj = SWIG_From_int((int)(result));
3023 }
3024 return resultobj;
3025 fail:
3026 return NULL;
3027 }
3028
3029
3030 static PyObject *_wrap_Palette_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3031 PyObject *resultobj;
3032 wxPalette *arg1 = (wxPalette *) 0 ;
3033 bool result;
3034 PyObject * obj0 = 0 ;
3035 char *kwnames[] = {
3036 (char *) "self", NULL
3037 };
3038
3039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_Ok",kwnames,&obj0)) goto fail;
3040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
3041 if (SWIG_arg_fail(1)) SWIG_fail;
3042 {
3043 PyThreadState* __tstate = wxPyBeginAllowThreads();
3044 result = (bool)(arg1)->Ok();
3045
3046 wxPyEndAllowThreads(__tstate);
3047 if (PyErr_Occurred()) SWIG_fail;
3048 }
3049 {
3050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3051 }
3052 return resultobj;
3053 fail:
3054 return NULL;
3055 }
3056
3057
3058 static PyObject * Palette_swigregister(PyObject *, PyObject *args) {
3059 PyObject *obj;
3060 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3061 SWIG_TypeClientData(SWIGTYPE_p_wxPalette, obj);
3062 Py_INCREF(obj);
3063 return Py_BuildValue((char *)"");
3064 }
3065 static PyObject *_wrap_new_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3066 PyObject *resultobj;
3067 wxColour *arg1 = 0 ;
3068 int arg2 = (int) 1 ;
3069 int arg3 = (int) wxSOLID ;
3070 wxPen *result;
3071 wxColour temp1 ;
3072 PyObject * obj0 = 0 ;
3073 PyObject * obj1 = 0 ;
3074 PyObject * obj2 = 0 ;
3075 char *kwnames[] = {
3076 (char *) "colour",(char *) "width",(char *) "style", NULL
3077 };
3078
3079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Pen",kwnames,&obj0,&obj1,&obj2)) goto fail;
3080 {
3081 arg1 = &temp1;
3082 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3083 }
3084 if (obj1) {
3085 {
3086 arg2 = (int)(SWIG_As_int(obj1));
3087 if (SWIG_arg_fail(2)) SWIG_fail;
3088 }
3089 }
3090 if (obj2) {
3091 {
3092 arg3 = (int)(SWIG_As_int(obj2));
3093 if (SWIG_arg_fail(3)) SWIG_fail;
3094 }
3095 }
3096 {
3097 if (!wxPyCheckForApp()) SWIG_fail;
3098 PyThreadState* __tstate = wxPyBeginAllowThreads();
3099 result = (wxPen *)new wxPen(*arg1,arg2,arg3);
3100
3101 wxPyEndAllowThreads(__tstate);
3102 if (PyErr_Occurred()) SWIG_fail;
3103 }
3104 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 1);
3105 return resultobj;
3106 fail:
3107 return NULL;
3108 }
3109
3110
3111 static PyObject *_wrap_delete_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3112 PyObject *resultobj;
3113 wxPen *arg1 = (wxPen *) 0 ;
3114 PyObject * obj0 = 0 ;
3115 char *kwnames[] = {
3116 (char *) "self", NULL
3117 };
3118
3119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Pen",kwnames,&obj0)) goto fail;
3120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3121 if (SWIG_arg_fail(1)) SWIG_fail;
3122 {
3123 PyThreadState* __tstate = wxPyBeginAllowThreads();
3124 delete arg1;
3125
3126 wxPyEndAllowThreads(__tstate);
3127 if (PyErr_Occurred()) SWIG_fail;
3128 }
3129 Py_INCREF(Py_None); resultobj = Py_None;
3130 return resultobj;
3131 fail:
3132 return NULL;
3133 }
3134
3135
3136 static PyObject *_wrap_Pen_GetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3137 PyObject *resultobj;
3138 wxPen *arg1 = (wxPen *) 0 ;
3139 int result;
3140 PyObject * obj0 = 0 ;
3141 char *kwnames[] = {
3142 (char *) "self", NULL
3143 };
3144
3145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetCap",kwnames,&obj0)) goto fail;
3146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3147 if (SWIG_arg_fail(1)) SWIG_fail;
3148 {
3149 PyThreadState* __tstate = wxPyBeginAllowThreads();
3150 result = (int)(arg1)->GetCap();
3151
3152 wxPyEndAllowThreads(__tstate);
3153 if (PyErr_Occurred()) SWIG_fail;
3154 }
3155 {
3156 resultobj = SWIG_From_int((int)(result));
3157 }
3158 return resultobj;
3159 fail:
3160 return NULL;
3161 }
3162
3163
3164 static PyObject *_wrap_Pen_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3165 PyObject *resultobj;
3166 wxPen *arg1 = (wxPen *) 0 ;
3167 wxColour result;
3168 PyObject * obj0 = 0 ;
3169 char *kwnames[] = {
3170 (char *) "self", NULL
3171 };
3172
3173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetColour",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 = (arg1)->GetColour();
3179
3180 wxPyEndAllowThreads(__tstate);
3181 if (PyErr_Occurred()) SWIG_fail;
3182 }
3183 {
3184 wxColour * resultptr;
3185 resultptr = new wxColour((wxColour &)(result));
3186 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3187 }
3188 return resultobj;
3189 fail:
3190 return NULL;
3191 }
3192
3193
3194 static PyObject *_wrap_Pen_GetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3195 PyObject *resultobj;
3196 wxPen *arg1 = (wxPen *) 0 ;
3197 int result;
3198 PyObject * obj0 = 0 ;
3199 char *kwnames[] = {
3200 (char *) "self", NULL
3201 };
3202
3203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetJoin",kwnames,&obj0)) goto fail;
3204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3205 if (SWIG_arg_fail(1)) SWIG_fail;
3206 {
3207 PyThreadState* __tstate = wxPyBeginAllowThreads();
3208 result = (int)(arg1)->GetJoin();
3209
3210 wxPyEndAllowThreads(__tstate);
3211 if (PyErr_Occurred()) SWIG_fail;
3212 }
3213 {
3214 resultobj = SWIG_From_int((int)(result));
3215 }
3216 return resultobj;
3217 fail:
3218 return NULL;
3219 }
3220
3221
3222 static PyObject *_wrap_Pen_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3223 PyObject *resultobj;
3224 wxPen *arg1 = (wxPen *) 0 ;
3225 int result;
3226 PyObject * obj0 = 0 ;
3227 char *kwnames[] = {
3228 (char *) "self", NULL
3229 };
3230
3231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetStyle",kwnames,&obj0)) goto fail;
3232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3233 if (SWIG_arg_fail(1)) SWIG_fail;
3234 {
3235 PyThreadState* __tstate = wxPyBeginAllowThreads();
3236 result = (int)(arg1)->GetStyle();
3237
3238 wxPyEndAllowThreads(__tstate);
3239 if (PyErr_Occurred()) SWIG_fail;
3240 }
3241 {
3242 resultobj = SWIG_From_int((int)(result));
3243 }
3244 return resultobj;
3245 fail:
3246 return NULL;
3247 }
3248
3249
3250 static PyObject *_wrap_Pen_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3251 PyObject *resultobj;
3252 wxPen *arg1 = (wxPen *) 0 ;
3253 int result;
3254 PyObject * obj0 = 0 ;
3255 char *kwnames[] = {
3256 (char *) "self", NULL
3257 };
3258
3259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetWidth",kwnames,&obj0)) goto fail;
3260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3261 if (SWIG_arg_fail(1)) SWIG_fail;
3262 {
3263 PyThreadState* __tstate = wxPyBeginAllowThreads();
3264 result = (int)(arg1)->GetWidth();
3265
3266 wxPyEndAllowThreads(__tstate);
3267 if (PyErr_Occurred()) SWIG_fail;
3268 }
3269 {
3270 resultobj = SWIG_From_int((int)(result));
3271 }
3272 return resultobj;
3273 fail:
3274 return NULL;
3275 }
3276
3277
3278 static PyObject *_wrap_Pen_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3279 PyObject *resultobj;
3280 wxPen *arg1 = (wxPen *) 0 ;
3281 bool result;
3282 PyObject * obj0 = 0 ;
3283 char *kwnames[] = {
3284 (char *) "self", NULL
3285 };
3286
3287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_Ok",kwnames,&obj0)) goto fail;
3288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3289 if (SWIG_arg_fail(1)) SWIG_fail;
3290 {
3291 PyThreadState* __tstate = wxPyBeginAllowThreads();
3292 result = (bool)(arg1)->Ok();
3293
3294 wxPyEndAllowThreads(__tstate);
3295 if (PyErr_Occurred()) SWIG_fail;
3296 }
3297 {
3298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3299 }
3300 return resultobj;
3301 fail:
3302 return NULL;
3303 }
3304
3305
3306 static PyObject *_wrap_Pen_SetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3307 PyObject *resultobj;
3308 wxPen *arg1 = (wxPen *) 0 ;
3309 int arg2 ;
3310 PyObject * obj0 = 0 ;
3311 PyObject * obj1 = 0 ;
3312 char *kwnames[] = {
3313 (char *) "self",(char *) "cap_style", NULL
3314 };
3315
3316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetCap",kwnames,&obj0,&obj1)) goto fail;
3317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3318 if (SWIG_arg_fail(1)) SWIG_fail;
3319 {
3320 arg2 = (int)(SWIG_As_int(obj1));
3321 if (SWIG_arg_fail(2)) SWIG_fail;
3322 }
3323 {
3324 PyThreadState* __tstate = wxPyBeginAllowThreads();
3325 (arg1)->SetCap(arg2);
3326
3327 wxPyEndAllowThreads(__tstate);
3328 if (PyErr_Occurred()) SWIG_fail;
3329 }
3330 Py_INCREF(Py_None); resultobj = Py_None;
3331 return resultobj;
3332 fail:
3333 return NULL;
3334 }
3335
3336
3337 static PyObject *_wrap_Pen_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3338 PyObject *resultobj;
3339 wxPen *arg1 = (wxPen *) 0 ;
3340 wxColour *arg2 = 0 ;
3341 wxColour temp2 ;
3342 PyObject * obj0 = 0 ;
3343 PyObject * obj1 = 0 ;
3344 char *kwnames[] = {
3345 (char *) "self",(char *) "colour", NULL
3346 };
3347
3348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetColour",kwnames,&obj0,&obj1)) goto fail;
3349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3350 if (SWIG_arg_fail(1)) SWIG_fail;
3351 {
3352 arg2 = &temp2;
3353 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3354 }
3355 {
3356 PyThreadState* __tstate = wxPyBeginAllowThreads();
3357 (arg1)->SetColour(*arg2);
3358
3359 wxPyEndAllowThreads(__tstate);
3360 if (PyErr_Occurred()) SWIG_fail;
3361 }
3362 Py_INCREF(Py_None); resultobj = Py_None;
3363 return resultobj;
3364 fail:
3365 return NULL;
3366 }
3367
3368
3369 static PyObject *_wrap_Pen_SetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3370 PyObject *resultobj;
3371 wxPen *arg1 = (wxPen *) 0 ;
3372 int arg2 ;
3373 PyObject * obj0 = 0 ;
3374 PyObject * obj1 = 0 ;
3375 char *kwnames[] = {
3376 (char *) "self",(char *) "join_style", NULL
3377 };
3378
3379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetJoin",kwnames,&obj0,&obj1)) goto fail;
3380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3381 if (SWIG_arg_fail(1)) SWIG_fail;
3382 {
3383 arg2 = (int)(SWIG_As_int(obj1));
3384 if (SWIG_arg_fail(2)) SWIG_fail;
3385 }
3386 {
3387 PyThreadState* __tstate = wxPyBeginAllowThreads();
3388 (arg1)->SetJoin(arg2);
3389
3390 wxPyEndAllowThreads(__tstate);
3391 if (PyErr_Occurred()) SWIG_fail;
3392 }
3393 Py_INCREF(Py_None); resultobj = Py_None;
3394 return resultobj;
3395 fail:
3396 return NULL;
3397 }
3398
3399
3400 static PyObject *_wrap_Pen_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3401 PyObject *resultobj;
3402 wxPen *arg1 = (wxPen *) 0 ;
3403 int arg2 ;
3404 PyObject * obj0 = 0 ;
3405 PyObject * obj1 = 0 ;
3406 char *kwnames[] = {
3407 (char *) "self",(char *) "style", NULL
3408 };
3409
3410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3412 if (SWIG_arg_fail(1)) SWIG_fail;
3413 {
3414 arg2 = (int)(SWIG_As_int(obj1));
3415 if (SWIG_arg_fail(2)) SWIG_fail;
3416 }
3417 {
3418 PyThreadState* __tstate = wxPyBeginAllowThreads();
3419 (arg1)->SetStyle(arg2);
3420
3421 wxPyEndAllowThreads(__tstate);
3422 if (PyErr_Occurred()) SWIG_fail;
3423 }
3424 Py_INCREF(Py_None); resultobj = Py_None;
3425 return resultobj;
3426 fail:
3427 return NULL;
3428 }
3429
3430
3431 static PyObject *_wrap_Pen_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3432 PyObject *resultobj;
3433 wxPen *arg1 = (wxPen *) 0 ;
3434 int arg2 ;
3435 PyObject * obj0 = 0 ;
3436 PyObject * obj1 = 0 ;
3437 char *kwnames[] = {
3438 (char *) "self",(char *) "width", NULL
3439 };
3440
3441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3443 if (SWIG_arg_fail(1)) SWIG_fail;
3444 {
3445 arg2 = (int)(SWIG_As_int(obj1));
3446 if (SWIG_arg_fail(2)) SWIG_fail;
3447 }
3448 {
3449 PyThreadState* __tstate = wxPyBeginAllowThreads();
3450 (arg1)->SetWidth(arg2);
3451
3452 wxPyEndAllowThreads(__tstate);
3453 if (PyErr_Occurred()) SWIG_fail;
3454 }
3455 Py_INCREF(Py_None); resultobj = Py_None;
3456 return resultobj;
3457 fail:
3458 return NULL;
3459 }
3460
3461
3462 static PyObject *_wrap_Pen_SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3463 PyObject *resultobj;
3464 wxPen *arg1 = (wxPen *) 0 ;
3465 int arg2 ;
3466 wxDash *arg3 = (wxDash *) 0 ;
3467 PyObject * obj0 = 0 ;
3468 PyObject * obj1 = 0 ;
3469 char *kwnames[] = {
3470 (char *) "self",(char *) "dashes", NULL
3471 };
3472
3473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetDashes",kwnames,&obj0,&obj1)) goto fail;
3474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3475 if (SWIG_arg_fail(1)) SWIG_fail;
3476 {
3477 arg2 = PyList_Size(obj1);
3478 arg3 = (wxDash*)byte_LIST_helper(obj1);
3479 if (arg3 == NULL) SWIG_fail;
3480 }
3481 {
3482 PyThreadState* __tstate = wxPyBeginAllowThreads();
3483 (arg1)->SetDashes(arg2,arg3);
3484
3485 wxPyEndAllowThreads(__tstate);
3486 if (PyErr_Occurred()) SWIG_fail;
3487 }
3488 Py_INCREF(Py_None); resultobj = Py_None;
3489 {
3490 if (arg3) delete [] arg3;
3491 }
3492 return resultobj;
3493 fail:
3494 {
3495 if (arg3) delete [] arg3;
3496 }
3497 return NULL;
3498 }
3499
3500
3501 static PyObject *_wrap_Pen_GetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3502 PyObject *resultobj;
3503 wxPen *arg1 = (wxPen *) 0 ;
3504 PyObject *result;
3505 PyObject * obj0 = 0 ;
3506 char *kwnames[] = {
3507 (char *) "self", NULL
3508 };
3509
3510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetDashes",kwnames,&obj0)) goto fail;
3511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3512 if (SWIG_arg_fail(1)) SWIG_fail;
3513 {
3514 PyThreadState* __tstate = wxPyBeginAllowThreads();
3515 result = (PyObject *)wxPen_GetDashes(arg1);
3516
3517 wxPyEndAllowThreads(__tstate);
3518 if (PyErr_Occurred()) SWIG_fail;
3519 }
3520 resultobj = result;
3521 return resultobj;
3522 fail:
3523 return NULL;
3524 }
3525
3526
3527 static PyObject *_wrap_Pen__SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3528 PyObject *resultobj;
3529 wxPen *arg1 = (wxPen *) 0 ;
3530 PyObject *arg2 = (PyObject *) 0 ;
3531 PyObject *arg3 = (PyObject *) 0 ;
3532 PyObject * obj0 = 0 ;
3533 PyObject * obj1 = 0 ;
3534 PyObject * obj2 = 0 ;
3535 char *kwnames[] = {
3536 (char *) "self",(char *) "_self",(char *) "pyDashes", NULL
3537 };
3538
3539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Pen__SetDashes",kwnames,&obj0,&obj1,&obj2)) goto fail;
3540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3541 if (SWIG_arg_fail(1)) SWIG_fail;
3542 arg2 = obj1;
3543 arg3 = obj2;
3544 {
3545 PyThreadState* __tstate = wxPyBeginAllowThreads();
3546 wxPen__SetDashes(arg1,arg2,arg3);
3547
3548 wxPyEndAllowThreads(__tstate);
3549 if (PyErr_Occurred()) SWIG_fail;
3550 }
3551 Py_INCREF(Py_None); resultobj = Py_None;
3552 return resultobj;
3553 fail:
3554 return NULL;
3555 }
3556
3557
3558 static PyObject *_wrap_Pen___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3559 PyObject *resultobj;
3560 wxPen *arg1 = (wxPen *) 0 ;
3561 wxPen *arg2 = (wxPen *) 0 ;
3562 bool result;
3563 PyObject * obj0 = 0 ;
3564 PyObject * obj1 = 0 ;
3565 char *kwnames[] = {
3566 (char *) "self",(char *) "other", NULL
3567 };
3568
3569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___eq__",kwnames,&obj0,&obj1)) goto fail;
3570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3571 if (SWIG_arg_fail(1)) SWIG_fail;
3572 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3573 if (SWIG_arg_fail(2)) SWIG_fail;
3574 {
3575 PyThreadState* __tstate = wxPyBeginAllowThreads();
3576 result = (bool)wxPen___eq__(arg1,(wxPen const *)arg2);
3577
3578 wxPyEndAllowThreads(__tstate);
3579 if (PyErr_Occurred()) SWIG_fail;
3580 }
3581 {
3582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3583 }
3584 return resultobj;
3585 fail:
3586 return NULL;
3587 }
3588
3589
3590 static PyObject *_wrap_Pen___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3591 PyObject *resultobj;
3592 wxPen *arg1 = (wxPen *) 0 ;
3593 wxPen *arg2 = (wxPen *) 0 ;
3594 bool result;
3595 PyObject * obj0 = 0 ;
3596 PyObject * obj1 = 0 ;
3597 char *kwnames[] = {
3598 (char *) "self",(char *) "other", NULL
3599 };
3600
3601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___ne__",kwnames,&obj0,&obj1)) goto fail;
3602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3603 if (SWIG_arg_fail(1)) SWIG_fail;
3604 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3605 if (SWIG_arg_fail(2)) SWIG_fail;
3606 {
3607 PyThreadState* __tstate = wxPyBeginAllowThreads();
3608 result = (bool)wxPen___ne__(arg1,(wxPen const *)arg2);
3609
3610 wxPyEndAllowThreads(__tstate);
3611 if (PyErr_Occurred()) SWIG_fail;
3612 }
3613 {
3614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3615 }
3616 return resultobj;
3617 fail:
3618 return NULL;
3619 }
3620
3621
3622 static PyObject * Pen_swigregister(PyObject *, PyObject *args) {
3623 PyObject *obj;
3624 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3625 SWIG_TypeClientData(SWIGTYPE_p_wxPen, obj);
3626 Py_INCREF(obj);
3627 return Py_BuildValue((char *)"");
3628 }
3629 static PyObject *_wrap_new_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3630 PyObject *resultobj;
3631 wxColour *arg1 = 0 ;
3632 int arg2 = (int) wxSOLID ;
3633 wxBrush *result;
3634 wxColour temp1 ;
3635 PyObject * obj0 = 0 ;
3636 PyObject * obj1 = 0 ;
3637 char *kwnames[] = {
3638 (char *) "colour",(char *) "style", NULL
3639 };
3640
3641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Brush",kwnames,&obj0,&obj1)) goto fail;
3642 {
3643 arg1 = &temp1;
3644 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3645 }
3646 if (obj1) {
3647 {
3648 arg2 = (int)(SWIG_As_int(obj1));
3649 if (SWIG_arg_fail(2)) SWIG_fail;
3650 }
3651 }
3652 {
3653 if (!wxPyCheckForApp()) SWIG_fail;
3654 PyThreadState* __tstate = wxPyBeginAllowThreads();
3655 result = (wxBrush *)new wxBrush((wxColour const &)*arg1,arg2);
3656
3657 wxPyEndAllowThreads(__tstate);
3658 if (PyErr_Occurred()) SWIG_fail;
3659 }
3660 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 1);
3661 return resultobj;
3662 fail:
3663 return NULL;
3664 }
3665
3666
3667 static PyObject *_wrap_delete_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3668 PyObject *resultobj;
3669 wxBrush *arg1 = (wxBrush *) 0 ;
3670 PyObject * obj0 = 0 ;
3671 char *kwnames[] = {
3672 (char *) "self", NULL
3673 };
3674
3675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Brush",kwnames,&obj0)) goto fail;
3676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3677 if (SWIG_arg_fail(1)) SWIG_fail;
3678 {
3679 PyThreadState* __tstate = wxPyBeginAllowThreads();
3680 delete arg1;
3681
3682 wxPyEndAllowThreads(__tstate);
3683 if (PyErr_Occurred()) SWIG_fail;
3684 }
3685 Py_INCREF(Py_None); resultobj = Py_None;
3686 return resultobj;
3687 fail:
3688 return NULL;
3689 }
3690
3691
3692 static PyObject *_wrap_Brush_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3693 PyObject *resultobj;
3694 wxBrush *arg1 = (wxBrush *) 0 ;
3695 wxColour *arg2 = 0 ;
3696 wxColour temp2 ;
3697 PyObject * obj0 = 0 ;
3698 PyObject * obj1 = 0 ;
3699 char *kwnames[] = {
3700 (char *) "self",(char *) "col", NULL
3701 };
3702
3703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetColour",kwnames,&obj0,&obj1)) goto fail;
3704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3705 if (SWIG_arg_fail(1)) SWIG_fail;
3706 {
3707 arg2 = &temp2;
3708 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3709 }
3710 {
3711 PyThreadState* __tstate = wxPyBeginAllowThreads();
3712 (arg1)->SetColour((wxColour const &)*arg2);
3713
3714 wxPyEndAllowThreads(__tstate);
3715 if (PyErr_Occurred()) SWIG_fail;
3716 }
3717 Py_INCREF(Py_None); resultobj = Py_None;
3718 return resultobj;
3719 fail:
3720 return NULL;
3721 }
3722
3723
3724 static PyObject *_wrap_Brush_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3725 PyObject *resultobj;
3726 wxBrush *arg1 = (wxBrush *) 0 ;
3727 int arg2 ;
3728 PyObject * obj0 = 0 ;
3729 PyObject * obj1 = 0 ;
3730 char *kwnames[] = {
3731 (char *) "self",(char *) "style", NULL
3732 };
3733
3734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3736 if (SWIG_arg_fail(1)) SWIG_fail;
3737 {
3738 arg2 = (int)(SWIG_As_int(obj1));
3739 if (SWIG_arg_fail(2)) SWIG_fail;
3740 }
3741 {
3742 PyThreadState* __tstate = wxPyBeginAllowThreads();
3743 (arg1)->SetStyle(arg2);
3744
3745 wxPyEndAllowThreads(__tstate);
3746 if (PyErr_Occurred()) SWIG_fail;
3747 }
3748 Py_INCREF(Py_None); resultobj = Py_None;
3749 return resultobj;
3750 fail:
3751 return NULL;
3752 }
3753
3754
3755 static PyObject *_wrap_Brush_SetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3756 PyObject *resultobj;
3757 wxBrush *arg1 = (wxBrush *) 0 ;
3758 wxBitmap *arg2 = 0 ;
3759 PyObject * obj0 = 0 ;
3760 PyObject * obj1 = 0 ;
3761 char *kwnames[] = {
3762 (char *) "self",(char *) "stipple", NULL
3763 };
3764
3765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStipple",kwnames,&obj0,&obj1)) goto fail;
3766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3767 if (SWIG_arg_fail(1)) SWIG_fail;
3768 {
3769 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3770 if (SWIG_arg_fail(2)) SWIG_fail;
3771 if (arg2 == NULL) {
3772 SWIG_null_ref("wxBitmap");
3773 }
3774 if (SWIG_arg_fail(2)) SWIG_fail;
3775 }
3776 {
3777 PyThreadState* __tstate = wxPyBeginAllowThreads();
3778 (arg1)->SetStipple((wxBitmap const &)*arg2);
3779
3780 wxPyEndAllowThreads(__tstate);
3781 if (PyErr_Occurred()) SWIG_fail;
3782 }
3783 Py_INCREF(Py_None); resultobj = Py_None;
3784 return resultobj;
3785 fail:
3786 return NULL;
3787 }
3788
3789
3790 static PyObject *_wrap_Brush_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3791 PyObject *resultobj;
3792 wxBrush *arg1 = (wxBrush *) 0 ;
3793 wxColour result;
3794 PyObject * obj0 = 0 ;
3795 char *kwnames[] = {
3796 (char *) "self", NULL
3797 };
3798
3799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetColour",kwnames,&obj0)) goto fail;
3800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3801 if (SWIG_arg_fail(1)) SWIG_fail;
3802 {
3803 PyThreadState* __tstate = wxPyBeginAllowThreads();
3804 result = ((wxBrush const *)arg1)->GetColour();
3805
3806 wxPyEndAllowThreads(__tstate);
3807 if (PyErr_Occurred()) SWIG_fail;
3808 }
3809 {
3810 wxColour * resultptr;
3811 resultptr = new wxColour((wxColour &)(result));
3812 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3813 }
3814 return resultobj;
3815 fail:
3816 return NULL;
3817 }
3818
3819
3820 static PyObject *_wrap_Brush_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3821 PyObject *resultobj;
3822 wxBrush *arg1 = (wxBrush *) 0 ;
3823 int result;
3824 PyObject * obj0 = 0 ;
3825 char *kwnames[] = {
3826 (char *) "self", NULL
3827 };
3828
3829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStyle",kwnames,&obj0)) goto fail;
3830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3831 if (SWIG_arg_fail(1)) SWIG_fail;
3832 {
3833 PyThreadState* __tstate = wxPyBeginAllowThreads();
3834 result = (int)((wxBrush const *)arg1)->GetStyle();
3835
3836 wxPyEndAllowThreads(__tstate);
3837 if (PyErr_Occurred()) SWIG_fail;
3838 }
3839 {
3840 resultobj = SWIG_From_int((int)(result));
3841 }
3842 return resultobj;
3843 fail:
3844 return NULL;
3845 }
3846
3847
3848 static PyObject *_wrap_Brush_GetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3849 PyObject *resultobj;
3850 wxBrush *arg1 = (wxBrush *) 0 ;
3851 wxBitmap *result;
3852 PyObject * obj0 = 0 ;
3853 char *kwnames[] = {
3854 (char *) "self", NULL
3855 };
3856
3857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStipple",kwnames,&obj0)) goto fail;
3858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3859 if (SWIG_arg_fail(1)) SWIG_fail;
3860 {
3861 PyThreadState* __tstate = wxPyBeginAllowThreads();
3862 result = (wxBitmap *)((wxBrush const *)arg1)->GetStipple();
3863
3864 wxPyEndAllowThreads(__tstate);
3865 if (PyErr_Occurred()) SWIG_fail;
3866 }
3867 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 0);
3868 return resultobj;
3869 fail:
3870 return NULL;
3871 }
3872
3873
3874 static PyObject *_wrap_Brush_IsHatch(PyObject *, PyObject *args, PyObject *kwargs) {
3875 PyObject *resultobj;
3876 wxBrush *arg1 = (wxBrush *) 0 ;
3877 bool result;
3878 PyObject * obj0 = 0 ;
3879 char *kwnames[] = {
3880 (char *) "self", NULL
3881 };
3882
3883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_IsHatch",kwnames,&obj0)) goto fail;
3884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3885 if (SWIG_arg_fail(1)) SWIG_fail;
3886 {
3887 PyThreadState* __tstate = wxPyBeginAllowThreads();
3888 result = (bool)((wxBrush const *)arg1)->IsHatch();
3889
3890 wxPyEndAllowThreads(__tstate);
3891 if (PyErr_Occurred()) SWIG_fail;
3892 }
3893 {
3894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3895 }
3896 return resultobj;
3897 fail:
3898 return NULL;
3899 }
3900
3901
3902 static PyObject *_wrap_Brush_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3903 PyObject *resultobj;
3904 wxBrush *arg1 = (wxBrush *) 0 ;
3905 bool result;
3906 PyObject * obj0 = 0 ;
3907 char *kwnames[] = {
3908 (char *) "self", NULL
3909 };
3910
3911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_Ok",kwnames,&obj0)) goto fail;
3912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3913 if (SWIG_arg_fail(1)) SWIG_fail;
3914 {
3915 PyThreadState* __tstate = wxPyBeginAllowThreads();
3916 result = (bool)(arg1)->Ok();
3917
3918 wxPyEndAllowThreads(__tstate);
3919 if (PyErr_Occurred()) SWIG_fail;
3920 }
3921 {
3922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3923 }
3924 return resultobj;
3925 fail:
3926 return NULL;
3927 }
3928
3929
3930 static PyObject *_wrap_Brush_MacGetTheme(PyObject *, PyObject *args, PyObject *kwargs) {
3931 PyObject *resultobj;
3932 wxBrush *arg1 = (wxBrush *) 0 ;
3933 short result;
3934 PyObject * obj0 = 0 ;
3935 char *kwnames[] = {
3936 (char *) "self", NULL
3937 };
3938
3939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_MacGetTheme",kwnames,&obj0)) goto fail;
3940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3941 if (SWIG_arg_fail(1)) SWIG_fail;
3942 {
3943 PyThreadState* __tstate = wxPyBeginAllowThreads();
3944 result = (short)(arg1)->MacGetTheme();
3945
3946 wxPyEndAllowThreads(__tstate);
3947 if (PyErr_Occurred()) SWIG_fail;
3948 }
3949 {
3950 resultobj = SWIG_From_short((short)(result));
3951 }
3952 return resultobj;
3953 fail:
3954 return NULL;
3955 }
3956
3957
3958 static PyObject *_wrap_Brush_MacSetTheme(PyObject *, PyObject *args, PyObject *kwargs) {
3959 PyObject *resultobj;
3960 wxBrush *arg1 = (wxBrush *) 0 ;
3961 short arg2 ;
3962 PyObject * obj0 = 0 ;
3963 PyObject * obj1 = 0 ;
3964 char *kwnames[] = {
3965 (char *) "self",(char *) "macThemeBrush", NULL
3966 };
3967
3968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_MacSetTheme",kwnames,&obj0,&obj1)) goto fail;
3969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3970 if (SWIG_arg_fail(1)) SWIG_fail;
3971 {
3972 arg2 = (short)(SWIG_As_short(obj1));
3973 if (SWIG_arg_fail(2)) SWIG_fail;
3974 }
3975 {
3976 PyThreadState* __tstate = wxPyBeginAllowThreads();
3977 (arg1)->MacSetTheme(arg2);
3978
3979 wxPyEndAllowThreads(__tstate);
3980 if (PyErr_Occurred()) SWIG_fail;
3981 }
3982 Py_INCREF(Py_None); resultobj = Py_None;
3983 return resultobj;
3984 fail:
3985 return NULL;
3986 }
3987
3988
3989 static PyObject * Brush_swigregister(PyObject *, PyObject *args) {
3990 PyObject *obj;
3991 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3992 SWIG_TypeClientData(SWIGTYPE_p_wxBrush, obj);
3993 Py_INCREF(obj);
3994 return Py_BuildValue((char *)"");
3995 }
3996 static PyObject *_wrap_new_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
3997 PyObject *resultobj;
3998 wxString *arg1 = 0 ;
3999 wxBitmapType arg2 = (wxBitmapType) wxBITMAP_TYPE_ANY ;
4000 wxBitmap *result;
4001 bool temp1 = false ;
4002 PyObject * obj0 = 0 ;
4003 PyObject * obj1 = 0 ;
4004 char *kwnames[] = {
4005 (char *) "name",(char *) "type", NULL
4006 };
4007
4008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Bitmap",kwnames,&obj0,&obj1)) goto fail;
4009 {
4010 arg1 = wxString_in_helper(obj0);
4011 if (arg1 == NULL) SWIG_fail;
4012 temp1 = true;
4013 }
4014 if (obj1) {
4015 {
4016 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
4017 if (SWIG_arg_fail(2)) SWIG_fail;
4018 }
4019 }
4020 {
4021 if (!wxPyCheckForApp()) SWIG_fail;
4022 PyThreadState* __tstate = wxPyBeginAllowThreads();
4023 result = (wxBitmap *)new wxBitmap((wxString const &)*arg1,(wxBitmapType )arg2);
4024
4025 wxPyEndAllowThreads(__tstate);
4026 if (PyErr_Occurred()) SWIG_fail;
4027 }
4028 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4029 {
4030 if (temp1)
4031 delete arg1;
4032 }
4033 return resultobj;
4034 fail:
4035 {
4036 if (temp1)
4037 delete arg1;
4038 }
4039 return NULL;
4040 }
4041
4042
4043 static PyObject *_wrap_delete_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4044 PyObject *resultobj;
4045 wxBitmap *arg1 = (wxBitmap *) 0 ;
4046 PyObject * obj0 = 0 ;
4047 char *kwnames[] = {
4048 (char *) "self", NULL
4049 };
4050
4051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Bitmap",kwnames,&obj0)) goto fail;
4052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4053 if (SWIG_arg_fail(1)) SWIG_fail;
4054 {
4055 PyThreadState* __tstate = wxPyBeginAllowThreads();
4056 delete arg1;
4057
4058 wxPyEndAllowThreads(__tstate);
4059 if (PyErr_Occurred()) SWIG_fail;
4060 }
4061 Py_INCREF(Py_None); resultobj = Py_None;
4062 return resultobj;
4063 fail:
4064 return NULL;
4065 }
4066
4067
4068 static PyObject *_wrap_new_EmptyBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4069 PyObject *resultobj;
4070 int arg1 ;
4071 int arg2 ;
4072 int arg3 = (int) -1 ;
4073 wxBitmap *result;
4074 PyObject * obj0 = 0 ;
4075 PyObject * obj1 = 0 ;
4076 PyObject * obj2 = 0 ;
4077 char *kwnames[] = {
4078 (char *) "width",(char *) "height",(char *) "depth", NULL
4079 };
4080
4081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_EmptyBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
4082 {
4083 arg1 = (int)(SWIG_As_int(obj0));
4084 if (SWIG_arg_fail(1)) SWIG_fail;
4085 }
4086 {
4087 arg2 = (int)(SWIG_As_int(obj1));
4088 if (SWIG_arg_fail(2)) SWIG_fail;
4089 }
4090 if (obj2) {
4091 {
4092 arg3 = (int)(SWIG_As_int(obj2));
4093 if (SWIG_arg_fail(3)) SWIG_fail;
4094 }
4095 }
4096 {
4097 if (!wxPyCheckForApp()) SWIG_fail;
4098 PyThreadState* __tstate = wxPyBeginAllowThreads();
4099 result = (wxBitmap *)new wxBitmap(arg1,arg2,arg3);
4100
4101 wxPyEndAllowThreads(__tstate);
4102 if (PyErr_Occurred()) SWIG_fail;
4103 }
4104 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4105 return resultobj;
4106 fail:
4107 return NULL;
4108 }
4109
4110
4111 static PyObject *_wrap_new_BitmapFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4112 PyObject *resultobj;
4113 wxIcon *arg1 = 0 ;
4114 wxBitmap *result;
4115 PyObject * obj0 = 0 ;
4116 char *kwnames[] = {
4117 (char *) "icon", NULL
4118 };
4119
4120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromIcon",kwnames,&obj0)) goto fail;
4121 {
4122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4123 if (SWIG_arg_fail(1)) SWIG_fail;
4124 if (arg1 == NULL) {
4125 SWIG_null_ref("wxIcon");
4126 }
4127 if (SWIG_arg_fail(1)) SWIG_fail;
4128 }
4129 {
4130 if (!wxPyCheckForApp()) SWIG_fail;
4131 PyThreadState* __tstate = wxPyBeginAllowThreads();
4132 result = (wxBitmap *)new wxBitmap((wxIcon const &)*arg1);
4133
4134 wxPyEndAllowThreads(__tstate);
4135 if (PyErr_Occurred()) SWIG_fail;
4136 }
4137 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4138 return resultobj;
4139 fail:
4140 return NULL;
4141 }
4142
4143
4144 static PyObject *_wrap_new_BitmapFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
4145 PyObject *resultobj;
4146 wxImage *arg1 = 0 ;
4147 int arg2 = (int) -1 ;
4148 wxBitmap *result;
4149 PyObject * obj0 = 0 ;
4150 PyObject * obj1 = 0 ;
4151 char *kwnames[] = {
4152 (char *) "image",(char *) "depth", NULL
4153 };
4154
4155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BitmapFromImage",kwnames,&obj0,&obj1)) goto fail;
4156 {
4157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
4158 if (SWIG_arg_fail(1)) SWIG_fail;
4159 if (arg1 == NULL) {
4160 SWIG_null_ref("wxImage");
4161 }
4162 if (SWIG_arg_fail(1)) SWIG_fail;
4163 }
4164 if (obj1) {
4165 {
4166 arg2 = (int)(SWIG_As_int(obj1));
4167 if (SWIG_arg_fail(2)) SWIG_fail;
4168 }
4169 }
4170 {
4171 if (!wxPyCheckForApp()) SWIG_fail;
4172 PyThreadState* __tstate = wxPyBeginAllowThreads();
4173 result = (wxBitmap *)new wxBitmap((wxImage const &)*arg1,arg2);
4174
4175 wxPyEndAllowThreads(__tstate);
4176 if (PyErr_Occurred()) SWIG_fail;
4177 }
4178 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4179 return resultobj;
4180 fail:
4181 return NULL;
4182 }
4183
4184
4185 static PyObject *_wrap_new_BitmapFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
4186 PyObject *resultobj;
4187 PyObject *arg1 = (PyObject *) 0 ;
4188 wxBitmap *result;
4189 PyObject * obj0 = 0 ;
4190 char *kwnames[] = {
4191 (char *) "listOfStrings", NULL
4192 };
4193
4194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromXPMData",kwnames,&obj0)) goto fail;
4195 arg1 = obj0;
4196 {
4197 if (!wxPyCheckForApp()) SWIG_fail;
4198 PyThreadState* __tstate = wxPyBeginAllowThreads();
4199 result = (wxBitmap *)new_wxBitmap(arg1);
4200
4201 wxPyEndAllowThreads(__tstate);
4202 if (PyErr_Occurred()) SWIG_fail;
4203 }
4204 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4205 return resultobj;
4206 fail:
4207 return NULL;
4208 }
4209
4210
4211 static PyObject *_wrap_new_BitmapFromBits(PyObject *, PyObject *args, PyObject *kwargs) {
4212 PyObject *resultobj;
4213 PyObject *arg1 = (PyObject *) 0 ;
4214 int arg2 ;
4215 int arg3 ;
4216 int arg4 = (int) 1 ;
4217 wxBitmap *result;
4218 PyObject * obj0 = 0 ;
4219 PyObject * obj1 = 0 ;
4220 PyObject * obj2 = 0 ;
4221 PyObject * obj3 = 0 ;
4222 char *kwnames[] = {
4223 (char *) "bits",(char *) "width",(char *) "height",(char *) "depth", NULL
4224 };
4225
4226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:new_BitmapFromBits",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4227 arg1 = obj0;
4228 {
4229 arg2 = (int)(SWIG_As_int(obj1));
4230 if (SWIG_arg_fail(2)) SWIG_fail;
4231 }
4232 {
4233 arg3 = (int)(SWIG_As_int(obj2));
4234 if (SWIG_arg_fail(3)) SWIG_fail;
4235 }
4236 if (obj3) {
4237 {
4238 arg4 = (int)(SWIG_As_int(obj3));
4239 if (SWIG_arg_fail(4)) SWIG_fail;
4240 }
4241 }
4242 {
4243 if (!wxPyCheckForApp()) SWIG_fail;
4244 PyThreadState* __tstate = wxPyBeginAllowThreads();
4245 result = (wxBitmap *)new_wxBitmap(arg1,arg2,arg3,arg4);
4246
4247 wxPyEndAllowThreads(__tstate);
4248 if (PyErr_Occurred()) SWIG_fail;
4249 }
4250 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4251 return resultobj;
4252 fail:
4253 return NULL;
4254 }
4255
4256
4257 static PyObject *_wrap_Bitmap_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
4258 PyObject *resultobj;
4259 wxBitmap *arg1 = (wxBitmap *) 0 ;
4260 bool result;
4261 PyObject * obj0 = 0 ;
4262 char *kwnames[] = {
4263 (char *) "self", NULL
4264 };
4265
4266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_Ok",kwnames,&obj0)) goto fail;
4267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4268 if (SWIG_arg_fail(1)) SWIG_fail;
4269 {
4270 PyThreadState* __tstate = wxPyBeginAllowThreads();
4271 result = (bool)(arg1)->Ok();
4272
4273 wxPyEndAllowThreads(__tstate);
4274 if (PyErr_Occurred()) SWIG_fail;
4275 }
4276 {
4277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4278 }
4279 return resultobj;
4280 fail:
4281 return NULL;
4282 }
4283
4284
4285 static PyObject *_wrap_Bitmap_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4286 PyObject *resultobj;
4287 wxBitmap *arg1 = (wxBitmap *) 0 ;
4288 int result;
4289 PyObject * obj0 = 0 ;
4290 char *kwnames[] = {
4291 (char *) "self", NULL
4292 };
4293
4294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetWidth",kwnames,&obj0)) goto fail;
4295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4296 if (SWIG_arg_fail(1)) SWIG_fail;
4297 {
4298 PyThreadState* __tstate = wxPyBeginAllowThreads();
4299 result = (int)(arg1)->GetWidth();
4300
4301 wxPyEndAllowThreads(__tstate);
4302 if (PyErr_Occurred()) SWIG_fail;
4303 }
4304 {
4305 resultobj = SWIG_From_int((int)(result));
4306 }
4307 return resultobj;
4308 fail:
4309 return NULL;
4310 }
4311
4312
4313 static PyObject *_wrap_Bitmap_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4314 PyObject *resultobj;
4315 wxBitmap *arg1 = (wxBitmap *) 0 ;
4316 int result;
4317 PyObject * obj0 = 0 ;
4318 char *kwnames[] = {
4319 (char *) "self", NULL
4320 };
4321
4322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetHeight",kwnames,&obj0)) goto fail;
4323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4324 if (SWIG_arg_fail(1)) SWIG_fail;
4325 {
4326 PyThreadState* __tstate = wxPyBeginAllowThreads();
4327 result = (int)(arg1)->GetHeight();
4328
4329 wxPyEndAllowThreads(__tstate);
4330 if (PyErr_Occurred()) SWIG_fail;
4331 }
4332 {
4333 resultobj = SWIG_From_int((int)(result));
4334 }
4335 return resultobj;
4336 fail:
4337 return NULL;
4338 }
4339
4340
4341 static PyObject *_wrap_Bitmap_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4342 PyObject *resultobj;
4343 wxBitmap *arg1 = (wxBitmap *) 0 ;
4344 int result;
4345 PyObject * obj0 = 0 ;
4346 char *kwnames[] = {
4347 (char *) "self", NULL
4348 };
4349
4350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetDepth",kwnames,&obj0)) goto fail;
4351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4352 if (SWIG_arg_fail(1)) SWIG_fail;
4353 {
4354 PyThreadState* __tstate = wxPyBeginAllowThreads();
4355 result = (int)(arg1)->GetDepth();
4356
4357 wxPyEndAllowThreads(__tstate);
4358 if (PyErr_Occurred()) SWIG_fail;
4359 }
4360 {
4361 resultobj = SWIG_From_int((int)(result));
4362 }
4363 return resultobj;
4364 fail:
4365 return NULL;
4366 }
4367
4368
4369 static PyObject *_wrap_Bitmap_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4370 PyObject *resultobj;
4371 wxBitmap *arg1 = (wxBitmap *) 0 ;
4372 wxSize result;
4373 PyObject * obj0 = 0 ;
4374 char *kwnames[] = {
4375 (char *) "self", NULL
4376 };
4377
4378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetSize",kwnames,&obj0)) goto fail;
4379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4380 if (SWIG_arg_fail(1)) SWIG_fail;
4381 {
4382 PyThreadState* __tstate = wxPyBeginAllowThreads();
4383 result = wxBitmap_GetSize(arg1);
4384
4385 wxPyEndAllowThreads(__tstate);
4386 if (PyErr_Occurred()) SWIG_fail;
4387 }
4388 {
4389 wxSize * resultptr;
4390 resultptr = new wxSize((wxSize &)(result));
4391 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
4392 }
4393 return resultobj;
4394 fail:
4395 return NULL;
4396 }
4397
4398
4399 static PyObject *_wrap_Bitmap_ConvertToImage(PyObject *, PyObject *args, PyObject *kwargs) {
4400 PyObject *resultobj;
4401 wxBitmap *arg1 = (wxBitmap *) 0 ;
4402 SwigValueWrapper<wxImage > result;
4403 PyObject * obj0 = 0 ;
4404 char *kwnames[] = {
4405 (char *) "self", NULL
4406 };
4407
4408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_ConvertToImage",kwnames,&obj0)) goto fail;
4409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4410 if (SWIG_arg_fail(1)) SWIG_fail;
4411 {
4412 PyThreadState* __tstate = wxPyBeginAllowThreads();
4413 result = ((wxBitmap const *)arg1)->ConvertToImage();
4414
4415 wxPyEndAllowThreads(__tstate);
4416 if (PyErr_Occurred()) SWIG_fail;
4417 }
4418 {
4419 wxImage * resultptr;
4420 resultptr = new wxImage((wxImage &)(result));
4421 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
4422 }
4423 return resultobj;
4424 fail:
4425 return NULL;
4426 }
4427
4428
4429 static PyObject *_wrap_Bitmap_GetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4430 PyObject *resultobj;
4431 wxBitmap *arg1 = (wxBitmap *) 0 ;
4432 wxMask *result;
4433 PyObject * obj0 = 0 ;
4434 char *kwnames[] = {
4435 (char *) "self", NULL
4436 };
4437
4438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetMask",kwnames,&obj0)) goto fail;
4439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4440 if (SWIG_arg_fail(1)) SWIG_fail;
4441 {
4442 PyThreadState* __tstate = wxPyBeginAllowThreads();
4443 result = (wxMask *)((wxBitmap const *)arg1)->GetMask();
4444
4445 wxPyEndAllowThreads(__tstate);
4446 if (PyErr_Occurred()) SWIG_fail;
4447 }
4448 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 0);
4449 return resultobj;
4450 fail:
4451 return NULL;
4452 }
4453
4454
4455 static PyObject *_wrap_Bitmap_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4456 PyObject *resultobj;
4457 wxBitmap *arg1 = (wxBitmap *) 0 ;
4458 wxMask *arg2 = (wxMask *) 0 ;
4459 PyObject * obj0 = 0 ;
4460 PyObject * obj1 = 0 ;
4461 char *kwnames[] = {
4462 (char *) "self",(char *) "mask", NULL
4463 };
4464
4465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMask",kwnames,&obj0,&obj1)) goto fail;
4466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4467 if (SWIG_arg_fail(1)) SWIG_fail;
4468 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMask, SWIG_POINTER_EXCEPTION | 0);
4469 if (SWIG_arg_fail(2)) SWIG_fail;
4470 {
4471 PyThreadState* __tstate = wxPyBeginAllowThreads();
4472 (arg1)->SetMask(arg2);
4473
4474 wxPyEndAllowThreads(__tstate);
4475 if (PyErr_Occurred()) SWIG_fail;
4476 }
4477 Py_INCREF(Py_None); resultobj = Py_None;
4478 return resultobj;
4479 fail:
4480 return NULL;
4481 }
4482
4483
4484 static PyObject *_wrap_Bitmap_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
4485 PyObject *resultobj;
4486 wxBitmap *arg1 = (wxBitmap *) 0 ;
4487 wxColour *arg2 = 0 ;
4488 wxColour temp2 ;
4489 PyObject * obj0 = 0 ;
4490 PyObject * obj1 = 0 ;
4491 char *kwnames[] = {
4492 (char *) "self",(char *) "colour", NULL
4493 };
4494
4495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMaskColour",kwnames,&obj0,&obj1)) goto fail;
4496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4497 if (SWIG_arg_fail(1)) SWIG_fail;
4498 {
4499 arg2 = &temp2;
4500 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4501 }
4502 {
4503 PyThreadState* __tstate = wxPyBeginAllowThreads();
4504 wxBitmap_SetMaskColour(arg1,(wxColour const &)*arg2);
4505
4506 wxPyEndAllowThreads(__tstate);
4507 if (PyErr_Occurred()) SWIG_fail;
4508 }
4509 Py_INCREF(Py_None); resultobj = Py_None;
4510 return resultobj;
4511 fail:
4512 return NULL;
4513 }
4514
4515
4516 static PyObject *_wrap_Bitmap_GetSubBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4517 PyObject *resultobj;
4518 wxBitmap *arg1 = (wxBitmap *) 0 ;
4519 wxRect *arg2 = 0 ;
4520 SwigValueWrapper<wxBitmap > result;
4521 wxRect temp2 ;
4522 PyObject * obj0 = 0 ;
4523 PyObject * obj1 = 0 ;
4524 char *kwnames[] = {
4525 (char *) "self",(char *) "rect", NULL
4526 };
4527
4528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_GetSubBitmap",kwnames,&obj0,&obj1)) goto fail;
4529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4530 if (SWIG_arg_fail(1)) SWIG_fail;
4531 {
4532 arg2 = &temp2;
4533 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4534 }
4535 {
4536 PyThreadState* __tstate = wxPyBeginAllowThreads();
4537 result = ((wxBitmap const *)arg1)->GetSubBitmap((wxRect const &)*arg2);
4538
4539 wxPyEndAllowThreads(__tstate);
4540 if (PyErr_Occurred()) SWIG_fail;
4541 }
4542 {
4543 wxBitmap * resultptr;
4544 resultptr = new wxBitmap((wxBitmap &)(result));
4545 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
4546 }
4547 return resultobj;
4548 fail:
4549 return NULL;
4550 }
4551
4552
4553 static PyObject *_wrap_Bitmap_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
4554 PyObject *resultobj;
4555 wxBitmap *arg1 = (wxBitmap *) 0 ;
4556 wxString *arg2 = 0 ;
4557 wxBitmapType arg3 ;
4558 wxPalette *arg4 = (wxPalette *) NULL ;
4559 bool result;
4560 bool temp2 = false ;
4561 PyObject * obj0 = 0 ;
4562 PyObject * obj1 = 0 ;
4563 PyObject * obj2 = 0 ;
4564 PyObject * obj3 = 0 ;
4565 char *kwnames[] = {
4566 (char *) "self",(char *) "name",(char *) "type",(char *) "palette", NULL
4567 };
4568
4569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Bitmap_SaveFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4571 if (SWIG_arg_fail(1)) SWIG_fail;
4572 {
4573 arg2 = wxString_in_helper(obj1);
4574 if (arg2 == NULL) SWIG_fail;
4575 temp2 = true;
4576 }
4577 {
4578 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4579 if (SWIG_arg_fail(3)) SWIG_fail;
4580 }
4581 if (obj3) {
4582 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
4583 if (SWIG_arg_fail(4)) SWIG_fail;
4584 }
4585 {
4586 PyThreadState* __tstate = wxPyBeginAllowThreads();
4587 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxBitmapType )arg3,arg4);
4588
4589 wxPyEndAllowThreads(__tstate);
4590 if (PyErr_Occurred()) SWIG_fail;
4591 }
4592 {
4593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4594 }
4595 {
4596 if (temp2)
4597 delete arg2;
4598 }
4599 return resultobj;
4600 fail:
4601 {
4602 if (temp2)
4603 delete arg2;
4604 }
4605 return NULL;
4606 }
4607
4608
4609 static PyObject *_wrap_Bitmap_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
4610 PyObject *resultobj;
4611 wxBitmap *arg1 = (wxBitmap *) 0 ;
4612 wxString *arg2 = 0 ;
4613 wxBitmapType arg3 ;
4614 bool result;
4615 bool temp2 = false ;
4616 PyObject * obj0 = 0 ;
4617 PyObject * obj1 = 0 ;
4618 PyObject * obj2 = 0 ;
4619 char *kwnames[] = {
4620 (char *) "self",(char *) "name",(char *) "type", NULL
4621 };
4622
4623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Bitmap_LoadFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
4624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4625 if (SWIG_arg_fail(1)) SWIG_fail;
4626 {
4627 arg2 = wxString_in_helper(obj1);
4628 if (arg2 == NULL) SWIG_fail;
4629 temp2 = true;
4630 }
4631 {
4632 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4633 if (SWIG_arg_fail(3)) SWIG_fail;
4634 }
4635 {
4636 PyThreadState* __tstate = wxPyBeginAllowThreads();
4637 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxBitmapType )arg3);
4638
4639 wxPyEndAllowThreads(__tstate);
4640 if (PyErr_Occurred()) SWIG_fail;
4641 }
4642 {
4643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4644 }
4645 {
4646 if (temp2)
4647 delete arg2;
4648 }
4649 return resultobj;
4650 fail:
4651 {
4652 if (temp2)
4653 delete arg2;
4654 }
4655 return NULL;
4656 }
4657
4658
4659 static PyObject *_wrap_Bitmap_GetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
4660 PyObject *resultobj;
4661 wxBitmap *arg1 = (wxBitmap *) 0 ;
4662 wxPalette *result;
4663 PyObject * obj0 = 0 ;
4664 char *kwnames[] = {
4665 (char *) "self", NULL
4666 };
4667
4668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetPalette",kwnames,&obj0)) goto fail;
4669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4670 if (SWIG_arg_fail(1)) SWIG_fail;
4671 {
4672 PyThreadState* __tstate = wxPyBeginAllowThreads();
4673 result = (wxPalette *)((wxBitmap const *)arg1)->GetPalette();
4674
4675 wxPyEndAllowThreads(__tstate);
4676 if (PyErr_Occurred()) SWIG_fail;
4677 }
4678 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 0);
4679 return resultobj;
4680 fail:
4681 return NULL;
4682 }
4683
4684
4685 static PyObject *_wrap_Bitmap_CopyFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4686 PyObject *resultobj;
4687 wxBitmap *arg1 = (wxBitmap *) 0 ;
4688 wxIcon *arg2 = 0 ;
4689 bool result;
4690 PyObject * obj0 = 0 ;
4691 PyObject * obj1 = 0 ;
4692 char *kwnames[] = {
4693 (char *) "self",(char *) "icon", NULL
4694 };
4695
4696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_CopyFromIcon",kwnames,&obj0,&obj1)) goto fail;
4697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4698 if (SWIG_arg_fail(1)) SWIG_fail;
4699 {
4700 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4701 if (SWIG_arg_fail(2)) SWIG_fail;
4702 if (arg2 == NULL) {
4703 SWIG_null_ref("wxIcon");
4704 }
4705 if (SWIG_arg_fail(2)) SWIG_fail;
4706 }
4707 {
4708 PyThreadState* __tstate = wxPyBeginAllowThreads();
4709 result = (bool)(arg1)->CopyFromIcon((wxIcon const &)*arg2);
4710
4711 wxPyEndAllowThreads(__tstate);
4712 if (PyErr_Occurred()) SWIG_fail;
4713 }
4714 {
4715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4716 }
4717 return resultobj;
4718 fail:
4719 return NULL;
4720 }
4721
4722
4723 static PyObject *_wrap_Bitmap_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4724 PyObject *resultobj;
4725 wxBitmap *arg1 = (wxBitmap *) 0 ;
4726 int arg2 ;
4727 PyObject * obj0 = 0 ;
4728 PyObject * obj1 = 0 ;
4729 char *kwnames[] = {
4730 (char *) "self",(char *) "height", NULL
4731 };
4732
4733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetHeight",kwnames,&obj0,&obj1)) goto fail;
4734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4735 if (SWIG_arg_fail(1)) SWIG_fail;
4736 {
4737 arg2 = (int)(SWIG_As_int(obj1));
4738 if (SWIG_arg_fail(2)) SWIG_fail;
4739 }
4740 {
4741 PyThreadState* __tstate = wxPyBeginAllowThreads();
4742 (arg1)->SetHeight(arg2);
4743
4744 wxPyEndAllowThreads(__tstate);
4745 if (PyErr_Occurred()) SWIG_fail;
4746 }
4747 Py_INCREF(Py_None); resultobj = Py_None;
4748 return resultobj;
4749 fail:
4750 return NULL;
4751 }
4752
4753
4754 static PyObject *_wrap_Bitmap_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4755 PyObject *resultobj;
4756 wxBitmap *arg1 = (wxBitmap *) 0 ;
4757 int arg2 ;
4758 PyObject * obj0 = 0 ;
4759 PyObject * obj1 = 0 ;
4760 char *kwnames[] = {
4761 (char *) "self",(char *) "width", NULL
4762 };
4763
4764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetWidth",kwnames,&obj0,&obj1)) goto fail;
4765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4766 if (SWIG_arg_fail(1)) SWIG_fail;
4767 {
4768 arg2 = (int)(SWIG_As_int(obj1));
4769 if (SWIG_arg_fail(2)) SWIG_fail;
4770 }
4771 {
4772 PyThreadState* __tstate = wxPyBeginAllowThreads();
4773 (arg1)->SetWidth(arg2);
4774
4775 wxPyEndAllowThreads(__tstate);
4776 if (PyErr_Occurred()) SWIG_fail;
4777 }
4778 Py_INCREF(Py_None); resultobj = Py_None;
4779 return resultobj;
4780 fail:
4781 return NULL;
4782 }
4783
4784
4785 static PyObject *_wrap_Bitmap_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4786 PyObject *resultobj;
4787 wxBitmap *arg1 = (wxBitmap *) 0 ;
4788 int arg2 ;
4789 PyObject * obj0 = 0 ;
4790 PyObject * obj1 = 0 ;
4791 char *kwnames[] = {
4792 (char *) "self",(char *) "depth", NULL
4793 };
4794
4795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetDepth",kwnames,&obj0,&obj1)) goto fail;
4796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4797 if (SWIG_arg_fail(1)) SWIG_fail;
4798 {
4799 arg2 = (int)(SWIG_As_int(obj1));
4800 if (SWIG_arg_fail(2)) SWIG_fail;
4801 }
4802 {
4803 PyThreadState* __tstate = wxPyBeginAllowThreads();
4804 (arg1)->SetDepth(arg2);
4805
4806 wxPyEndAllowThreads(__tstate);
4807 if (PyErr_Occurred()) SWIG_fail;
4808 }
4809 Py_INCREF(Py_None); resultobj = Py_None;
4810 return resultobj;
4811 fail:
4812 return NULL;
4813 }
4814
4815
4816 static PyObject *_wrap_Bitmap_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4817 PyObject *resultobj;
4818 wxBitmap *arg1 = (wxBitmap *) 0 ;
4819 wxSize *arg2 = 0 ;
4820 wxSize temp2 ;
4821 PyObject * obj0 = 0 ;
4822 PyObject * obj1 = 0 ;
4823 char *kwnames[] = {
4824 (char *) "self",(char *) "size", NULL
4825 };
4826
4827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetSize",kwnames,&obj0,&obj1)) goto fail;
4828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4829 if (SWIG_arg_fail(1)) SWIG_fail;
4830 {
4831 arg2 = &temp2;
4832 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4833 }
4834 {
4835 PyThreadState* __tstate = wxPyBeginAllowThreads();
4836 wxBitmap_SetSize(arg1,(wxSize const &)*arg2);
4837
4838 wxPyEndAllowThreads(__tstate);
4839 if (PyErr_Occurred()) SWIG_fail;
4840 }
4841 Py_INCREF(Py_None); resultobj = Py_None;
4842 return resultobj;
4843 fail:
4844 return NULL;
4845 }
4846
4847
4848 static PyObject *_wrap_Bitmap___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4849 PyObject *resultobj;
4850 wxBitmap *arg1 = (wxBitmap *) 0 ;
4851 wxBitmap *arg2 = (wxBitmap *) 0 ;
4852 bool result;
4853 PyObject * obj0 = 0 ;
4854 PyObject * obj1 = 0 ;
4855 char *kwnames[] = {
4856 (char *) "self",(char *) "other", NULL
4857 };
4858
4859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___eq__",kwnames,&obj0,&obj1)) goto fail;
4860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4861 if (SWIG_arg_fail(1)) SWIG_fail;
4862 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4863 if (SWIG_arg_fail(2)) SWIG_fail;
4864 {
4865 PyThreadState* __tstate = wxPyBeginAllowThreads();
4866 result = (bool)wxBitmap___eq__(arg1,(wxBitmap const *)arg2);
4867
4868 wxPyEndAllowThreads(__tstate);
4869 if (PyErr_Occurred()) SWIG_fail;
4870 }
4871 {
4872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4873 }
4874 return resultobj;
4875 fail:
4876 return NULL;
4877 }
4878
4879
4880 static PyObject *_wrap_Bitmap___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4881 PyObject *resultobj;
4882 wxBitmap *arg1 = (wxBitmap *) 0 ;
4883 wxBitmap *arg2 = (wxBitmap *) 0 ;
4884 bool result;
4885 PyObject * obj0 = 0 ;
4886 PyObject * obj1 = 0 ;
4887 char *kwnames[] = {
4888 (char *) "self",(char *) "other", NULL
4889 };
4890
4891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___ne__",kwnames,&obj0,&obj1)) goto fail;
4892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4893 if (SWIG_arg_fail(1)) SWIG_fail;
4894 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4895 if (SWIG_arg_fail(2)) SWIG_fail;
4896 {
4897 PyThreadState* __tstate = wxPyBeginAllowThreads();
4898 result = (bool)wxBitmap___ne__(arg1,(wxBitmap const *)arg2);
4899
4900 wxPyEndAllowThreads(__tstate);
4901 if (PyErr_Occurred()) SWIG_fail;
4902 }
4903 {
4904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4905 }
4906 return resultobj;
4907 fail:
4908 return NULL;
4909 }
4910
4911
4912 static PyObject * Bitmap_swigregister(PyObject *, PyObject *args) {
4913 PyObject *obj;
4914 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4915 SWIG_TypeClientData(SWIGTYPE_p_wxBitmap, obj);
4916 Py_INCREF(obj);
4917 return Py_BuildValue((char *)"");
4918 }
4919 static PyObject *_wrap_new_Mask(PyObject *, PyObject *args, PyObject *kwargs) {
4920 PyObject *resultobj;
4921 wxBitmap *arg1 = 0 ;
4922 wxColour const &arg2_defvalue = wxNullColour ;
4923 wxColour *arg2 = (wxColour *) &arg2_defvalue ;
4924 wxMask *result;
4925 wxColour temp2 ;
4926 PyObject * obj0 = 0 ;
4927 PyObject * obj1 = 0 ;
4928 char *kwnames[] = {
4929 (char *) "bitmap",(char *) "colour", NULL
4930 };
4931
4932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Mask",kwnames,&obj0,&obj1)) goto fail;
4933 {
4934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4935 if (SWIG_arg_fail(1)) SWIG_fail;
4936 if (arg1 == NULL) {
4937 SWIG_null_ref("wxBitmap");
4938 }
4939 if (SWIG_arg_fail(1)) SWIG_fail;
4940 }
4941 if (obj1) {
4942 {
4943 arg2 = &temp2;
4944 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4945 }
4946 }
4947 {
4948 if (!wxPyCheckForApp()) SWIG_fail;
4949 PyThreadState* __tstate = wxPyBeginAllowThreads();
4950 result = (wxMask *)new_wxMask((wxBitmap const &)*arg1,(wxColour const &)*arg2);
4951
4952 wxPyEndAllowThreads(__tstate);
4953 if (PyErr_Occurred()) SWIG_fail;
4954 }
4955 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 1);
4956 return resultobj;
4957 fail:
4958 return NULL;
4959 }
4960
4961
4962 static PyObject * Mask_swigregister(PyObject *, PyObject *args) {
4963 PyObject *obj;
4964 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4965 SWIG_TypeClientData(SWIGTYPE_p_wxMask, obj);
4966 Py_INCREF(obj);
4967 return Py_BuildValue((char *)"");
4968 }
4969 static PyObject *_wrap_new_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
4970 PyObject *resultobj;
4971 wxString *arg1 = 0 ;
4972 wxBitmapType arg2 ;
4973 int arg3 = (int) -1 ;
4974 int arg4 = (int) -1 ;
4975 wxIcon *result;
4976 bool temp1 = false ;
4977 PyObject * obj0 = 0 ;
4978 PyObject * obj1 = 0 ;
4979 PyObject * obj2 = 0 ;
4980 PyObject * obj3 = 0 ;
4981 char *kwnames[] = {
4982 (char *) "name",(char *) "type",(char *) "desiredWidth",(char *) "desiredHeight", NULL
4983 };
4984
4985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Icon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4986 {
4987 arg1 = wxString_in_helper(obj0);
4988 if (arg1 == NULL) SWIG_fail;
4989 temp1 = true;
4990 }
4991 {
4992 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
4993 if (SWIG_arg_fail(2)) SWIG_fail;
4994 }
4995 if (obj2) {
4996 {
4997 arg3 = (int)(SWIG_As_int(obj2));
4998 if (SWIG_arg_fail(3)) SWIG_fail;
4999 }
5000 }
5001 if (obj3) {
5002 {
5003 arg4 = (int)(SWIG_As_int(obj3));
5004 if (SWIG_arg_fail(4)) SWIG_fail;
5005 }
5006 }
5007 {
5008 if (!wxPyCheckForApp()) SWIG_fail;
5009 PyThreadState* __tstate = wxPyBeginAllowThreads();
5010 result = (wxIcon *)new wxIcon((wxString const &)*arg1,(wxBitmapType )arg2,arg3,arg4);
5011
5012 wxPyEndAllowThreads(__tstate);
5013 if (PyErr_Occurred()) SWIG_fail;
5014 }
5015 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5016 {
5017 if (temp1)
5018 delete arg1;
5019 }
5020 return resultobj;
5021 fail:
5022 {
5023 if (temp1)
5024 delete arg1;
5025 }
5026 return NULL;
5027 }
5028
5029
5030 static PyObject *_wrap_delete_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
5031 PyObject *resultobj;
5032 wxIcon *arg1 = (wxIcon *) 0 ;
5033 PyObject * obj0 = 0 ;
5034 char *kwnames[] = {
5035 (char *) "self", NULL
5036 };
5037
5038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Icon",kwnames,&obj0)) goto fail;
5039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5040 if (SWIG_arg_fail(1)) SWIG_fail;
5041 {
5042 PyThreadState* __tstate = wxPyBeginAllowThreads();
5043 delete arg1;
5044
5045 wxPyEndAllowThreads(__tstate);
5046 if (PyErr_Occurred()) SWIG_fail;
5047 }
5048 Py_INCREF(Py_None); resultobj = Py_None;
5049 return resultobj;
5050 fail:
5051 return NULL;
5052 }
5053
5054
5055 static PyObject *_wrap_new_EmptyIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5056 PyObject *resultobj;
5057 wxIcon *result;
5058 char *kwnames[] = {
5059 NULL
5060 };
5061
5062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EmptyIcon",kwnames)) goto fail;
5063 {
5064 if (!wxPyCheckForApp()) SWIG_fail;
5065 PyThreadState* __tstate = wxPyBeginAllowThreads();
5066 result = (wxIcon *)new wxIcon();
5067
5068 wxPyEndAllowThreads(__tstate);
5069 if (PyErr_Occurred()) SWIG_fail;
5070 }
5071 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5072 return resultobj;
5073 fail:
5074 return NULL;
5075 }
5076
5077
5078 static PyObject *_wrap_new_IconFromLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5079 PyObject *resultobj;
5080 wxIconLocation *arg1 = 0 ;
5081 wxIcon *result;
5082 PyObject * obj0 = 0 ;
5083 char *kwnames[] = {
5084 (char *) "loc", NULL
5085 };
5086
5087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromLocation",kwnames,&obj0)) goto fail;
5088 {
5089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5090 if (SWIG_arg_fail(1)) SWIG_fail;
5091 if (arg1 == NULL) {
5092 SWIG_null_ref("wxIconLocation");
5093 }
5094 if (SWIG_arg_fail(1)) SWIG_fail;
5095 }
5096 {
5097 if (!wxPyCheckForApp()) SWIG_fail;
5098 PyThreadState* __tstate = wxPyBeginAllowThreads();
5099 result = (wxIcon *)new wxIcon((wxIconLocation const &)*arg1);
5100
5101 wxPyEndAllowThreads(__tstate);
5102 if (PyErr_Occurred()) SWIG_fail;
5103 }
5104 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5105 return resultobj;
5106 fail:
5107 return NULL;
5108 }
5109
5110
5111 static PyObject *_wrap_new_IconFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5112 PyObject *resultobj;
5113 wxBitmap *arg1 = 0 ;
5114 wxIcon *result;
5115 PyObject * obj0 = 0 ;
5116 char *kwnames[] = {
5117 (char *) "bmp", NULL
5118 };
5119
5120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromBitmap",kwnames,&obj0)) goto fail;
5121 {
5122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5123 if (SWIG_arg_fail(1)) SWIG_fail;
5124 if (arg1 == NULL) {
5125 SWIG_null_ref("wxBitmap");
5126 }
5127 if (SWIG_arg_fail(1)) SWIG_fail;
5128 }
5129 {
5130 if (!wxPyCheckForApp()) SWIG_fail;
5131 PyThreadState* __tstate = wxPyBeginAllowThreads();
5132 result = (wxIcon *)new_wxIcon((wxBitmap const &)*arg1);
5133
5134 wxPyEndAllowThreads(__tstate);
5135 if (PyErr_Occurred()) SWIG_fail;
5136 }
5137 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5138 return resultobj;
5139 fail:
5140 return NULL;
5141 }
5142
5143
5144 static PyObject *_wrap_new_IconFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
5145 PyObject *resultobj;
5146 PyObject *arg1 = (PyObject *) 0 ;
5147 wxIcon *result;
5148 PyObject * obj0 = 0 ;
5149 char *kwnames[] = {
5150 (char *) "listOfStrings", NULL
5151 };
5152
5153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromXPMData",kwnames,&obj0)) goto fail;
5154 arg1 = obj0;
5155 {
5156 if (!wxPyCheckForApp()) SWIG_fail;
5157 PyThreadState* __tstate = wxPyBeginAllowThreads();
5158 result = (wxIcon *)new_wxIcon(arg1);
5159
5160 wxPyEndAllowThreads(__tstate);
5161 if (PyErr_Occurred()) SWIG_fail;
5162 }
5163 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5164 return resultobj;
5165 fail:
5166 return NULL;
5167 }
5168
5169
5170 static PyObject *_wrap_Icon_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
5171 PyObject *resultobj;
5172 wxIcon *arg1 = (wxIcon *) 0 ;
5173 bool result;
5174 PyObject * obj0 = 0 ;
5175 char *kwnames[] = {
5176 (char *) "self", NULL
5177 };
5178
5179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_Ok",kwnames,&obj0)) goto fail;
5180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5181 if (SWIG_arg_fail(1)) SWIG_fail;
5182 {
5183 PyThreadState* __tstate = wxPyBeginAllowThreads();
5184 result = (bool)(arg1)->Ok();
5185
5186 wxPyEndAllowThreads(__tstate);
5187 if (PyErr_Occurred()) SWIG_fail;
5188 }
5189 {
5190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5191 }
5192 return resultobj;
5193 fail:
5194 return NULL;
5195 }
5196
5197
5198 static PyObject *_wrap_Icon_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5199 PyObject *resultobj;
5200 wxIcon *arg1 = (wxIcon *) 0 ;
5201 int result;
5202 PyObject * obj0 = 0 ;
5203 char *kwnames[] = {
5204 (char *) "self", NULL
5205 };
5206
5207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetWidth",kwnames,&obj0)) goto fail;
5208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5209 if (SWIG_arg_fail(1)) SWIG_fail;
5210 {
5211 PyThreadState* __tstate = wxPyBeginAllowThreads();
5212 result = (int)(arg1)->GetWidth();
5213
5214 wxPyEndAllowThreads(__tstate);
5215 if (PyErr_Occurred()) SWIG_fail;
5216 }
5217 {
5218 resultobj = SWIG_From_int((int)(result));
5219 }
5220 return resultobj;
5221 fail:
5222 return NULL;
5223 }
5224
5225
5226 static PyObject *_wrap_Icon_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5227 PyObject *resultobj;
5228 wxIcon *arg1 = (wxIcon *) 0 ;
5229 int result;
5230 PyObject * obj0 = 0 ;
5231 char *kwnames[] = {
5232 (char *) "self", NULL
5233 };
5234
5235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetHeight",kwnames,&obj0)) goto fail;
5236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5237 if (SWIG_arg_fail(1)) SWIG_fail;
5238 {
5239 PyThreadState* __tstate = wxPyBeginAllowThreads();
5240 result = (int)(arg1)->GetHeight();
5241
5242 wxPyEndAllowThreads(__tstate);
5243 if (PyErr_Occurred()) SWIG_fail;
5244 }
5245 {
5246 resultobj = SWIG_From_int((int)(result));
5247 }
5248 return resultobj;
5249 fail:
5250 return NULL;
5251 }
5252
5253
5254 static PyObject *_wrap_Icon_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5255 PyObject *resultobj;
5256 wxIcon *arg1 = (wxIcon *) 0 ;
5257 int result;
5258 PyObject * obj0 = 0 ;
5259 char *kwnames[] = {
5260 (char *) "self", NULL
5261 };
5262
5263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetDepth",kwnames,&obj0)) goto fail;
5264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5265 if (SWIG_arg_fail(1)) SWIG_fail;
5266 {
5267 PyThreadState* __tstate = wxPyBeginAllowThreads();
5268 result = (int)(arg1)->GetDepth();
5269
5270 wxPyEndAllowThreads(__tstate);
5271 if (PyErr_Occurred()) SWIG_fail;
5272 }
5273 {
5274 resultobj = SWIG_From_int((int)(result));
5275 }
5276 return resultobj;
5277 fail:
5278 return NULL;
5279 }
5280
5281
5282 static PyObject *_wrap_Icon_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5283 PyObject *resultobj;
5284 wxIcon *arg1 = (wxIcon *) 0 ;
5285 int arg2 ;
5286 PyObject * obj0 = 0 ;
5287 PyObject * obj1 = 0 ;
5288 char *kwnames[] = {
5289 (char *) "self",(char *) "w", NULL
5290 };
5291
5292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5294 if (SWIG_arg_fail(1)) SWIG_fail;
5295 {
5296 arg2 = (int)(SWIG_As_int(obj1));
5297 if (SWIG_arg_fail(2)) SWIG_fail;
5298 }
5299 {
5300 PyThreadState* __tstate = wxPyBeginAllowThreads();
5301 (arg1)->SetWidth(arg2);
5302
5303 wxPyEndAllowThreads(__tstate);
5304 if (PyErr_Occurred()) SWIG_fail;
5305 }
5306 Py_INCREF(Py_None); resultobj = Py_None;
5307 return resultobj;
5308 fail:
5309 return NULL;
5310 }
5311
5312
5313 static PyObject *_wrap_Icon_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5314 PyObject *resultobj;
5315 wxIcon *arg1 = (wxIcon *) 0 ;
5316 int arg2 ;
5317 PyObject * obj0 = 0 ;
5318 PyObject * obj1 = 0 ;
5319 char *kwnames[] = {
5320 (char *) "self",(char *) "h", NULL
5321 };
5322
5323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5325 if (SWIG_arg_fail(1)) SWIG_fail;
5326 {
5327 arg2 = (int)(SWIG_As_int(obj1));
5328 if (SWIG_arg_fail(2)) SWIG_fail;
5329 }
5330 {
5331 PyThreadState* __tstate = wxPyBeginAllowThreads();
5332 (arg1)->SetHeight(arg2);
5333
5334 wxPyEndAllowThreads(__tstate);
5335 if (PyErr_Occurred()) SWIG_fail;
5336 }
5337 Py_INCREF(Py_None); resultobj = Py_None;
5338 return resultobj;
5339 fail:
5340 return NULL;
5341 }
5342
5343
5344 static PyObject *_wrap_Icon_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5345 PyObject *resultobj;
5346 wxIcon *arg1 = (wxIcon *) 0 ;
5347 int arg2 ;
5348 PyObject * obj0 = 0 ;
5349 PyObject * obj1 = 0 ;
5350 char *kwnames[] = {
5351 (char *) "self",(char *) "d", NULL
5352 };
5353
5354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetDepth",kwnames,&obj0,&obj1)) goto fail;
5355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5356 if (SWIG_arg_fail(1)) SWIG_fail;
5357 {
5358 arg2 = (int)(SWIG_As_int(obj1));
5359 if (SWIG_arg_fail(2)) SWIG_fail;
5360 }
5361 {
5362 PyThreadState* __tstate = wxPyBeginAllowThreads();
5363 (arg1)->SetDepth(arg2);
5364
5365 wxPyEndAllowThreads(__tstate);
5366 if (PyErr_Occurred()) SWIG_fail;
5367 }
5368 Py_INCREF(Py_None); resultobj = Py_None;
5369 return resultobj;
5370 fail:
5371 return NULL;
5372 }
5373
5374
5375 static PyObject *_wrap_Icon_CopyFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5376 PyObject *resultobj;
5377 wxIcon *arg1 = (wxIcon *) 0 ;
5378 wxBitmap *arg2 = 0 ;
5379 PyObject * obj0 = 0 ;
5380 PyObject * obj1 = 0 ;
5381 char *kwnames[] = {
5382 (char *) "self",(char *) "bmp", NULL
5383 };
5384
5385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_CopyFromBitmap",kwnames,&obj0,&obj1)) goto fail;
5386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5387 if (SWIG_arg_fail(1)) SWIG_fail;
5388 {
5389 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5390 if (SWIG_arg_fail(2)) SWIG_fail;
5391 if (arg2 == NULL) {
5392 SWIG_null_ref("wxBitmap");
5393 }
5394 if (SWIG_arg_fail(2)) SWIG_fail;
5395 }
5396 {
5397 PyThreadState* __tstate = wxPyBeginAllowThreads();
5398 (arg1)->CopyFromBitmap((wxBitmap const &)*arg2);
5399
5400 wxPyEndAllowThreads(__tstate);
5401 if (PyErr_Occurred()) SWIG_fail;
5402 }
5403 Py_INCREF(Py_None); resultobj = Py_None;
5404 return resultobj;
5405 fail:
5406 return NULL;
5407 }
5408
5409
5410 static PyObject * Icon_swigregister(PyObject *, PyObject *args) {
5411 PyObject *obj;
5412 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5413 SWIG_TypeClientData(SWIGTYPE_p_wxIcon, obj);
5414 Py_INCREF(obj);
5415 return Py_BuildValue((char *)"");
5416 }
5417 static PyObject *_wrap_new_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5418 PyObject *resultobj;
5419 wxString *arg1 = (wxString *) &wxPyEmptyString ;
5420 int arg2 = (int) 0 ;
5421 wxIconLocation *result;
5422 bool temp1 = false ;
5423 PyObject * obj0 = 0 ;
5424 PyObject * obj1 = 0 ;
5425 char *kwnames[] = {
5426 (char *) "filename",(char *) "num", NULL
5427 };
5428
5429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconLocation",kwnames,&obj0,&obj1)) goto fail;
5430 if (obj0) {
5431 {
5432 arg1 = wxString_in_helper(obj0);
5433 if (arg1 == NULL) SWIG_fail;
5434 temp1 = true;
5435 }
5436 }
5437 if (obj1) {
5438 {
5439 arg2 = (int)(SWIG_As_int(obj1));
5440 if (SWIG_arg_fail(2)) SWIG_fail;
5441 }
5442 }
5443 {
5444 PyThreadState* __tstate = wxPyBeginAllowThreads();
5445 result = (wxIconLocation *)new_wxIconLocation((wxString const *)arg1,arg2);
5446
5447 wxPyEndAllowThreads(__tstate);
5448 if (PyErr_Occurred()) SWIG_fail;
5449 }
5450 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconLocation, 1);
5451 {
5452 if (temp1)
5453 delete arg1;
5454 }
5455 return resultobj;
5456 fail:
5457 {
5458 if (temp1)
5459 delete arg1;
5460 }
5461 return NULL;
5462 }
5463
5464
5465 static PyObject *_wrap_delete_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5466 PyObject *resultobj;
5467 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5468 PyObject * obj0 = 0 ;
5469 char *kwnames[] = {
5470 (char *) "self", NULL
5471 };
5472
5473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconLocation",kwnames,&obj0)) goto fail;
5474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5475 if (SWIG_arg_fail(1)) SWIG_fail;
5476 {
5477 PyThreadState* __tstate = wxPyBeginAllowThreads();
5478 delete arg1;
5479
5480 wxPyEndAllowThreads(__tstate);
5481 if (PyErr_Occurred()) SWIG_fail;
5482 }
5483 Py_INCREF(Py_None); resultobj = Py_None;
5484 return resultobj;
5485 fail:
5486 return NULL;
5487 }
5488
5489
5490 static PyObject *_wrap_IconLocation_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
5491 PyObject *resultobj;
5492 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5493 bool result;
5494 PyObject * obj0 = 0 ;
5495 char *kwnames[] = {
5496 (char *) "self", NULL
5497 };
5498
5499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_IsOk",kwnames,&obj0)) goto fail;
5500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5501 if (SWIG_arg_fail(1)) SWIG_fail;
5502 {
5503 PyThreadState* __tstate = wxPyBeginAllowThreads();
5504 result = (bool)((wxIconLocation const *)arg1)->IsOk();
5505
5506 wxPyEndAllowThreads(__tstate);
5507 if (PyErr_Occurred()) SWIG_fail;
5508 }
5509 {
5510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5511 }
5512 return resultobj;
5513 fail:
5514 return NULL;
5515 }
5516
5517
5518 static PyObject *_wrap_IconLocation_SetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5519 PyObject *resultobj;
5520 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5521 wxString *arg2 = 0 ;
5522 bool temp2 = false ;
5523 PyObject * obj0 = 0 ;
5524 PyObject * obj1 = 0 ;
5525 char *kwnames[] = {
5526 (char *) "self",(char *) "filename", NULL
5527 };
5528
5529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetFileName",kwnames,&obj0,&obj1)) goto fail;
5530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5531 if (SWIG_arg_fail(1)) SWIG_fail;
5532 {
5533 arg2 = wxString_in_helper(obj1);
5534 if (arg2 == NULL) SWIG_fail;
5535 temp2 = true;
5536 }
5537 {
5538 PyThreadState* __tstate = wxPyBeginAllowThreads();
5539 (arg1)->SetFileName((wxString const &)*arg2);
5540
5541 wxPyEndAllowThreads(__tstate);
5542 if (PyErr_Occurred()) SWIG_fail;
5543 }
5544 Py_INCREF(Py_None); resultobj = Py_None;
5545 {
5546 if (temp2)
5547 delete arg2;
5548 }
5549 return resultobj;
5550 fail:
5551 {
5552 if (temp2)
5553 delete arg2;
5554 }
5555 return NULL;
5556 }
5557
5558
5559 static PyObject *_wrap_IconLocation_GetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5560 PyObject *resultobj;
5561 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5562 wxString *result;
5563 PyObject * obj0 = 0 ;
5564 char *kwnames[] = {
5565 (char *) "self", NULL
5566 };
5567
5568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetFileName",kwnames,&obj0)) goto fail;
5569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5570 if (SWIG_arg_fail(1)) SWIG_fail;
5571 {
5572 PyThreadState* __tstate = wxPyBeginAllowThreads();
5573 {
5574 wxString const &_result_ref = ((wxIconLocation const *)arg1)->GetFileName();
5575 result = (wxString *) &_result_ref;
5576 }
5577
5578 wxPyEndAllowThreads(__tstate);
5579 if (PyErr_Occurred()) SWIG_fail;
5580 }
5581 {
5582 #if wxUSE_UNICODE
5583 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
5584 #else
5585 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
5586 #endif
5587 }
5588 return resultobj;
5589 fail:
5590 return NULL;
5591 }
5592
5593
5594 static PyObject *_wrap_IconLocation_SetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5595 PyObject *resultobj;
5596 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5597 int arg2 ;
5598 PyObject * obj0 = 0 ;
5599 PyObject * obj1 = 0 ;
5600 char *kwnames[] = {
5601 (char *) "self",(char *) "num", NULL
5602 };
5603
5604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetIndex",kwnames,&obj0,&obj1)) goto fail;
5605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5606 if (SWIG_arg_fail(1)) SWIG_fail;
5607 {
5608 arg2 = (int)(SWIG_As_int(obj1));
5609 if (SWIG_arg_fail(2)) SWIG_fail;
5610 }
5611 {
5612 PyThreadState* __tstate = wxPyBeginAllowThreads();
5613 wxIconLocation_SetIndex(arg1,arg2);
5614
5615 wxPyEndAllowThreads(__tstate);
5616 if (PyErr_Occurred()) SWIG_fail;
5617 }
5618 Py_INCREF(Py_None); resultobj = Py_None;
5619 return resultobj;
5620 fail:
5621 return NULL;
5622 }
5623
5624
5625 static PyObject *_wrap_IconLocation_GetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5626 PyObject *resultobj;
5627 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5628 int result;
5629 PyObject * obj0 = 0 ;
5630 char *kwnames[] = {
5631 (char *) "self", NULL
5632 };
5633
5634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetIndex",kwnames,&obj0)) goto fail;
5635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5636 if (SWIG_arg_fail(1)) SWIG_fail;
5637 {
5638 PyThreadState* __tstate = wxPyBeginAllowThreads();
5639 result = (int)wxIconLocation_GetIndex(arg1);
5640
5641 wxPyEndAllowThreads(__tstate);
5642 if (PyErr_Occurred()) SWIG_fail;
5643 }
5644 {
5645 resultobj = SWIG_From_int((int)(result));
5646 }
5647 return resultobj;
5648 fail:
5649 return NULL;
5650 }
5651
5652
5653 static PyObject * IconLocation_swigregister(PyObject *, PyObject *args) {
5654 PyObject *obj;
5655 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5656 SWIG_TypeClientData(SWIGTYPE_p_wxIconLocation, obj);
5657 Py_INCREF(obj);
5658 return Py_BuildValue((char *)"");
5659 }
5660 static PyObject *_wrap_new_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
5661 PyObject *resultobj;
5662 wxIconBundle *result;
5663 char *kwnames[] = {
5664 NULL
5665 };
5666
5667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IconBundle",kwnames)) goto fail;
5668 {
5669 PyThreadState* __tstate = wxPyBeginAllowThreads();
5670 result = (wxIconBundle *)new wxIconBundle();
5671
5672 wxPyEndAllowThreads(__tstate);
5673 if (PyErr_Occurred()) SWIG_fail;
5674 }
5675 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5676 return resultobj;
5677 fail:
5678 return NULL;
5679 }
5680
5681
5682 static PyObject *_wrap_new_IconBundleFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
5683 PyObject *resultobj;
5684 wxString *arg1 = 0 ;
5685 long arg2 ;
5686 wxIconBundle *result;
5687 bool temp1 = false ;
5688 PyObject * obj0 = 0 ;
5689 PyObject * obj1 = 0 ;
5690 char *kwnames[] = {
5691 (char *) "file",(char *) "type", NULL
5692 };
5693
5694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_IconBundleFromFile",kwnames,&obj0,&obj1)) goto fail;
5695 {
5696 arg1 = wxString_in_helper(obj0);
5697 if (arg1 == NULL) SWIG_fail;
5698 temp1 = true;
5699 }
5700 {
5701 arg2 = (long)(SWIG_As_long(obj1));
5702 if (SWIG_arg_fail(2)) SWIG_fail;
5703 }
5704 {
5705 PyThreadState* __tstate = wxPyBeginAllowThreads();
5706 result = (wxIconBundle *)new wxIconBundle((wxString const &)*arg1,arg2);
5707
5708 wxPyEndAllowThreads(__tstate);
5709 if (PyErr_Occurred()) SWIG_fail;
5710 }
5711 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5712 {
5713 if (temp1)
5714 delete arg1;
5715 }
5716 return resultobj;
5717 fail:
5718 {
5719 if (temp1)
5720 delete arg1;
5721 }
5722 return NULL;
5723 }
5724
5725
5726 static PyObject *_wrap_new_IconBundleFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5727 PyObject *resultobj;
5728 wxIcon *arg1 = 0 ;
5729 wxIconBundle *result;
5730 PyObject * obj0 = 0 ;
5731 char *kwnames[] = {
5732 (char *) "icon", NULL
5733 };
5734
5735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconBundleFromIcon",kwnames,&obj0)) goto fail;
5736 {
5737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5738 if (SWIG_arg_fail(1)) SWIG_fail;
5739 if (arg1 == NULL) {
5740 SWIG_null_ref("wxIcon");
5741 }
5742 if (SWIG_arg_fail(1)) SWIG_fail;
5743 }
5744 {
5745 PyThreadState* __tstate = wxPyBeginAllowThreads();
5746 result = (wxIconBundle *)new wxIconBundle((wxIcon const &)*arg1);
5747
5748 wxPyEndAllowThreads(__tstate);
5749 if (PyErr_Occurred()) SWIG_fail;
5750 }
5751 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5752 return resultobj;
5753 fail:
5754 return NULL;
5755 }
5756
5757
5758 static PyObject *_wrap_delete_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
5759 PyObject *resultobj;
5760 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5761 PyObject * obj0 = 0 ;
5762 char *kwnames[] = {
5763 (char *) "self", NULL
5764 };
5765
5766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconBundle",kwnames,&obj0)) goto fail;
5767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5768 if (SWIG_arg_fail(1)) SWIG_fail;
5769 {
5770 PyThreadState* __tstate = wxPyBeginAllowThreads();
5771 delete arg1;
5772
5773 wxPyEndAllowThreads(__tstate);
5774 if (PyErr_Occurred()) SWIG_fail;
5775 }
5776 Py_INCREF(Py_None); resultobj = Py_None;
5777 return resultobj;
5778 fail:
5779 return NULL;
5780 }
5781
5782
5783 static PyObject *_wrap_IconBundle_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5784 PyObject *resultobj;
5785 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5786 wxIcon *arg2 = 0 ;
5787 PyObject * obj0 = 0 ;
5788 PyObject * obj1 = 0 ;
5789 char *kwnames[] = {
5790 (char *) "self",(char *) "icon", NULL
5791 };
5792
5793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_AddIcon",kwnames,&obj0,&obj1)) goto fail;
5794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5795 if (SWIG_arg_fail(1)) SWIG_fail;
5796 {
5797 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5798 if (SWIG_arg_fail(2)) SWIG_fail;
5799 if (arg2 == NULL) {
5800 SWIG_null_ref("wxIcon");
5801 }
5802 if (SWIG_arg_fail(2)) SWIG_fail;
5803 }
5804 {
5805 PyThreadState* __tstate = wxPyBeginAllowThreads();
5806 (arg1)->AddIcon((wxIcon const &)*arg2);
5807
5808 wxPyEndAllowThreads(__tstate);
5809 if (PyErr_Occurred()) SWIG_fail;
5810 }
5811 Py_INCREF(Py_None); resultobj = Py_None;
5812 return resultobj;
5813 fail:
5814 return NULL;
5815 }
5816
5817
5818 static PyObject *_wrap_IconBundle_AddIconFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
5819 PyObject *resultobj;
5820 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5821 wxString *arg2 = 0 ;
5822 long arg3 ;
5823 bool temp2 = false ;
5824 PyObject * obj0 = 0 ;
5825 PyObject * obj1 = 0 ;
5826 PyObject * obj2 = 0 ;
5827 char *kwnames[] = {
5828 (char *) "self",(char *) "file",(char *) "type", NULL
5829 };
5830
5831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IconBundle_AddIconFromFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
5832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5833 if (SWIG_arg_fail(1)) SWIG_fail;
5834 {
5835 arg2 = wxString_in_helper(obj1);
5836 if (arg2 == NULL) SWIG_fail;
5837 temp2 = true;
5838 }
5839 {
5840 arg3 = (long)(SWIG_As_long(obj2));
5841 if (SWIG_arg_fail(3)) SWIG_fail;
5842 }
5843 {
5844 PyThreadState* __tstate = wxPyBeginAllowThreads();
5845 (arg1)->AddIcon((wxString const &)*arg2,arg3);
5846
5847 wxPyEndAllowThreads(__tstate);
5848 if (PyErr_Occurred()) SWIG_fail;
5849 }
5850 Py_INCREF(Py_None); resultobj = Py_None;
5851 {
5852 if (temp2)
5853 delete arg2;
5854 }
5855 return resultobj;
5856 fail:
5857 {
5858 if (temp2)
5859 delete arg2;
5860 }
5861 return NULL;
5862 }
5863
5864
5865 static PyObject *_wrap_IconBundle_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5866 PyObject *resultobj;
5867 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5868 wxSize *arg2 = 0 ;
5869 wxIcon *result;
5870 wxSize temp2 ;
5871 PyObject * obj0 = 0 ;
5872 PyObject * obj1 = 0 ;
5873 char *kwnames[] = {
5874 (char *) "self",(char *) "size", NULL
5875 };
5876
5877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_GetIcon",kwnames,&obj0,&obj1)) goto fail;
5878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5879 if (SWIG_arg_fail(1)) SWIG_fail;
5880 {
5881 arg2 = &temp2;
5882 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5883 }
5884 {
5885 PyThreadState* __tstate = wxPyBeginAllowThreads();
5886 {
5887 wxIcon const &_result_ref = ((wxIconBundle const *)arg1)->GetIcon((wxSize const &)*arg2);
5888 result = (wxIcon *) &_result_ref;
5889 }
5890
5891 wxPyEndAllowThreads(__tstate);
5892 if (PyErr_Occurred()) SWIG_fail;
5893 }
5894 {
5895 wxIcon* resultptr = new wxIcon(*result);
5896 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxIcon, 1);
5897 }
5898 return resultobj;
5899 fail:
5900 return NULL;
5901 }
5902
5903
5904 static PyObject * IconBundle_swigregister(PyObject *, PyObject *args) {
5905 PyObject *obj;
5906 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5907 SWIG_TypeClientData(SWIGTYPE_p_wxIconBundle, obj);
5908 Py_INCREF(obj);
5909 return Py_BuildValue((char *)"");
5910 }
5911 static PyObject *_wrap_new_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
5912 PyObject *resultobj;
5913 wxString *arg1 = 0 ;
5914 long arg2 ;
5915 int arg3 = (int) 0 ;
5916 int arg4 = (int) 0 ;
5917 wxCursor *result;
5918 bool temp1 = false ;
5919 PyObject * obj0 = 0 ;
5920 PyObject * obj1 = 0 ;
5921 PyObject * obj2 = 0 ;
5922 PyObject * obj3 = 0 ;
5923 char *kwnames[] = {
5924 (char *) "cursorName",(char *) "type",(char *) "hotSpotX",(char *) "hotSpotY", NULL
5925 };
5926
5927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Cursor",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5928 {
5929 arg1 = wxString_in_helper(obj0);
5930 if (arg1 == NULL) SWIG_fail;
5931 temp1 = true;
5932 }
5933 {
5934 arg2 = (long)(SWIG_As_long(obj1));
5935 if (SWIG_arg_fail(2)) SWIG_fail;
5936 }
5937 if (obj2) {
5938 {
5939 arg3 = (int)(SWIG_As_int(obj2));
5940 if (SWIG_arg_fail(3)) SWIG_fail;
5941 }
5942 }
5943 if (obj3) {
5944 {
5945 arg4 = (int)(SWIG_As_int(obj3));
5946 if (SWIG_arg_fail(4)) SWIG_fail;
5947 }
5948 }
5949 {
5950 if (!wxPyCheckForApp()) SWIG_fail;
5951 PyThreadState* __tstate = wxPyBeginAllowThreads();
5952 result = (wxCursor *)new_wxCursor((wxString const &)*arg1,arg2,arg3,arg4);
5953
5954 wxPyEndAllowThreads(__tstate);
5955 if (PyErr_Occurred()) SWIG_fail;
5956 }
5957 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
5958 {
5959 if (temp1)
5960 delete arg1;
5961 }
5962 return resultobj;
5963 fail:
5964 {
5965 if (temp1)
5966 delete arg1;
5967 }
5968 return NULL;
5969 }
5970
5971
5972 static PyObject *_wrap_delete_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
5973 PyObject *resultobj;
5974 wxCursor *arg1 = (wxCursor *) 0 ;
5975 PyObject * obj0 = 0 ;
5976 char *kwnames[] = {
5977 (char *) "self", NULL
5978 };
5979
5980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Cursor",kwnames,&obj0)) goto fail;
5981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5982 if (SWIG_arg_fail(1)) SWIG_fail;
5983 {
5984 PyThreadState* __tstate = wxPyBeginAllowThreads();
5985 delete arg1;
5986
5987 wxPyEndAllowThreads(__tstate);
5988 if (PyErr_Occurred()) SWIG_fail;
5989 }
5990 Py_INCREF(Py_None); resultobj = Py_None;
5991 return resultobj;
5992 fail:
5993 return NULL;
5994 }
5995
5996
5997 static PyObject *_wrap_new_StockCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5998 PyObject *resultobj;
5999 int arg1 ;
6000 wxCursor *result;
6001 PyObject * obj0 = 0 ;
6002 char *kwnames[] = {
6003 (char *) "id", NULL
6004 };
6005
6006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_StockCursor",kwnames,&obj0)) goto fail;
6007 {
6008 arg1 = (int)(SWIG_As_int(obj0));
6009 if (SWIG_arg_fail(1)) SWIG_fail;
6010 }
6011 {
6012 if (!wxPyCheckForApp()) SWIG_fail;
6013 PyThreadState* __tstate = wxPyBeginAllowThreads();
6014 result = (wxCursor *)new wxCursor(arg1);
6015
6016 wxPyEndAllowThreads(__tstate);
6017 if (PyErr_Occurred()) SWIG_fail;
6018 }
6019 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6020 return resultobj;
6021 fail:
6022 return NULL;
6023 }
6024
6025
6026 static PyObject *_wrap_new_CursorFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
6027 PyObject *resultobj;
6028 wxImage *arg1 = 0 ;
6029 wxCursor *result;
6030 PyObject * obj0 = 0 ;
6031 char *kwnames[] = {
6032 (char *) "image", NULL
6033 };
6034
6035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CursorFromImage",kwnames,&obj0)) goto fail;
6036 {
6037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
6038 if (SWIG_arg_fail(1)) SWIG_fail;
6039 if (arg1 == NULL) {
6040 SWIG_null_ref("wxImage");
6041 }
6042 if (SWIG_arg_fail(1)) SWIG_fail;
6043 }
6044 {
6045 if (!wxPyCheckForApp()) SWIG_fail;
6046 PyThreadState* __tstate = wxPyBeginAllowThreads();
6047 result = (wxCursor *)new wxCursor((wxImage const &)*arg1);
6048
6049 wxPyEndAllowThreads(__tstate);
6050 if (PyErr_Occurred()) SWIG_fail;
6051 }
6052 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6053 return resultobj;
6054 fail:
6055 return NULL;
6056 }
6057
6058
6059 static PyObject *_wrap_Cursor_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
6060 PyObject *resultobj;
6061 wxCursor *arg1 = (wxCursor *) 0 ;
6062 bool result;
6063 PyObject * obj0 = 0 ;
6064 char *kwnames[] = {
6065 (char *) "self", NULL
6066 };
6067
6068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_Ok",kwnames,&obj0)) goto fail;
6069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6070 if (SWIG_arg_fail(1)) SWIG_fail;
6071 {
6072 PyThreadState* __tstate = wxPyBeginAllowThreads();
6073 result = (bool)(arg1)->Ok();
6074
6075 wxPyEndAllowThreads(__tstate);
6076 if (PyErr_Occurred()) SWIG_fail;
6077 }
6078 {
6079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6080 }
6081 return resultobj;
6082 fail:
6083 return NULL;
6084 }
6085
6086
6087 static PyObject * Cursor_swigregister(PyObject *, PyObject *args) {
6088 PyObject *obj;
6089 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6090 SWIG_TypeClientData(SWIGTYPE_p_wxCursor, obj);
6091 Py_INCREF(obj);
6092 return Py_BuildValue((char *)"");
6093 }
6094 static PyObject *_wrap_new_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6095 PyObject *resultobj;
6096 int arg1 = (int) 0 ;
6097 int arg2 = (int) 0 ;
6098 int arg3 = (int) 0 ;
6099 int arg4 = (int) 0 ;
6100 wxRegion *result;
6101 PyObject * obj0 = 0 ;
6102 PyObject * obj1 = 0 ;
6103 PyObject * obj2 = 0 ;
6104 PyObject * obj3 = 0 ;
6105 char *kwnames[] = {
6106 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6107 };
6108
6109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Region",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6110 if (obj0) {
6111 {
6112 arg1 = (int)(SWIG_As_int(obj0));
6113 if (SWIG_arg_fail(1)) SWIG_fail;
6114 }
6115 }
6116 if (obj1) {
6117 {
6118 arg2 = (int)(SWIG_As_int(obj1));
6119 if (SWIG_arg_fail(2)) SWIG_fail;
6120 }
6121 }
6122 if (obj2) {
6123 {
6124 arg3 = (int)(SWIG_As_int(obj2));
6125 if (SWIG_arg_fail(3)) SWIG_fail;
6126 }
6127 }
6128 if (obj3) {
6129 {
6130 arg4 = (int)(SWIG_As_int(obj3));
6131 if (SWIG_arg_fail(4)) SWIG_fail;
6132 }
6133 }
6134 {
6135 if (!wxPyCheckForApp()) SWIG_fail;
6136 PyThreadState* __tstate = wxPyBeginAllowThreads();
6137 result = (wxRegion *)new wxRegion(arg1,arg2,arg3,arg4);
6138
6139 wxPyEndAllowThreads(__tstate);
6140 if (PyErr_Occurred()) SWIG_fail;
6141 }
6142 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6143 return resultobj;
6144 fail:
6145 return NULL;
6146 }
6147
6148
6149 static PyObject *_wrap_new_RegionFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
6150 PyObject *resultobj;
6151 wxBitmap *arg1 = 0 ;
6152 wxRegion *result;
6153 PyObject * obj0 = 0 ;
6154 char *kwnames[] = {
6155 (char *) "bmp", NULL
6156 };
6157
6158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionFromBitmap",kwnames,&obj0)) goto fail;
6159 {
6160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6161 if (SWIG_arg_fail(1)) SWIG_fail;
6162 if (arg1 == NULL) {
6163 SWIG_null_ref("wxBitmap");
6164 }
6165 if (SWIG_arg_fail(1)) SWIG_fail;
6166 }
6167 {
6168 if (!wxPyCheckForApp()) SWIG_fail;
6169 PyThreadState* __tstate = wxPyBeginAllowThreads();
6170 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1);
6171
6172 wxPyEndAllowThreads(__tstate);
6173 if (PyErr_Occurred()) SWIG_fail;
6174 }
6175 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6176 return resultobj;
6177 fail:
6178 return NULL;
6179 }
6180
6181
6182 static PyObject *_wrap_new_RegionFromBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
6183 PyObject *resultobj;
6184 wxBitmap *arg1 = 0 ;
6185 wxColour *arg2 = 0 ;
6186 int arg3 = (int) 0 ;
6187 wxRegion *result;
6188 wxColour temp2 ;
6189 PyObject * obj0 = 0 ;
6190 PyObject * obj1 = 0 ;
6191 PyObject * obj2 = 0 ;
6192 char *kwnames[] = {
6193 (char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
6194 };
6195
6196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_RegionFromBitmapColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
6197 {
6198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6199 if (SWIG_arg_fail(1)) SWIG_fail;
6200 if (arg1 == NULL) {
6201 SWIG_null_ref("wxBitmap");
6202 }
6203 if (SWIG_arg_fail(1)) SWIG_fail;
6204 }
6205 {
6206 arg2 = &temp2;
6207 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6208 }
6209 if (obj2) {
6210 {
6211 arg3 = (int)(SWIG_As_int(obj2));
6212 if (SWIG_arg_fail(3)) SWIG_fail;
6213 }
6214 }
6215 {
6216 if (!wxPyCheckForApp()) SWIG_fail;
6217 PyThreadState* __tstate = wxPyBeginAllowThreads();
6218 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1,(wxColour const &)*arg2,arg3);
6219
6220 wxPyEndAllowThreads(__tstate);
6221 if (PyErr_Occurred()) SWIG_fail;
6222 }
6223 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6224 return resultobj;
6225 fail:
6226 return NULL;
6227 }
6228
6229
6230 static PyObject *_wrap_new_RegionFromPoints(PyObject *, PyObject *args, PyObject *kwargs) {
6231 PyObject *resultobj;
6232 int arg1 ;
6233 wxPoint *arg2 = (wxPoint *) 0 ;
6234 int arg3 = (int) wxWINDING_RULE ;
6235 wxRegion *result;
6236 PyObject * obj0 = 0 ;
6237 PyObject * obj1 = 0 ;
6238 char *kwnames[] = {
6239 (char *) "points",(char *) "fillStyle", NULL
6240 };
6241
6242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_RegionFromPoints",kwnames,&obj0,&obj1)) goto fail;
6243 {
6244 arg2 = wxPoint_LIST_helper(obj0, &arg1);
6245 if (arg2 == NULL) SWIG_fail;
6246 }
6247 if (obj1) {
6248 {
6249 arg3 = (int)(SWIG_As_int(obj1));
6250 if (SWIG_arg_fail(3)) SWIG_fail;
6251 }
6252 }
6253 {
6254 if (!wxPyCheckForApp()) SWIG_fail;
6255 PyThreadState* __tstate = wxPyBeginAllowThreads();
6256 result = (wxRegion *)new wxRegion(arg1,arg2,arg3);
6257
6258 wxPyEndAllowThreads(__tstate);
6259 if (PyErr_Occurred()) SWIG_fail;
6260 }
6261 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6262 {
6263 if (arg2) delete [] arg2;
6264 }
6265 return resultobj;
6266 fail:
6267 {
6268 if (arg2) delete [] arg2;
6269 }
6270 return NULL;
6271 }
6272
6273
6274 static PyObject *_wrap_delete_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6275 PyObject *resultobj;
6276 wxRegion *arg1 = (wxRegion *) 0 ;
6277 PyObject * obj0 = 0 ;
6278 char *kwnames[] = {
6279 (char *) "self", NULL
6280 };
6281
6282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Region",kwnames,&obj0)) goto fail;
6283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6284 if (SWIG_arg_fail(1)) SWIG_fail;
6285 {
6286 PyThreadState* __tstate = wxPyBeginAllowThreads();
6287 delete arg1;
6288
6289 wxPyEndAllowThreads(__tstate);
6290 if (PyErr_Occurred()) SWIG_fail;
6291 }
6292 Py_INCREF(Py_None); resultobj = Py_None;
6293 return resultobj;
6294 fail:
6295 return NULL;
6296 }
6297
6298
6299 static PyObject *_wrap_Region_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
6300 PyObject *resultobj;
6301 wxRegion *arg1 = (wxRegion *) 0 ;
6302 PyObject * obj0 = 0 ;
6303 char *kwnames[] = {
6304 (char *) "self", NULL
6305 };
6306
6307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_Clear",kwnames,&obj0)) goto fail;
6308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6309 if (SWIG_arg_fail(1)) SWIG_fail;
6310 {
6311 PyThreadState* __tstate = wxPyBeginAllowThreads();
6312 (arg1)->Clear();
6313
6314 wxPyEndAllowThreads(__tstate);
6315 if (PyErr_Occurred()) SWIG_fail;
6316 }
6317 Py_INCREF(Py_None); resultobj = Py_None;
6318 return resultobj;
6319 fail:
6320 return NULL;
6321 }
6322
6323
6324 static PyObject *_wrap_Region_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
6325 PyObject *resultobj;
6326 wxRegion *arg1 = (wxRegion *) 0 ;
6327 int arg2 ;
6328 int arg3 ;
6329 bool result;
6330 PyObject * obj0 = 0 ;
6331 PyObject * obj1 = 0 ;
6332 PyObject * obj2 = 0 ;
6333 char *kwnames[] = {
6334 (char *) "self",(char *) "x",(char *) "y", NULL
6335 };
6336
6337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Offset",kwnames,&obj0,&obj1,&obj2)) goto fail;
6338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6339 if (SWIG_arg_fail(1)) SWIG_fail;
6340 {
6341 arg2 = (int)(SWIG_As_int(obj1));
6342 if (SWIG_arg_fail(2)) SWIG_fail;
6343 }
6344 {
6345 arg3 = (int)(SWIG_As_int(obj2));
6346 if (SWIG_arg_fail(3)) SWIG_fail;
6347 }
6348 {
6349 PyThreadState* __tstate = wxPyBeginAllowThreads();
6350 result = (bool)(arg1)->Offset(arg2,arg3);
6351
6352 wxPyEndAllowThreads(__tstate);
6353 if (PyErr_Occurred()) SWIG_fail;
6354 }
6355 {
6356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6357 }
6358 return resultobj;
6359 fail:
6360 return NULL;
6361 }
6362
6363
6364 static PyObject *_wrap_Region_Contains(PyObject *, PyObject *args, PyObject *kwargs) {
6365 PyObject *resultobj;
6366 wxRegion *arg1 = (wxRegion *) 0 ;
6367 int arg2 ;
6368 int arg3 ;
6369 wxRegionContain result;
6370 PyObject * obj0 = 0 ;
6371 PyObject * obj1 = 0 ;
6372 PyObject * obj2 = 0 ;
6373 char *kwnames[] = {
6374 (char *) "self",(char *) "x",(char *) "y", NULL
6375 };
6376
6377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Contains",kwnames,&obj0,&obj1,&obj2)) goto fail;
6378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6379 if (SWIG_arg_fail(1)) SWIG_fail;
6380 {
6381 arg2 = (int)(SWIG_As_int(obj1));
6382 if (SWIG_arg_fail(2)) SWIG_fail;
6383 }
6384 {
6385 arg3 = (int)(SWIG_As_int(obj2));
6386 if (SWIG_arg_fail(3)) SWIG_fail;
6387 }
6388 {
6389 PyThreadState* __tstate = wxPyBeginAllowThreads();
6390 result = (wxRegionContain)(arg1)->Contains(arg2,arg3);
6391
6392 wxPyEndAllowThreads(__tstate);
6393 if (PyErr_Occurred()) SWIG_fail;
6394 }
6395 resultobj = SWIG_From_int((result));
6396 return resultobj;
6397 fail:
6398 return NULL;
6399 }
6400
6401
6402 static PyObject *_wrap_Region_ContainsPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6403 PyObject *resultobj;
6404 wxRegion *arg1 = (wxRegion *) 0 ;
6405 wxPoint *arg2 = 0 ;
6406 wxRegionContain result;
6407 wxPoint temp2 ;
6408 PyObject * obj0 = 0 ;
6409 PyObject * obj1 = 0 ;
6410 char *kwnames[] = {
6411 (char *) "self",(char *) "pt", NULL
6412 };
6413
6414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsPoint",kwnames,&obj0,&obj1)) goto fail;
6415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6416 if (SWIG_arg_fail(1)) SWIG_fail;
6417 {
6418 arg2 = &temp2;
6419 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6420 }
6421 {
6422 PyThreadState* __tstate = wxPyBeginAllowThreads();
6423 result = (wxRegionContain)(arg1)->Contains((wxPoint const &)*arg2);
6424
6425 wxPyEndAllowThreads(__tstate);
6426 if (PyErr_Occurred()) SWIG_fail;
6427 }
6428 resultobj = SWIG_From_int((result));
6429 return resultobj;
6430 fail:
6431 return NULL;
6432 }
6433
6434
6435 static PyObject *_wrap_Region_ContainsRect(PyObject *, PyObject *args, PyObject *kwargs) {
6436 PyObject *resultobj;
6437 wxRegion *arg1 = (wxRegion *) 0 ;
6438 wxRect *arg2 = 0 ;
6439 wxRegionContain result;
6440 wxRect temp2 ;
6441 PyObject * obj0 = 0 ;
6442 PyObject * obj1 = 0 ;
6443 char *kwnames[] = {
6444 (char *) "self",(char *) "rect", NULL
6445 };
6446
6447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsRect",kwnames,&obj0,&obj1)) goto fail;
6448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6449 if (SWIG_arg_fail(1)) SWIG_fail;
6450 {
6451 arg2 = &temp2;
6452 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6453 }
6454 {
6455 PyThreadState* __tstate = wxPyBeginAllowThreads();
6456 result = (wxRegionContain)(arg1)->Contains((wxRect const &)*arg2);
6457
6458 wxPyEndAllowThreads(__tstate);
6459 if (PyErr_Occurred()) SWIG_fail;
6460 }
6461 resultobj = SWIG_From_int((result));
6462 return resultobj;
6463 fail:
6464 return NULL;
6465 }
6466
6467
6468 static PyObject *_wrap_Region_ContainsRectDim(PyObject *, PyObject *args, PyObject *kwargs) {
6469 PyObject *resultobj;
6470 wxRegion *arg1 = (wxRegion *) 0 ;
6471 int arg2 ;
6472 int arg3 ;
6473 int arg4 ;
6474 int arg5 ;
6475 wxRegionContain result;
6476 PyObject * obj0 = 0 ;
6477 PyObject * obj1 = 0 ;
6478 PyObject * obj2 = 0 ;
6479 PyObject * obj3 = 0 ;
6480 PyObject * obj4 = 0 ;
6481 char *kwnames[] = {
6482 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
6483 };
6484
6485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_ContainsRectDim",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6487 if (SWIG_arg_fail(1)) SWIG_fail;
6488 {
6489 arg2 = (int)(SWIG_As_int(obj1));
6490 if (SWIG_arg_fail(2)) SWIG_fail;
6491 }
6492 {
6493 arg3 = (int)(SWIG_As_int(obj2));
6494 if (SWIG_arg_fail(3)) SWIG_fail;
6495 }
6496 {
6497 arg4 = (int)(SWIG_As_int(obj3));
6498 if (SWIG_arg_fail(4)) SWIG_fail;
6499 }
6500 {
6501 arg5 = (int)(SWIG_As_int(obj4));
6502 if (SWIG_arg_fail(5)) SWIG_fail;
6503 }
6504 {
6505 PyThreadState* __tstate = wxPyBeginAllowThreads();
6506 result = (wxRegionContain)(arg1)->Contains(arg2,arg3,arg4,arg5);
6507
6508 wxPyEndAllowThreads(__tstate);
6509 if (PyErr_Occurred()) SWIG_fail;
6510 }
6511 resultobj = SWIG_From_int((result));
6512 return resultobj;
6513 fail:
6514 return NULL;
6515 }
6516
6517
6518 static PyObject *_wrap_Region_GetBox(PyObject *, PyObject *args, PyObject *kwargs) {
6519 PyObject *resultobj;
6520 wxRegion *arg1 = (wxRegion *) 0 ;
6521 wxRect result;
6522 PyObject * obj0 = 0 ;
6523 char *kwnames[] = {
6524 (char *) "self", NULL
6525 };
6526
6527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_GetBox",kwnames,&obj0)) goto fail;
6528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6529 if (SWIG_arg_fail(1)) SWIG_fail;
6530 {
6531 PyThreadState* __tstate = wxPyBeginAllowThreads();
6532 result = (arg1)->GetBox();
6533
6534 wxPyEndAllowThreads(__tstate);
6535 if (PyErr_Occurred()) SWIG_fail;
6536 }
6537 {
6538 wxRect * resultptr;
6539 resultptr = new wxRect((wxRect &)(result));
6540 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6541 }
6542 return resultobj;
6543 fail:
6544 return NULL;
6545 }
6546
6547
6548 static PyObject *_wrap_Region_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
6549 PyObject *resultobj;
6550 wxRegion *arg1 = (wxRegion *) 0 ;
6551 int arg2 ;
6552 int arg3 ;
6553 int arg4 ;
6554 int arg5 ;
6555 bool result;
6556 PyObject * obj0 = 0 ;
6557 PyObject * obj1 = 0 ;
6558 PyObject * obj2 = 0 ;
6559 PyObject * obj3 = 0 ;
6560 PyObject * obj4 = 0 ;
6561 char *kwnames[] = {
6562 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6563 };
6564
6565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Intersect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6567 if (SWIG_arg_fail(1)) SWIG_fail;
6568 {
6569 arg2 = (int)(SWIG_As_int(obj1));
6570 if (SWIG_arg_fail(2)) SWIG_fail;
6571 }
6572 {
6573 arg3 = (int)(SWIG_As_int(obj2));
6574 if (SWIG_arg_fail(3)) SWIG_fail;
6575 }
6576 {
6577 arg4 = (int)(SWIG_As_int(obj3));
6578 if (SWIG_arg_fail(4)) SWIG_fail;
6579 }
6580 {
6581 arg5 = (int)(SWIG_As_int(obj4));
6582 if (SWIG_arg_fail(5)) SWIG_fail;
6583 }
6584 {
6585 PyThreadState* __tstate = wxPyBeginAllowThreads();
6586 result = (bool)(arg1)->Intersect(arg2,arg3,arg4,arg5);
6587
6588 wxPyEndAllowThreads(__tstate);
6589 if (PyErr_Occurred()) SWIG_fail;
6590 }
6591 {
6592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6593 }
6594 return resultobj;
6595 fail:
6596 return NULL;
6597 }
6598
6599
6600 static PyObject *_wrap_Region_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6601 PyObject *resultobj;
6602 wxRegion *arg1 = (wxRegion *) 0 ;
6603 wxRect *arg2 = 0 ;
6604 bool result;
6605 wxRect temp2 ;
6606 PyObject * obj0 = 0 ;
6607 PyObject * obj1 = 0 ;
6608 char *kwnames[] = {
6609 (char *) "self",(char *) "rect", NULL
6610 };
6611
6612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6614 if (SWIG_arg_fail(1)) SWIG_fail;
6615 {
6616 arg2 = &temp2;
6617 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6618 }
6619 {
6620 PyThreadState* __tstate = wxPyBeginAllowThreads();
6621 result = (bool)(arg1)->Intersect((wxRect const &)*arg2);
6622
6623 wxPyEndAllowThreads(__tstate);
6624 if (PyErr_Occurred()) SWIG_fail;
6625 }
6626 {
6627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6628 }
6629 return resultobj;
6630 fail:
6631 return NULL;
6632 }
6633
6634
6635 static PyObject *_wrap_Region_IntersectRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6636 PyObject *resultobj;
6637 wxRegion *arg1 = (wxRegion *) 0 ;
6638 wxRegion *arg2 = 0 ;
6639 bool result;
6640 PyObject * obj0 = 0 ;
6641 PyObject * obj1 = 0 ;
6642 char *kwnames[] = {
6643 (char *) "self",(char *) "region", NULL
6644 };
6645
6646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRegion",kwnames,&obj0,&obj1)) goto fail;
6647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6648 if (SWIG_arg_fail(1)) SWIG_fail;
6649 {
6650 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6651 if (SWIG_arg_fail(2)) SWIG_fail;
6652 if (arg2 == NULL) {
6653 SWIG_null_ref("wxRegion");
6654 }
6655 if (SWIG_arg_fail(2)) SWIG_fail;
6656 }
6657 {
6658 PyThreadState* __tstate = wxPyBeginAllowThreads();
6659 result = (bool)(arg1)->Intersect((wxRegion const &)*arg2);
6660
6661 wxPyEndAllowThreads(__tstate);
6662 if (PyErr_Occurred()) SWIG_fail;
6663 }
6664 {
6665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6666 }
6667 return resultobj;
6668 fail:
6669 return NULL;
6670 }
6671
6672
6673 static PyObject *_wrap_Region_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
6674 PyObject *resultobj;
6675 wxRegion *arg1 = (wxRegion *) 0 ;
6676 bool result;
6677 PyObject * obj0 = 0 ;
6678 char *kwnames[] = {
6679 (char *) "self", NULL
6680 };
6681
6682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_IsEmpty",kwnames,&obj0)) goto fail;
6683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6684 if (SWIG_arg_fail(1)) SWIG_fail;
6685 {
6686 PyThreadState* __tstate = wxPyBeginAllowThreads();
6687 result = (bool)(arg1)->IsEmpty();
6688
6689 wxPyEndAllowThreads(__tstate);
6690 if (PyErr_Occurred()) SWIG_fail;
6691 }
6692 {
6693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6694 }
6695 return resultobj;
6696 fail:
6697 return NULL;
6698 }
6699
6700
6701 static PyObject *_wrap_Region_Union(PyObject *, PyObject *args, PyObject *kwargs) {
6702 PyObject *resultobj;
6703 wxRegion *arg1 = (wxRegion *) 0 ;
6704 int arg2 ;
6705 int arg3 ;
6706 int arg4 ;
6707 int arg5 ;
6708 bool result;
6709 PyObject * obj0 = 0 ;
6710 PyObject * obj1 = 0 ;
6711 PyObject * obj2 = 0 ;
6712 PyObject * obj3 = 0 ;
6713 PyObject * obj4 = 0 ;
6714 char *kwnames[] = {
6715 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6716 };
6717
6718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Union",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6720 if (SWIG_arg_fail(1)) SWIG_fail;
6721 {
6722 arg2 = (int)(SWIG_As_int(obj1));
6723 if (SWIG_arg_fail(2)) SWIG_fail;
6724 }
6725 {
6726 arg3 = (int)(SWIG_As_int(obj2));
6727 if (SWIG_arg_fail(3)) SWIG_fail;
6728 }
6729 {
6730 arg4 = (int)(SWIG_As_int(obj3));
6731 if (SWIG_arg_fail(4)) SWIG_fail;
6732 }
6733 {
6734 arg5 = (int)(SWIG_As_int(obj4));
6735 if (SWIG_arg_fail(5)) SWIG_fail;
6736 }
6737 {
6738 PyThreadState* __tstate = wxPyBeginAllowThreads();
6739 result = (bool)(arg1)->Union(arg2,arg3,arg4,arg5);
6740
6741 wxPyEndAllowThreads(__tstate);
6742 if (PyErr_Occurred()) SWIG_fail;
6743 }
6744 {
6745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6746 }
6747 return resultobj;
6748 fail:
6749 return NULL;
6750 }
6751
6752
6753 static PyObject *_wrap_Region_UnionRect(PyObject *, PyObject *args, PyObject *kwargs) {
6754 PyObject *resultobj;
6755 wxRegion *arg1 = (wxRegion *) 0 ;
6756 wxRect *arg2 = 0 ;
6757 bool result;
6758 wxRect temp2 ;
6759 PyObject * obj0 = 0 ;
6760 PyObject * obj1 = 0 ;
6761 char *kwnames[] = {
6762 (char *) "self",(char *) "rect", NULL
6763 };
6764
6765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRect",kwnames,&obj0,&obj1)) goto fail;
6766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6767 if (SWIG_arg_fail(1)) SWIG_fail;
6768 {
6769 arg2 = &temp2;
6770 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6771 }
6772 {
6773 PyThreadState* __tstate = wxPyBeginAllowThreads();
6774 result = (bool)(arg1)->Union((wxRect const &)*arg2);
6775
6776 wxPyEndAllowThreads(__tstate);
6777 if (PyErr_Occurred()) SWIG_fail;
6778 }
6779 {
6780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6781 }
6782 return resultobj;
6783 fail:
6784 return NULL;
6785 }
6786
6787
6788 static PyObject *_wrap_Region_UnionRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6789 PyObject *resultobj;
6790 wxRegion *arg1 = (wxRegion *) 0 ;
6791 wxRegion *arg2 = 0 ;
6792 bool result;
6793 PyObject * obj0 = 0 ;
6794 PyObject * obj1 = 0 ;
6795 char *kwnames[] = {
6796 (char *) "self",(char *) "region", NULL
6797 };
6798
6799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRegion",kwnames,&obj0,&obj1)) goto fail;
6800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6801 if (SWIG_arg_fail(1)) SWIG_fail;
6802 {
6803 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6804 if (SWIG_arg_fail(2)) SWIG_fail;
6805 if (arg2 == NULL) {
6806 SWIG_null_ref("wxRegion");
6807 }
6808 if (SWIG_arg_fail(2)) SWIG_fail;
6809 }
6810 {
6811 PyThreadState* __tstate = wxPyBeginAllowThreads();
6812 result = (bool)(arg1)->Union((wxRegion const &)*arg2);
6813
6814 wxPyEndAllowThreads(__tstate);
6815 if (PyErr_Occurred()) SWIG_fail;
6816 }
6817 {
6818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6819 }
6820 return resultobj;
6821 fail:
6822 return NULL;
6823 }
6824
6825
6826 static PyObject *_wrap_Region_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
6827 PyObject *resultobj;
6828 wxRegion *arg1 = (wxRegion *) 0 ;
6829 int arg2 ;
6830 int arg3 ;
6831 int arg4 ;
6832 int arg5 ;
6833 bool result;
6834 PyObject * obj0 = 0 ;
6835 PyObject * obj1 = 0 ;
6836 PyObject * obj2 = 0 ;
6837 PyObject * obj3 = 0 ;
6838 PyObject * obj4 = 0 ;
6839 char *kwnames[] = {
6840 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6841 };
6842
6843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Subtract",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6845 if (SWIG_arg_fail(1)) SWIG_fail;
6846 {
6847 arg2 = (int)(SWIG_As_int(obj1));
6848 if (SWIG_arg_fail(2)) SWIG_fail;
6849 }
6850 {
6851 arg3 = (int)(SWIG_As_int(obj2));
6852 if (SWIG_arg_fail(3)) SWIG_fail;
6853 }
6854 {
6855 arg4 = (int)(SWIG_As_int(obj3));
6856 if (SWIG_arg_fail(4)) SWIG_fail;
6857 }
6858 {
6859 arg5 = (int)(SWIG_As_int(obj4));
6860 if (SWIG_arg_fail(5)) SWIG_fail;
6861 }
6862 {
6863 PyThreadState* __tstate = wxPyBeginAllowThreads();
6864 result = (bool)(arg1)->Subtract(arg2,arg3,arg4,arg5);
6865
6866 wxPyEndAllowThreads(__tstate);
6867 if (PyErr_Occurred()) SWIG_fail;
6868 }
6869 {
6870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6871 }
6872 return resultobj;
6873 fail:
6874 return NULL;
6875 }
6876
6877
6878 static PyObject *_wrap_Region_SubtractRect(PyObject *, PyObject *args, PyObject *kwargs) {
6879 PyObject *resultobj;
6880 wxRegion *arg1 = (wxRegion *) 0 ;
6881 wxRect *arg2 = 0 ;
6882 bool result;
6883 wxRect temp2 ;
6884 PyObject * obj0 = 0 ;
6885 PyObject * obj1 = 0 ;
6886 char *kwnames[] = {
6887 (char *) "self",(char *) "rect", NULL
6888 };
6889
6890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRect",kwnames,&obj0,&obj1)) goto fail;
6891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6892 if (SWIG_arg_fail(1)) SWIG_fail;
6893 {
6894 arg2 = &temp2;
6895 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6896 }
6897 {
6898 PyThreadState* __tstate = wxPyBeginAllowThreads();
6899 result = (bool)(arg1)->Subtract((wxRect const &)*arg2);
6900
6901 wxPyEndAllowThreads(__tstate);
6902 if (PyErr_Occurred()) SWIG_fail;
6903 }
6904 {
6905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6906 }
6907 return resultobj;
6908 fail:
6909 return NULL;
6910 }
6911
6912
6913 static PyObject *_wrap_Region_SubtractRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6914 PyObject *resultobj;
6915 wxRegion *arg1 = (wxRegion *) 0 ;
6916 wxRegion *arg2 = 0 ;
6917 bool result;
6918 PyObject * obj0 = 0 ;
6919 PyObject * obj1 = 0 ;
6920 char *kwnames[] = {
6921 (char *) "self",(char *) "region", NULL
6922 };
6923
6924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRegion",kwnames,&obj0,&obj1)) goto fail;
6925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6926 if (SWIG_arg_fail(1)) SWIG_fail;
6927 {
6928 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6929 if (SWIG_arg_fail(2)) SWIG_fail;
6930 if (arg2 == NULL) {
6931 SWIG_null_ref("wxRegion");
6932 }
6933 if (SWIG_arg_fail(2)) SWIG_fail;
6934 }
6935 {
6936 PyThreadState* __tstate = wxPyBeginAllowThreads();
6937 result = (bool)(arg1)->Subtract((wxRegion const &)*arg2);
6938
6939 wxPyEndAllowThreads(__tstate);
6940 if (PyErr_Occurred()) SWIG_fail;
6941 }
6942 {
6943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6944 }
6945 return resultobj;
6946 fail:
6947 return NULL;
6948 }
6949
6950
6951 static PyObject *_wrap_Region_Xor(PyObject *, PyObject *args, PyObject *kwargs) {
6952 PyObject *resultobj;
6953 wxRegion *arg1 = (wxRegion *) 0 ;
6954 int arg2 ;
6955 int arg3 ;
6956 int arg4 ;
6957 int arg5 ;
6958 bool result;
6959 PyObject * obj0 = 0 ;
6960 PyObject * obj1 = 0 ;
6961 PyObject * obj2 = 0 ;
6962 PyObject * obj3 = 0 ;
6963 PyObject * obj4 = 0 ;
6964 char *kwnames[] = {
6965 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6966 };
6967
6968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Xor",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6970 if (SWIG_arg_fail(1)) SWIG_fail;
6971 {
6972 arg2 = (int)(SWIG_As_int(obj1));
6973 if (SWIG_arg_fail(2)) SWIG_fail;
6974 }
6975 {
6976 arg3 = (int)(SWIG_As_int(obj2));
6977 if (SWIG_arg_fail(3)) SWIG_fail;
6978 }
6979 {
6980 arg4 = (int)(SWIG_As_int(obj3));
6981 if (SWIG_arg_fail(4)) SWIG_fail;
6982 }
6983 {
6984 arg5 = (int)(SWIG_As_int(obj4));
6985 if (SWIG_arg_fail(5)) SWIG_fail;
6986 }
6987 {
6988 PyThreadState* __tstate = wxPyBeginAllowThreads();
6989 result = (bool)(arg1)->Xor(arg2,arg3,arg4,arg5);
6990
6991 wxPyEndAllowThreads(__tstate);
6992 if (PyErr_Occurred()) SWIG_fail;
6993 }
6994 {
6995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6996 }
6997 return resultobj;
6998 fail:
6999 return NULL;
7000 }
7001
7002
7003 static PyObject *_wrap_Region_XorRect(PyObject *, PyObject *args, PyObject *kwargs) {
7004 PyObject *resultobj;
7005 wxRegion *arg1 = (wxRegion *) 0 ;
7006 wxRect *arg2 = 0 ;
7007 bool result;
7008 wxRect temp2 ;
7009 PyObject * obj0 = 0 ;
7010 PyObject * obj1 = 0 ;
7011 char *kwnames[] = {
7012 (char *) "self",(char *) "rect", NULL
7013 };
7014
7015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRect",kwnames,&obj0,&obj1)) goto fail;
7016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7017 if (SWIG_arg_fail(1)) SWIG_fail;
7018 {
7019 arg2 = &temp2;
7020 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7021 }
7022 {
7023 PyThreadState* __tstate = wxPyBeginAllowThreads();
7024 result = (bool)(arg1)->Xor((wxRect const &)*arg2);
7025
7026 wxPyEndAllowThreads(__tstate);
7027 if (PyErr_Occurred()) SWIG_fail;
7028 }
7029 {
7030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7031 }
7032 return resultobj;
7033 fail:
7034 return NULL;
7035 }
7036
7037
7038 static PyObject *_wrap_Region_XorRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7039 PyObject *resultobj;
7040 wxRegion *arg1 = (wxRegion *) 0 ;
7041 wxRegion *arg2 = 0 ;
7042 bool result;
7043 PyObject * obj0 = 0 ;
7044 PyObject * obj1 = 0 ;
7045 char *kwnames[] = {
7046 (char *) "self",(char *) "region", NULL
7047 };
7048
7049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRegion",kwnames,&obj0,&obj1)) goto fail;
7050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7051 if (SWIG_arg_fail(1)) SWIG_fail;
7052 {
7053 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7054 if (SWIG_arg_fail(2)) SWIG_fail;
7055 if (arg2 == NULL) {
7056 SWIG_null_ref("wxRegion");
7057 }
7058 if (SWIG_arg_fail(2)) SWIG_fail;
7059 }
7060 {
7061 PyThreadState* __tstate = wxPyBeginAllowThreads();
7062 result = (bool)(arg1)->Xor((wxRegion const &)*arg2);
7063
7064 wxPyEndAllowThreads(__tstate);
7065 if (PyErr_Occurred()) SWIG_fail;
7066 }
7067 {
7068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7069 }
7070 return resultobj;
7071 fail:
7072 return NULL;
7073 }
7074
7075
7076 static PyObject *_wrap_Region_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7077 PyObject *resultobj;
7078 wxRegion *arg1 = (wxRegion *) 0 ;
7079 SwigValueWrapper<wxBitmap > result;
7080 PyObject * obj0 = 0 ;
7081 char *kwnames[] = {
7082 (char *) "self", NULL
7083 };
7084
7085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_ConvertToBitmap",kwnames,&obj0)) goto fail;
7086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7087 if (SWIG_arg_fail(1)) SWIG_fail;
7088 {
7089 PyThreadState* __tstate = wxPyBeginAllowThreads();
7090 result = (arg1)->ConvertToBitmap();
7091
7092 wxPyEndAllowThreads(__tstate);
7093 if (PyErr_Occurred()) SWIG_fail;
7094 }
7095 {
7096 wxBitmap * resultptr;
7097 resultptr = new wxBitmap((wxBitmap &)(result));
7098 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
7099 }
7100 return resultobj;
7101 fail:
7102 return NULL;
7103 }
7104
7105
7106 static PyObject *_wrap_Region_UnionBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7107 PyObject *resultobj;
7108 wxRegion *arg1 = (wxRegion *) 0 ;
7109 wxBitmap *arg2 = 0 ;
7110 bool result;
7111 PyObject * obj0 = 0 ;
7112 PyObject * obj1 = 0 ;
7113 char *kwnames[] = {
7114 (char *) "self",(char *) "bmp", NULL
7115 };
7116
7117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionBitmap",kwnames,&obj0,&obj1)) goto fail;
7118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7119 if (SWIG_arg_fail(1)) SWIG_fail;
7120 {
7121 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7122 if (SWIG_arg_fail(2)) SWIG_fail;
7123 if (arg2 == NULL) {
7124 SWIG_null_ref("wxBitmap");
7125 }
7126 if (SWIG_arg_fail(2)) SWIG_fail;
7127 }
7128 {
7129 PyThreadState* __tstate = wxPyBeginAllowThreads();
7130 result = (bool)(arg1)->Union((wxBitmap const &)*arg2);
7131
7132 wxPyEndAllowThreads(__tstate);
7133 if (PyErr_Occurred()) SWIG_fail;
7134 }
7135 {
7136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7137 }
7138 return resultobj;
7139 fail:
7140 return NULL;
7141 }
7142
7143
7144 static PyObject *_wrap_Region_UnionBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
7145 PyObject *resultobj;
7146 wxRegion *arg1 = (wxRegion *) 0 ;
7147 wxBitmap *arg2 = 0 ;
7148 wxColour *arg3 = 0 ;
7149 int arg4 = (int) 0 ;
7150 bool result;
7151 wxColour temp3 ;
7152 PyObject * obj0 = 0 ;
7153 PyObject * obj1 = 0 ;
7154 PyObject * obj2 = 0 ;
7155 PyObject * obj3 = 0 ;
7156 char *kwnames[] = {
7157 (char *) "self",(char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
7158 };
7159
7160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Region_UnionBitmapColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7162 if (SWIG_arg_fail(1)) SWIG_fail;
7163 {
7164 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7165 if (SWIG_arg_fail(2)) SWIG_fail;
7166 if (arg2 == NULL) {
7167 SWIG_null_ref("wxBitmap");
7168 }
7169 if (SWIG_arg_fail(2)) SWIG_fail;
7170 }
7171 {
7172 arg3 = &temp3;
7173 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
7174 }
7175 if (obj3) {
7176 {
7177 arg4 = (int)(SWIG_As_int(obj3));
7178 if (SWIG_arg_fail(4)) SWIG_fail;
7179 }
7180 }
7181 {
7182 PyThreadState* __tstate = wxPyBeginAllowThreads();
7183 result = (bool)(arg1)->Union((wxBitmap const &)*arg2,(wxColour const &)*arg3,arg4);
7184
7185 wxPyEndAllowThreads(__tstate);
7186 if (PyErr_Occurred()) SWIG_fail;
7187 }
7188 {
7189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7190 }
7191 return resultobj;
7192 fail:
7193 return NULL;
7194 }
7195
7196
7197 static PyObject * Region_swigregister(PyObject *, PyObject *args) {
7198 PyObject *obj;
7199 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7200 SWIG_TypeClientData(SWIGTYPE_p_wxRegion, obj);
7201 Py_INCREF(obj);
7202 return Py_BuildValue((char *)"");
7203 }
7204 static PyObject *_wrap_new_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7205 PyObject *resultobj;
7206 wxRegion *arg1 = 0 ;
7207 wxRegionIterator *result;
7208 PyObject * obj0 = 0 ;
7209 char *kwnames[] = {
7210 (char *) "region", NULL
7211 };
7212
7213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionIterator",kwnames,&obj0)) goto fail;
7214 {
7215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7216 if (SWIG_arg_fail(1)) SWIG_fail;
7217 if (arg1 == NULL) {
7218 SWIG_null_ref("wxRegion");
7219 }
7220 if (SWIG_arg_fail(1)) SWIG_fail;
7221 }
7222 {
7223 if (!wxPyCheckForApp()) SWIG_fail;
7224 PyThreadState* __tstate = wxPyBeginAllowThreads();
7225 result = (wxRegionIterator *)new wxRegionIterator((wxRegion const &)*arg1);
7226
7227 wxPyEndAllowThreads(__tstate);
7228 if (PyErr_Occurred()) SWIG_fail;
7229 }
7230 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegionIterator, 1);
7231 return resultobj;
7232 fail:
7233 return NULL;
7234 }
7235
7236
7237 static PyObject *_wrap_delete_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7238 PyObject *resultobj;
7239 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7240 PyObject * obj0 = 0 ;
7241 char *kwnames[] = {
7242 (char *) "self", NULL
7243 };
7244
7245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RegionIterator",kwnames,&obj0)) goto fail;
7246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7247 if (SWIG_arg_fail(1)) SWIG_fail;
7248 {
7249 PyThreadState* __tstate = wxPyBeginAllowThreads();
7250 delete arg1;
7251
7252 wxPyEndAllowThreads(__tstate);
7253 if (PyErr_Occurred()) SWIG_fail;
7254 }
7255 Py_INCREF(Py_None); resultobj = Py_None;
7256 return resultobj;
7257 fail:
7258 return NULL;
7259 }
7260
7261
7262 static PyObject *_wrap_RegionIterator_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
7263 PyObject *resultobj;
7264 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7265 int result;
7266 PyObject * obj0 = 0 ;
7267 char *kwnames[] = {
7268 (char *) "self", NULL
7269 };
7270
7271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetX",kwnames,&obj0)) goto fail;
7272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7273 if (SWIG_arg_fail(1)) SWIG_fail;
7274 {
7275 PyThreadState* __tstate = wxPyBeginAllowThreads();
7276 result = (int)(arg1)->GetX();
7277
7278 wxPyEndAllowThreads(__tstate);
7279 if (PyErr_Occurred()) SWIG_fail;
7280 }
7281 {
7282 resultobj = SWIG_From_int((int)(result));
7283 }
7284 return resultobj;
7285 fail:
7286 return NULL;
7287 }
7288
7289
7290 static PyObject *_wrap_RegionIterator_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
7291 PyObject *resultobj;
7292 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7293 int result;
7294 PyObject * obj0 = 0 ;
7295 char *kwnames[] = {
7296 (char *) "self", NULL
7297 };
7298
7299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetY",kwnames,&obj0)) goto fail;
7300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7301 if (SWIG_arg_fail(1)) SWIG_fail;
7302 {
7303 PyThreadState* __tstate = wxPyBeginAllowThreads();
7304 result = (int)(arg1)->GetY();
7305
7306 wxPyEndAllowThreads(__tstate);
7307 if (PyErr_Occurred()) SWIG_fail;
7308 }
7309 {
7310 resultobj = SWIG_From_int((int)(result));
7311 }
7312 return resultobj;
7313 fail:
7314 return NULL;
7315 }
7316
7317
7318 static PyObject *_wrap_RegionIterator_GetW(PyObject *, PyObject *args, PyObject *kwargs) {
7319 PyObject *resultobj;
7320 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7321 int result;
7322 PyObject * obj0 = 0 ;
7323 char *kwnames[] = {
7324 (char *) "self", NULL
7325 };
7326
7327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetW",kwnames,&obj0)) goto fail;
7328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7329 if (SWIG_arg_fail(1)) SWIG_fail;
7330 {
7331 PyThreadState* __tstate = wxPyBeginAllowThreads();
7332 result = (int)(arg1)->GetW();
7333
7334 wxPyEndAllowThreads(__tstate);
7335 if (PyErr_Occurred()) SWIG_fail;
7336 }
7337 {
7338 resultobj = SWIG_From_int((int)(result));
7339 }
7340 return resultobj;
7341 fail:
7342 return NULL;
7343 }
7344
7345
7346 static PyObject *_wrap_RegionIterator_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
7347 PyObject *resultobj;
7348 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7349 int result;
7350 PyObject * obj0 = 0 ;
7351 char *kwnames[] = {
7352 (char *) "self", NULL
7353 };
7354
7355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetWidth",kwnames,&obj0)) goto fail;
7356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7357 if (SWIG_arg_fail(1)) SWIG_fail;
7358 {
7359 PyThreadState* __tstate = wxPyBeginAllowThreads();
7360 result = (int)(arg1)->GetWidth();
7361
7362 wxPyEndAllowThreads(__tstate);
7363 if (PyErr_Occurred()) SWIG_fail;
7364 }
7365 {
7366 resultobj = SWIG_From_int((int)(result));
7367 }
7368 return resultobj;
7369 fail:
7370 return NULL;
7371 }
7372
7373
7374 static PyObject *_wrap_RegionIterator_GetH(PyObject *, PyObject *args, PyObject *kwargs) {
7375 PyObject *resultobj;
7376 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7377 int result;
7378 PyObject * obj0 = 0 ;
7379 char *kwnames[] = {
7380 (char *) "self", NULL
7381 };
7382
7383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetH",kwnames,&obj0)) goto fail;
7384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7385 if (SWIG_arg_fail(1)) SWIG_fail;
7386 {
7387 PyThreadState* __tstate = wxPyBeginAllowThreads();
7388 result = (int)(arg1)->GetH();
7389
7390 wxPyEndAllowThreads(__tstate);
7391 if (PyErr_Occurred()) SWIG_fail;
7392 }
7393 {
7394 resultobj = SWIG_From_int((int)(result));
7395 }
7396 return resultobj;
7397 fail:
7398 return NULL;
7399 }
7400
7401
7402 static PyObject *_wrap_RegionIterator_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
7403 PyObject *resultobj;
7404 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7405 int result;
7406 PyObject * obj0 = 0 ;
7407 char *kwnames[] = {
7408 (char *) "self", NULL
7409 };
7410
7411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetHeight",kwnames,&obj0)) goto fail;
7412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7413 if (SWIG_arg_fail(1)) SWIG_fail;
7414 {
7415 PyThreadState* __tstate = wxPyBeginAllowThreads();
7416 result = (int)(arg1)->GetHeight();
7417
7418 wxPyEndAllowThreads(__tstate);
7419 if (PyErr_Occurred()) SWIG_fail;
7420 }
7421 {
7422 resultobj = SWIG_From_int((int)(result));
7423 }
7424 return resultobj;
7425 fail:
7426 return NULL;
7427 }
7428
7429
7430 static PyObject *_wrap_RegionIterator_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
7431 PyObject *resultobj;
7432 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7433 wxRect result;
7434 PyObject * obj0 = 0 ;
7435 char *kwnames[] = {
7436 (char *) "self", NULL
7437 };
7438
7439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetRect",kwnames,&obj0)) goto fail;
7440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7441 if (SWIG_arg_fail(1)) SWIG_fail;
7442 {
7443 PyThreadState* __tstate = wxPyBeginAllowThreads();
7444 result = (arg1)->GetRect();
7445
7446 wxPyEndAllowThreads(__tstate);
7447 if (PyErr_Occurred()) SWIG_fail;
7448 }
7449 {
7450 wxRect * resultptr;
7451 resultptr = new wxRect((wxRect &)(result));
7452 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
7453 }
7454 return resultobj;
7455 fail:
7456 return NULL;
7457 }
7458
7459
7460 static PyObject *_wrap_RegionIterator_HaveRects(PyObject *, PyObject *args, PyObject *kwargs) {
7461 PyObject *resultobj;
7462 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7463 bool result;
7464 PyObject * obj0 = 0 ;
7465 char *kwnames[] = {
7466 (char *) "self", NULL
7467 };
7468
7469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_HaveRects",kwnames,&obj0)) goto fail;
7470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7471 if (SWIG_arg_fail(1)) SWIG_fail;
7472 {
7473 PyThreadState* __tstate = wxPyBeginAllowThreads();
7474 result = (bool)(arg1)->HaveRects();
7475
7476 wxPyEndAllowThreads(__tstate);
7477 if (PyErr_Occurred()) SWIG_fail;
7478 }
7479 {
7480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7481 }
7482 return resultobj;
7483 fail:
7484 return NULL;
7485 }
7486
7487
7488 static PyObject *_wrap_RegionIterator_Reset(PyObject *, PyObject *args, PyObject *kwargs) {
7489 PyObject *resultobj;
7490 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7491 PyObject * obj0 = 0 ;
7492 char *kwnames[] = {
7493 (char *) "self", NULL
7494 };
7495
7496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Reset",kwnames,&obj0)) goto fail;
7497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7498 if (SWIG_arg_fail(1)) SWIG_fail;
7499 {
7500 PyThreadState* __tstate = wxPyBeginAllowThreads();
7501 (arg1)->Reset();
7502
7503 wxPyEndAllowThreads(__tstate);
7504 if (PyErr_Occurred()) SWIG_fail;
7505 }
7506 Py_INCREF(Py_None); resultobj = Py_None;
7507 return resultobj;
7508 fail:
7509 return NULL;
7510 }
7511
7512
7513 static PyObject *_wrap_RegionIterator_Next(PyObject *, PyObject *args, PyObject *kwargs) {
7514 PyObject *resultobj;
7515 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7516 PyObject * obj0 = 0 ;
7517 char *kwnames[] = {
7518 (char *) "self", NULL
7519 };
7520
7521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Next",kwnames,&obj0)) goto fail;
7522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7523 if (SWIG_arg_fail(1)) SWIG_fail;
7524 {
7525 PyThreadState* __tstate = wxPyBeginAllowThreads();
7526 wxRegionIterator_Next(arg1);
7527
7528 wxPyEndAllowThreads(__tstate);
7529 if (PyErr_Occurred()) SWIG_fail;
7530 }
7531 Py_INCREF(Py_None); resultobj = Py_None;
7532 return resultobj;
7533 fail:
7534 return NULL;
7535 }
7536
7537
7538 static PyObject *_wrap_RegionIterator___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
7539 PyObject *resultobj;
7540 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7541 bool result;
7542 PyObject * obj0 = 0 ;
7543 char *kwnames[] = {
7544 (char *) "self", NULL
7545 };
7546
7547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator___nonzero__",kwnames,&obj0)) goto fail;
7548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7549 if (SWIG_arg_fail(1)) SWIG_fail;
7550 {
7551 PyThreadState* __tstate = wxPyBeginAllowThreads();
7552 result = (bool)wxRegionIterator___nonzero__(arg1);
7553
7554 wxPyEndAllowThreads(__tstate);
7555 if (PyErr_Occurred()) SWIG_fail;
7556 }
7557 {
7558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7559 }
7560 return resultobj;
7561 fail:
7562 return NULL;
7563 }
7564
7565
7566 static PyObject * RegionIterator_swigregister(PyObject *, PyObject *args) {
7567 PyObject *obj;
7568 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7569 SWIG_TypeClientData(SWIGTYPE_p_wxRegionIterator, obj);
7570 Py_INCREF(obj);
7571 return Py_BuildValue((char *)"");
7572 }
7573 static PyObject *_wrap_new_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7574 PyObject *resultobj;
7575 wxNativeFontInfo *result;
7576 char *kwnames[] = {
7577 NULL
7578 };
7579
7580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeFontInfo",kwnames)) goto fail;
7581 {
7582 PyThreadState* __tstate = wxPyBeginAllowThreads();
7583 result = (wxNativeFontInfo *)new wxNativeFontInfo();
7584
7585 wxPyEndAllowThreads(__tstate);
7586 if (PyErr_Occurred()) SWIG_fail;
7587 }
7588 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 1);
7589 return resultobj;
7590 fail:
7591 return NULL;
7592 }
7593
7594
7595 static PyObject *_wrap_delete_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7596 PyObject *resultobj;
7597 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7598 PyObject * obj0 = 0 ;
7599 char *kwnames[] = {
7600 (char *) "self", NULL
7601 };
7602
7603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeFontInfo",kwnames,&obj0)) goto fail;
7604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7605 if (SWIG_arg_fail(1)) SWIG_fail;
7606 {
7607 PyThreadState* __tstate = wxPyBeginAllowThreads();
7608 delete arg1;
7609
7610 wxPyEndAllowThreads(__tstate);
7611 if (PyErr_Occurred()) SWIG_fail;
7612 }
7613 Py_INCREF(Py_None); resultobj = Py_None;
7614 return resultobj;
7615 fail:
7616 return NULL;
7617 }
7618
7619
7620 static PyObject *_wrap_NativeFontInfo_Init(PyObject *, PyObject *args, PyObject *kwargs) {
7621 PyObject *resultobj;
7622 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7623 PyObject * obj0 = 0 ;
7624 char *kwnames[] = {
7625 (char *) "self", NULL
7626 };
7627
7628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_Init",kwnames,&obj0)) goto fail;
7629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7630 if (SWIG_arg_fail(1)) SWIG_fail;
7631 {
7632 PyThreadState* __tstate = wxPyBeginAllowThreads();
7633 (arg1)->Init();
7634
7635 wxPyEndAllowThreads(__tstate);
7636 if (PyErr_Occurred()) SWIG_fail;
7637 }
7638 Py_INCREF(Py_None); resultobj = Py_None;
7639 return resultobj;
7640 fail:
7641 return NULL;
7642 }
7643
7644
7645 static PyObject *_wrap_NativeFontInfo_InitFromFont(PyObject *, PyObject *args, PyObject *kwargs) {
7646 PyObject *resultobj;
7647 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7648 wxFont *arg2 = 0 ;
7649 PyObject * obj0 = 0 ;
7650 PyObject * obj1 = 0 ;
7651 char *kwnames[] = {
7652 (char *) "self",(char *) "font", NULL
7653 };
7654
7655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_InitFromFont",kwnames,&obj0,&obj1)) goto fail;
7656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7657 if (SWIG_arg_fail(1)) SWIG_fail;
7658 {
7659 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
7660 if (SWIG_arg_fail(2)) SWIG_fail;
7661 if (arg2 == NULL) {
7662 SWIG_null_ref("wxFont");
7663 }
7664 if (SWIG_arg_fail(2)) SWIG_fail;
7665 }
7666 {
7667 PyThreadState* __tstate = wxPyBeginAllowThreads();
7668 (arg1)->InitFromFont((wxFont const &)*arg2);
7669
7670 wxPyEndAllowThreads(__tstate);
7671 if (PyErr_Occurred()) SWIG_fail;
7672 }
7673 Py_INCREF(Py_None); resultobj = Py_None;
7674 return resultobj;
7675 fail:
7676 return NULL;
7677 }
7678
7679
7680 static PyObject *_wrap_NativeFontInfo_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
7681 PyObject *resultobj;
7682 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7683 int result;
7684 PyObject * obj0 = 0 ;
7685 char *kwnames[] = {
7686 (char *) "self", NULL
7687 };
7688
7689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetPointSize",kwnames,&obj0)) goto fail;
7690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7691 if (SWIG_arg_fail(1)) SWIG_fail;
7692 {
7693 PyThreadState* __tstate = wxPyBeginAllowThreads();
7694 result = (int)((wxNativeFontInfo const *)arg1)->GetPointSize();
7695
7696 wxPyEndAllowThreads(__tstate);
7697 if (PyErr_Occurred()) SWIG_fail;
7698 }
7699 {
7700 resultobj = SWIG_From_int((int)(result));
7701 }
7702 return resultobj;
7703 fail:
7704 return NULL;
7705 }
7706
7707
7708 static PyObject *_wrap_NativeFontInfo_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
7709 PyObject *resultobj;
7710 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7711 wxFontStyle result;
7712 PyObject * obj0 = 0 ;
7713 char *kwnames[] = {
7714 (char *) "self", NULL
7715 };
7716
7717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetStyle",kwnames,&obj0)) goto fail;
7718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7719 if (SWIG_arg_fail(1)) SWIG_fail;
7720 {
7721 PyThreadState* __tstate = wxPyBeginAllowThreads();
7722 result = (wxFontStyle)((wxNativeFontInfo const *)arg1)->GetStyle();
7723
7724 wxPyEndAllowThreads(__tstate);
7725 if (PyErr_Occurred()) SWIG_fail;
7726 }
7727 resultobj = SWIG_From_int((result));
7728 return resultobj;
7729 fail:
7730 return NULL;
7731 }
7732
7733
7734 static PyObject *_wrap_NativeFontInfo_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
7735 PyObject *resultobj;
7736 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7737 wxFontWeight result;
7738 PyObject * obj0 = 0 ;
7739 char *kwnames[] = {
7740 (char *) "self", NULL
7741 };
7742
7743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetWeight",kwnames,&obj0)) goto fail;
7744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7745 if (SWIG_arg_fail(1)) SWIG_fail;
7746 {
7747 PyThreadState* __tstate = wxPyBeginAllowThreads();
7748 result = (wxFontWeight)((wxNativeFontInfo const *)arg1)->GetWeight();
7749
7750 wxPyEndAllowThreads(__tstate);
7751 if (PyErr_Occurred()) SWIG_fail;
7752 }
7753 resultobj = SWIG_From_int((result));
7754 return resultobj;
7755 fail:
7756 return NULL;
7757 }
7758
7759
7760 static PyObject *_wrap_NativeFontInfo_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
7761 PyObject *resultobj;
7762 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7763 bool result;
7764 PyObject * obj0 = 0 ;
7765 char *kwnames[] = {
7766 (char *) "self", NULL
7767 };
7768
7769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetUnderlined",kwnames,&obj0)) goto fail;
7770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7771 if (SWIG_arg_fail(1)) SWIG_fail;
7772 {
7773 PyThreadState* __tstate = wxPyBeginAllowThreads();
7774 result = (bool)((wxNativeFontInfo const *)arg1)->GetUnderlined();
7775
7776 wxPyEndAllowThreads(__tstate);
7777 if (PyErr_Occurred()) SWIG_fail;
7778 }
7779 {
7780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7781 }
7782 return resultobj;
7783 fail:
7784 return NULL;
7785 }
7786
7787
7788 static PyObject *_wrap_NativeFontInfo_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
7789 PyObject *resultobj;
7790 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7791 wxString result;
7792 PyObject * obj0 = 0 ;
7793 char *kwnames[] = {
7794 (char *) "self", NULL
7795 };
7796
7797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFaceName",kwnames,&obj0)) goto fail;
7798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7799 if (SWIG_arg_fail(1)) SWIG_fail;
7800 {
7801 PyThreadState* __tstate = wxPyBeginAllowThreads();
7802 result = ((wxNativeFontInfo const *)arg1)->GetFaceName();
7803
7804 wxPyEndAllowThreads(__tstate);
7805 if (PyErr_Occurred()) SWIG_fail;
7806 }
7807 {
7808 #if wxUSE_UNICODE
7809 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7810 #else
7811 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7812 #endif
7813 }
7814 return resultobj;
7815 fail:
7816 return NULL;
7817 }
7818
7819
7820 static PyObject *_wrap_NativeFontInfo_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
7821 PyObject *resultobj;
7822 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7823 wxFontFamily result;
7824 PyObject * obj0 = 0 ;
7825 char *kwnames[] = {
7826 (char *) "self", NULL
7827 };
7828
7829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFamily",kwnames,&obj0)) goto fail;
7830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7831 if (SWIG_arg_fail(1)) SWIG_fail;
7832 {
7833 PyThreadState* __tstate = wxPyBeginAllowThreads();
7834 result = (wxFontFamily)((wxNativeFontInfo const *)arg1)->GetFamily();
7835
7836 wxPyEndAllowThreads(__tstate);
7837 if (PyErr_Occurred()) SWIG_fail;
7838 }
7839 resultobj = SWIG_From_int((result));
7840 return resultobj;
7841 fail:
7842 return NULL;
7843 }
7844
7845
7846 static PyObject *_wrap_NativeFontInfo_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
7847 PyObject *resultobj;
7848 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7849 wxFontEncoding result;
7850 PyObject * obj0 = 0 ;
7851 char *kwnames[] = {
7852 (char *) "self", NULL
7853 };
7854
7855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetEncoding",kwnames,&obj0)) goto fail;
7856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7857 if (SWIG_arg_fail(1)) SWIG_fail;
7858 {
7859 PyThreadState* __tstate = wxPyBeginAllowThreads();
7860 result = (wxFontEncoding)((wxNativeFontInfo const *)arg1)->GetEncoding();
7861
7862 wxPyEndAllowThreads(__tstate);
7863 if (PyErr_Occurred()) SWIG_fail;
7864 }
7865 resultobj = SWIG_From_int((result));
7866 return resultobj;
7867 fail:
7868 return NULL;
7869 }
7870
7871
7872 static PyObject *_wrap_NativeFontInfo_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
7873 PyObject *resultobj;
7874 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7875 int arg2 ;
7876 PyObject * obj0 = 0 ;
7877 PyObject * obj1 = 0 ;
7878 char *kwnames[] = {
7879 (char *) "self",(char *) "pointsize", NULL
7880 };
7881
7882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
7883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7884 if (SWIG_arg_fail(1)) SWIG_fail;
7885 {
7886 arg2 = (int)(SWIG_As_int(obj1));
7887 if (SWIG_arg_fail(2)) SWIG_fail;
7888 }
7889 {
7890 PyThreadState* __tstate = wxPyBeginAllowThreads();
7891 (arg1)->SetPointSize(arg2);
7892
7893 wxPyEndAllowThreads(__tstate);
7894 if (PyErr_Occurred()) SWIG_fail;
7895 }
7896 Py_INCREF(Py_None); resultobj = Py_None;
7897 return resultobj;
7898 fail:
7899 return NULL;
7900 }
7901
7902
7903 static PyObject *_wrap_NativeFontInfo_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
7904 PyObject *resultobj;
7905 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7906 wxFontStyle arg2 ;
7907 PyObject * obj0 = 0 ;
7908 PyObject * obj1 = 0 ;
7909 char *kwnames[] = {
7910 (char *) "self",(char *) "style", NULL
7911 };
7912
7913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetStyle",kwnames,&obj0,&obj1)) goto fail;
7914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7915 if (SWIG_arg_fail(1)) SWIG_fail;
7916 {
7917 arg2 = (wxFontStyle)(SWIG_As_int(obj1));
7918 if (SWIG_arg_fail(2)) SWIG_fail;
7919 }
7920 {
7921 PyThreadState* __tstate = wxPyBeginAllowThreads();
7922 (arg1)->SetStyle((wxFontStyle )arg2);
7923
7924 wxPyEndAllowThreads(__tstate);
7925 if (PyErr_Occurred()) SWIG_fail;
7926 }
7927 Py_INCREF(Py_None); resultobj = Py_None;
7928 return resultobj;
7929 fail:
7930 return NULL;
7931 }
7932
7933
7934 static PyObject *_wrap_NativeFontInfo_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
7935 PyObject *resultobj;
7936 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7937 wxFontWeight arg2 ;
7938 PyObject * obj0 = 0 ;
7939 PyObject * obj1 = 0 ;
7940 char *kwnames[] = {
7941 (char *) "self",(char *) "weight", NULL
7942 };
7943
7944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetWeight",kwnames,&obj0,&obj1)) goto fail;
7945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7946 if (SWIG_arg_fail(1)) SWIG_fail;
7947 {
7948 arg2 = (wxFontWeight)(SWIG_As_int(obj1));
7949 if (SWIG_arg_fail(2)) SWIG_fail;
7950 }
7951 {
7952 PyThreadState* __tstate = wxPyBeginAllowThreads();
7953 (arg1)->SetWeight((wxFontWeight )arg2);
7954
7955 wxPyEndAllowThreads(__tstate);
7956 if (PyErr_Occurred()) SWIG_fail;
7957 }
7958 Py_INCREF(Py_None); resultobj = Py_None;
7959 return resultobj;
7960 fail:
7961 return NULL;
7962 }
7963
7964
7965 static PyObject *_wrap_NativeFontInfo_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
7966 PyObject *resultobj;
7967 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7968 bool arg2 ;
7969 PyObject * obj0 = 0 ;
7970 PyObject * obj1 = 0 ;
7971 char *kwnames[] = {
7972 (char *) "self",(char *) "underlined", NULL
7973 };
7974
7975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
7976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7977 if (SWIG_arg_fail(1)) SWIG_fail;
7978 {
7979 arg2 = (bool)(SWIG_As_bool(obj1));
7980 if (SWIG_arg_fail(2)) SWIG_fail;
7981 }
7982 {
7983 PyThreadState* __tstate = wxPyBeginAllowThreads();
7984 (arg1)->SetUnderlined(arg2);
7985
7986 wxPyEndAllowThreads(__tstate);
7987 if (PyErr_Occurred()) SWIG_fail;
7988 }
7989 Py_INCREF(Py_None); resultobj = Py_None;
7990 return resultobj;
7991 fail:
7992 return NULL;
7993 }
7994
7995
7996 static PyObject *_wrap_NativeFontInfo_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
7997 PyObject *resultobj;
7998 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7999 wxString arg2 ;
8000 PyObject * obj0 = 0 ;
8001 PyObject * obj1 = 0 ;
8002 char *kwnames[] = {
8003 (char *) "self",(char *) "facename", NULL
8004 };
8005
8006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
8007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8008 if (SWIG_arg_fail(1)) SWIG_fail;
8009 {
8010 wxString* sptr = wxString_in_helper(obj1);
8011 if (sptr == NULL) SWIG_fail;
8012 arg2 = *sptr;
8013 delete sptr;
8014 }
8015 {
8016 PyThreadState* __tstate = wxPyBeginAllowThreads();
8017 (arg1)->SetFaceName(arg2);
8018
8019 wxPyEndAllowThreads(__tstate);
8020 if (PyErr_Occurred()) SWIG_fail;
8021 }
8022 Py_INCREF(Py_None); resultobj = Py_None;
8023 return resultobj;
8024 fail:
8025 return NULL;
8026 }
8027
8028
8029 static PyObject *_wrap_NativeFontInfo_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
8030 PyObject *resultobj;
8031 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8032 wxFontFamily arg2 ;
8033 PyObject * obj0 = 0 ;
8034 PyObject * obj1 = 0 ;
8035 char *kwnames[] = {
8036 (char *) "self",(char *) "family", NULL
8037 };
8038
8039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFamily",kwnames,&obj0,&obj1)) goto fail;
8040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8041 if (SWIG_arg_fail(1)) SWIG_fail;
8042 {
8043 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
8044 if (SWIG_arg_fail(2)) SWIG_fail;
8045 }
8046 {
8047 PyThreadState* __tstate = wxPyBeginAllowThreads();
8048 (arg1)->SetFamily((wxFontFamily )arg2);
8049
8050 wxPyEndAllowThreads(__tstate);
8051 if (PyErr_Occurred()) SWIG_fail;
8052 }
8053 Py_INCREF(Py_None); resultobj = Py_None;
8054 return resultobj;
8055 fail:
8056 return NULL;
8057 }
8058
8059
8060 static PyObject *_wrap_NativeFontInfo_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8061 PyObject *resultobj;
8062 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8063 wxFontEncoding arg2 ;
8064 PyObject * obj0 = 0 ;
8065 PyObject * obj1 = 0 ;
8066 char *kwnames[] = {
8067 (char *) "self",(char *) "encoding", NULL
8068 };
8069
8070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
8071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8072 if (SWIG_arg_fail(1)) SWIG_fail;
8073 {
8074 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8075 if (SWIG_arg_fail(2)) SWIG_fail;
8076 }
8077 {
8078 PyThreadState* __tstate = wxPyBeginAllowThreads();
8079 (arg1)->SetEncoding((wxFontEncoding )arg2);
8080
8081 wxPyEndAllowThreads(__tstate);
8082 if (PyErr_Occurred()) SWIG_fail;
8083 }
8084 Py_INCREF(Py_None); resultobj = Py_None;
8085 return resultobj;
8086 fail:
8087 return NULL;
8088 }
8089
8090
8091 static PyObject *_wrap_NativeFontInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
8092 PyObject *resultobj;
8093 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8094 wxString *arg2 = 0 ;
8095 bool result;
8096 bool temp2 = false ;
8097 PyObject * obj0 = 0 ;
8098 PyObject * obj1 = 0 ;
8099 char *kwnames[] = {
8100 (char *) "self",(char *) "s", NULL
8101 };
8102
8103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
8104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8105 if (SWIG_arg_fail(1)) SWIG_fail;
8106 {
8107 arg2 = wxString_in_helper(obj1);
8108 if (arg2 == NULL) SWIG_fail;
8109 temp2 = true;
8110 }
8111 {
8112 PyThreadState* __tstate = wxPyBeginAllowThreads();
8113 result = (bool)(arg1)->FromString((wxString const &)*arg2);
8114
8115 wxPyEndAllowThreads(__tstate);
8116 if (PyErr_Occurred()) SWIG_fail;
8117 }
8118 {
8119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8120 }
8121 {
8122 if (temp2)
8123 delete arg2;
8124 }
8125 return resultobj;
8126 fail:
8127 {
8128 if (temp2)
8129 delete arg2;
8130 }
8131 return NULL;
8132 }
8133
8134
8135 static PyObject *_wrap_NativeFontInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
8136 PyObject *resultobj;
8137 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8138 wxString result;
8139 PyObject * obj0 = 0 ;
8140 char *kwnames[] = {
8141 (char *) "self", NULL
8142 };
8143
8144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToString",kwnames,&obj0)) goto fail;
8145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8146 if (SWIG_arg_fail(1)) SWIG_fail;
8147 {
8148 PyThreadState* __tstate = wxPyBeginAllowThreads();
8149 result = ((wxNativeFontInfo const *)arg1)->ToString();
8150
8151 wxPyEndAllowThreads(__tstate);
8152 if (PyErr_Occurred()) SWIG_fail;
8153 }
8154 {
8155 #if wxUSE_UNICODE
8156 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8157 #else
8158 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8159 #endif
8160 }
8161 return resultobj;
8162 fail:
8163 return NULL;
8164 }
8165
8166
8167 static PyObject *_wrap_NativeFontInfo___str__(PyObject *, PyObject *args, PyObject *kwargs) {
8168 PyObject *resultobj;
8169 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8170 wxString result;
8171 PyObject * obj0 = 0 ;
8172 char *kwnames[] = {
8173 (char *) "self", NULL
8174 };
8175
8176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo___str__",kwnames,&obj0)) goto fail;
8177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8178 if (SWIG_arg_fail(1)) SWIG_fail;
8179 {
8180 PyThreadState* __tstate = wxPyBeginAllowThreads();
8181 result = wxNativeFontInfo___str__(arg1);
8182
8183 wxPyEndAllowThreads(__tstate);
8184 if (PyErr_Occurred()) SWIG_fail;
8185 }
8186 {
8187 #if wxUSE_UNICODE
8188 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8189 #else
8190 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8191 #endif
8192 }
8193 return resultobj;
8194 fail:
8195 return NULL;
8196 }
8197
8198
8199 static PyObject *_wrap_NativeFontInfo_FromUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8200 PyObject *resultobj;
8201 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8202 wxString *arg2 = 0 ;
8203 bool result;
8204 bool temp2 = false ;
8205 PyObject * obj0 = 0 ;
8206 PyObject * obj1 = 0 ;
8207 char *kwnames[] = {
8208 (char *) "self",(char *) "s", NULL
8209 };
8210
8211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromUserString",kwnames,&obj0,&obj1)) goto fail;
8212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8213 if (SWIG_arg_fail(1)) SWIG_fail;
8214 {
8215 arg2 = wxString_in_helper(obj1);
8216 if (arg2 == NULL) SWIG_fail;
8217 temp2 = true;
8218 }
8219 {
8220 PyThreadState* __tstate = wxPyBeginAllowThreads();
8221 result = (bool)(arg1)->FromUserString((wxString const &)*arg2);
8222
8223 wxPyEndAllowThreads(__tstate);
8224 if (PyErr_Occurred()) SWIG_fail;
8225 }
8226 {
8227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8228 }
8229 {
8230 if (temp2)
8231 delete arg2;
8232 }
8233 return resultobj;
8234 fail:
8235 {
8236 if (temp2)
8237 delete arg2;
8238 }
8239 return NULL;
8240 }
8241
8242
8243 static PyObject *_wrap_NativeFontInfo_ToUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8244 PyObject *resultobj;
8245 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8246 wxString result;
8247 PyObject * obj0 = 0 ;
8248 char *kwnames[] = {
8249 (char *) "self", NULL
8250 };
8251
8252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToUserString",kwnames,&obj0)) goto fail;
8253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8254 if (SWIG_arg_fail(1)) SWIG_fail;
8255 {
8256 PyThreadState* __tstate = wxPyBeginAllowThreads();
8257 result = ((wxNativeFontInfo const *)arg1)->ToUserString();
8258
8259 wxPyEndAllowThreads(__tstate);
8260 if (PyErr_Occurred()) SWIG_fail;
8261 }
8262 {
8263 #if wxUSE_UNICODE
8264 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8265 #else
8266 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8267 #endif
8268 }
8269 return resultobj;
8270 fail:
8271 return NULL;
8272 }
8273
8274
8275 static PyObject * NativeFontInfo_swigregister(PyObject *, PyObject *args) {
8276 PyObject *obj;
8277 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8278 SWIG_TypeClientData(SWIGTYPE_p_wxNativeFontInfo, obj);
8279 Py_INCREF(obj);
8280 return Py_BuildValue((char *)"");
8281 }
8282 static PyObject *_wrap_NativeEncodingInfo_facename_set(PyObject *, PyObject *args, PyObject *kwargs) {
8283 PyObject *resultobj;
8284 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8285 wxString *arg2 = (wxString *) 0 ;
8286 bool temp2 = false ;
8287 PyObject * obj0 = 0 ;
8288 PyObject * obj1 = 0 ;
8289 char *kwnames[] = {
8290 (char *) "self",(char *) "facename", NULL
8291 };
8292
8293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_facename_set",kwnames,&obj0,&obj1)) goto fail;
8294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8295 if (SWIG_arg_fail(1)) SWIG_fail;
8296 {
8297 arg2 = wxString_in_helper(obj1);
8298 if (arg2 == NULL) SWIG_fail;
8299 temp2 = true;
8300 }
8301 if (arg1) (arg1)->facename = *arg2;
8302
8303 Py_INCREF(Py_None); resultobj = Py_None;
8304 {
8305 if (temp2)
8306 delete arg2;
8307 }
8308 return resultobj;
8309 fail:
8310 {
8311 if (temp2)
8312 delete arg2;
8313 }
8314 return NULL;
8315 }
8316
8317
8318 static PyObject *_wrap_NativeEncodingInfo_facename_get(PyObject *, PyObject *args, PyObject *kwargs) {
8319 PyObject *resultobj;
8320 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8321 wxString *result;
8322 PyObject * obj0 = 0 ;
8323 char *kwnames[] = {
8324 (char *) "self", NULL
8325 };
8326
8327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_facename_get",kwnames,&obj0)) goto fail;
8328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8329 if (SWIG_arg_fail(1)) SWIG_fail;
8330 result = (wxString *)& ((arg1)->facename);
8331
8332 {
8333 #if wxUSE_UNICODE
8334 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8335 #else
8336 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8337 #endif
8338 }
8339 return resultobj;
8340 fail:
8341 return NULL;
8342 }
8343
8344
8345 static PyObject *_wrap_NativeEncodingInfo_encoding_set(PyObject *, PyObject *args, PyObject *kwargs) {
8346 PyObject *resultobj;
8347 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8348 wxFontEncoding arg2 ;
8349 PyObject * obj0 = 0 ;
8350 PyObject * obj1 = 0 ;
8351 char *kwnames[] = {
8352 (char *) "self",(char *) "encoding", NULL
8353 };
8354
8355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_encoding_set",kwnames,&obj0,&obj1)) goto fail;
8356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8357 if (SWIG_arg_fail(1)) SWIG_fail;
8358 {
8359 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8360 if (SWIG_arg_fail(2)) SWIG_fail;
8361 }
8362 if (arg1) (arg1)->encoding = (wxFontEncoding )arg2;
8363
8364 Py_INCREF(Py_None); resultobj = Py_None;
8365 return resultobj;
8366 fail:
8367 return NULL;
8368 }
8369
8370
8371 static PyObject *_wrap_NativeEncodingInfo_encoding_get(PyObject *, PyObject *args, PyObject *kwargs) {
8372 PyObject *resultobj;
8373 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8374 wxFontEncoding result;
8375 PyObject * obj0 = 0 ;
8376 char *kwnames[] = {
8377 (char *) "self", NULL
8378 };
8379
8380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_encoding_get",kwnames,&obj0)) goto fail;
8381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8382 if (SWIG_arg_fail(1)) SWIG_fail;
8383 result = (wxFontEncoding) ((arg1)->encoding);
8384
8385 resultobj = SWIG_From_int((result));
8386 return resultobj;
8387 fail:
8388 return NULL;
8389 }
8390
8391
8392 static PyObject *_wrap_new_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8393 PyObject *resultobj;
8394 wxNativeEncodingInfo *result;
8395 char *kwnames[] = {
8396 NULL
8397 };
8398
8399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeEncodingInfo",kwnames)) goto fail;
8400 {
8401 PyThreadState* __tstate = wxPyBeginAllowThreads();
8402 result = (wxNativeEncodingInfo *)new wxNativeEncodingInfo();
8403
8404 wxPyEndAllowThreads(__tstate);
8405 if (PyErr_Occurred()) SWIG_fail;
8406 }
8407 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 1);
8408 return resultobj;
8409 fail:
8410 return NULL;
8411 }
8412
8413
8414 static PyObject *_wrap_delete_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8415 PyObject *resultobj;
8416 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8417 PyObject * obj0 = 0 ;
8418 char *kwnames[] = {
8419 (char *) "self", NULL
8420 };
8421
8422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeEncodingInfo",kwnames,&obj0)) goto fail;
8423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8424 if (SWIG_arg_fail(1)) SWIG_fail;
8425 {
8426 PyThreadState* __tstate = wxPyBeginAllowThreads();
8427 delete arg1;
8428
8429 wxPyEndAllowThreads(__tstate);
8430 if (PyErr_Occurred()) SWIG_fail;
8431 }
8432 Py_INCREF(Py_None); resultobj = Py_None;
8433 return resultobj;
8434 fail:
8435 return NULL;
8436 }
8437
8438
8439 static PyObject *_wrap_NativeEncodingInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
8440 PyObject *resultobj;
8441 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8442 wxString *arg2 = 0 ;
8443 bool result;
8444 bool temp2 = false ;
8445 PyObject * obj0 = 0 ;
8446 PyObject * obj1 = 0 ;
8447 char *kwnames[] = {
8448 (char *) "self",(char *) "s", NULL
8449 };
8450
8451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
8452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8453 if (SWIG_arg_fail(1)) SWIG_fail;
8454 {
8455 arg2 = wxString_in_helper(obj1);
8456 if (arg2 == NULL) SWIG_fail;
8457 temp2 = true;
8458 }
8459 {
8460 PyThreadState* __tstate = wxPyBeginAllowThreads();
8461 result = (bool)(arg1)->FromString((wxString const &)*arg2);
8462
8463 wxPyEndAllowThreads(__tstate);
8464 if (PyErr_Occurred()) SWIG_fail;
8465 }
8466 {
8467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8468 }
8469 {
8470 if (temp2)
8471 delete arg2;
8472 }
8473 return resultobj;
8474 fail:
8475 {
8476 if (temp2)
8477 delete arg2;
8478 }
8479 return NULL;
8480 }
8481
8482
8483 static PyObject *_wrap_NativeEncodingInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
8484 PyObject *resultobj;
8485 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8486 wxString result;
8487 PyObject * obj0 = 0 ;
8488 char *kwnames[] = {
8489 (char *) "self", NULL
8490 };
8491
8492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_ToString",kwnames,&obj0)) goto fail;
8493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8494 if (SWIG_arg_fail(1)) SWIG_fail;
8495 {
8496 PyThreadState* __tstate = wxPyBeginAllowThreads();
8497 result = ((wxNativeEncodingInfo const *)arg1)->ToString();
8498
8499 wxPyEndAllowThreads(__tstate);
8500 if (PyErr_Occurred()) SWIG_fail;
8501 }
8502 {
8503 #if wxUSE_UNICODE
8504 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8505 #else
8506 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8507 #endif
8508 }
8509 return resultobj;
8510 fail:
8511 return NULL;
8512 }
8513
8514
8515 static PyObject * NativeEncodingInfo_swigregister(PyObject *, PyObject *args) {
8516 PyObject *obj;
8517 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8518 SWIG_TypeClientData(SWIGTYPE_p_wxNativeEncodingInfo, obj);
8519 Py_INCREF(obj);
8520 return Py_BuildValue((char *)"");
8521 }
8522 static PyObject *_wrap_GetNativeFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8523 PyObject *resultobj;
8524 wxFontEncoding arg1 ;
8525 wxNativeEncodingInfo *result;
8526 PyObject * obj0 = 0 ;
8527 char *kwnames[] = {
8528 (char *) "encoding", NULL
8529 };
8530
8531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetNativeFontEncoding",kwnames,&obj0)) goto fail;
8532 {
8533 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8534 if (SWIG_arg_fail(1)) SWIG_fail;
8535 }
8536 {
8537 PyThreadState* __tstate = wxPyBeginAllowThreads();
8538 result = (wxNativeEncodingInfo *)wxGetNativeFontEncoding((wxFontEncoding )arg1);
8539
8540 wxPyEndAllowThreads(__tstate);
8541 if (PyErr_Occurred()) SWIG_fail;
8542 }
8543 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 0);
8544 return resultobj;
8545 fail:
8546 return NULL;
8547 }
8548
8549
8550 static PyObject *_wrap_TestFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8551 PyObject *resultobj;
8552 wxNativeEncodingInfo *arg1 = 0 ;
8553 bool result;
8554 PyObject * obj0 = 0 ;
8555 char *kwnames[] = {
8556 (char *) "info", NULL
8557 };
8558
8559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TestFontEncoding",kwnames,&obj0)) goto fail;
8560 {
8561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8562 if (SWIG_arg_fail(1)) SWIG_fail;
8563 if (arg1 == NULL) {
8564 SWIG_null_ref("wxNativeEncodingInfo");
8565 }
8566 if (SWIG_arg_fail(1)) SWIG_fail;
8567 }
8568 {
8569 PyThreadState* __tstate = wxPyBeginAllowThreads();
8570 result = (bool)wxTestFontEncoding((wxNativeEncodingInfo const &)*arg1);
8571
8572 wxPyEndAllowThreads(__tstate);
8573 if (PyErr_Occurred()) SWIG_fail;
8574 }
8575 {
8576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8577 }
8578 return resultobj;
8579 fail:
8580 return NULL;
8581 }
8582
8583
8584 static PyObject *_wrap_new_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
8585 PyObject *resultobj;
8586 wxFontMapper *result;
8587 char *kwnames[] = {
8588 NULL
8589 };
8590
8591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontMapper",kwnames)) goto fail;
8592 {
8593 PyThreadState* __tstate = wxPyBeginAllowThreads();
8594 result = (wxFontMapper *)new wxFontMapper();
8595
8596 wxPyEndAllowThreads(__tstate);
8597 if (PyErr_Occurred()) SWIG_fail;
8598 }
8599 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 1);
8600 return resultobj;
8601 fail:
8602 return NULL;
8603 }
8604
8605
8606 static PyObject *_wrap_delete_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
8607 PyObject *resultobj;
8608 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8609 PyObject * obj0 = 0 ;
8610 char *kwnames[] = {
8611 (char *) "self", NULL
8612 };
8613
8614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontMapper",kwnames,&obj0)) goto fail;
8615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8616 if (SWIG_arg_fail(1)) SWIG_fail;
8617 {
8618 PyThreadState* __tstate = wxPyBeginAllowThreads();
8619 delete arg1;
8620
8621 wxPyEndAllowThreads(__tstate);
8622 if (PyErr_Occurred()) SWIG_fail;
8623 }
8624 Py_INCREF(Py_None); resultobj = Py_None;
8625 return resultobj;
8626 fail:
8627 return NULL;
8628 }
8629
8630
8631 static PyObject *_wrap_FontMapper_Get(PyObject *, PyObject *args, PyObject *kwargs) {
8632 PyObject *resultobj;
8633 wxFontMapper *result;
8634 char *kwnames[] = {
8635 NULL
8636 };
8637
8638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_Get",kwnames)) goto fail;
8639 {
8640 PyThreadState* __tstate = wxPyBeginAllowThreads();
8641 result = (wxFontMapper *)wxFontMapper::Get();
8642
8643 wxPyEndAllowThreads(__tstate);
8644 if (PyErr_Occurred()) SWIG_fail;
8645 }
8646 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
8647 return resultobj;
8648 fail:
8649 return NULL;
8650 }
8651
8652
8653 static PyObject *_wrap_FontMapper_Set(PyObject *, PyObject *args, PyObject *kwargs) {
8654 PyObject *resultobj;
8655 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8656 wxFontMapper *result;
8657 PyObject * obj0 = 0 ;
8658 char *kwnames[] = {
8659 (char *) "mapper", NULL
8660 };
8661
8662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_Set",kwnames,&obj0)) goto fail;
8663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8664 if (SWIG_arg_fail(1)) SWIG_fail;
8665 {
8666 PyThreadState* __tstate = wxPyBeginAllowThreads();
8667 result = (wxFontMapper *)wxFontMapper::Set(arg1);
8668
8669 wxPyEndAllowThreads(__tstate);
8670 if (PyErr_Occurred()) SWIG_fail;
8671 }
8672 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
8673 return resultobj;
8674 fail:
8675 return NULL;
8676 }
8677
8678
8679 static PyObject *_wrap_FontMapper_CharsetToEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8680 PyObject *resultobj;
8681 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8682 wxString *arg2 = 0 ;
8683 bool arg3 = (bool) true ;
8684 wxFontEncoding result;
8685 bool temp2 = false ;
8686 PyObject * obj0 = 0 ;
8687 PyObject * obj1 = 0 ;
8688 PyObject * obj2 = 0 ;
8689 char *kwnames[] = {
8690 (char *) "self",(char *) "charset",(char *) "interactive", NULL
8691 };
8692
8693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_CharsetToEncoding",kwnames,&obj0,&obj1,&obj2)) goto fail;
8694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8695 if (SWIG_arg_fail(1)) SWIG_fail;
8696 {
8697 arg2 = wxString_in_helper(obj1);
8698 if (arg2 == NULL) SWIG_fail;
8699 temp2 = true;
8700 }
8701 if (obj2) {
8702 {
8703 arg3 = (bool)(SWIG_As_bool(obj2));
8704 if (SWIG_arg_fail(3)) SWIG_fail;
8705 }
8706 }
8707 {
8708 PyThreadState* __tstate = wxPyBeginAllowThreads();
8709 result = (wxFontEncoding)(arg1)->CharsetToEncoding((wxString const &)*arg2,arg3);
8710
8711 wxPyEndAllowThreads(__tstate);
8712 if (PyErr_Occurred()) SWIG_fail;
8713 }
8714 resultobj = SWIG_From_int((result));
8715 {
8716 if (temp2)
8717 delete arg2;
8718 }
8719 return resultobj;
8720 fail:
8721 {
8722 if (temp2)
8723 delete arg2;
8724 }
8725 return NULL;
8726 }
8727
8728
8729 static PyObject *_wrap_FontMapper_GetSupportedEncodingsCount(PyObject *, PyObject *args, PyObject *kwargs) {
8730 PyObject *resultobj;
8731 size_t result;
8732 char *kwnames[] = {
8733 NULL
8734 };
8735
8736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetSupportedEncodingsCount",kwnames)) goto fail;
8737 {
8738 PyThreadState* __tstate = wxPyBeginAllowThreads();
8739 result = (size_t)wxFontMapper::GetSupportedEncodingsCount();
8740
8741 wxPyEndAllowThreads(__tstate);
8742 if (PyErr_Occurred()) SWIG_fail;
8743 }
8744 {
8745 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
8746 }
8747 return resultobj;
8748 fail:
8749 return NULL;
8750 }
8751
8752
8753 static PyObject *_wrap_FontMapper_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8754 PyObject *resultobj;
8755 size_t arg1 ;
8756 wxFontEncoding result;
8757 PyObject * obj0 = 0 ;
8758 char *kwnames[] = {
8759 (char *) "n", NULL
8760 };
8761
8762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncoding",kwnames,&obj0)) goto fail;
8763 {
8764 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8765 if (SWIG_arg_fail(1)) SWIG_fail;
8766 }
8767 {
8768 PyThreadState* __tstate = wxPyBeginAllowThreads();
8769 result = (wxFontEncoding)wxFontMapper::GetEncoding(arg1);
8770
8771 wxPyEndAllowThreads(__tstate);
8772 if (PyErr_Occurred()) SWIG_fail;
8773 }
8774 resultobj = SWIG_From_int((result));
8775 return resultobj;
8776 fail:
8777 return NULL;
8778 }
8779
8780
8781 static PyObject *_wrap_FontMapper_GetEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
8782 PyObject *resultobj;
8783 wxFontEncoding arg1 ;
8784 wxString result;
8785 PyObject * obj0 = 0 ;
8786 char *kwnames[] = {
8787 (char *) "encoding", NULL
8788 };
8789
8790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingName",kwnames,&obj0)) goto fail;
8791 {
8792 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8793 if (SWIG_arg_fail(1)) SWIG_fail;
8794 }
8795 {
8796 PyThreadState* __tstate = wxPyBeginAllowThreads();
8797 result = wxFontMapper::GetEncodingName((wxFontEncoding )arg1);
8798
8799 wxPyEndAllowThreads(__tstate);
8800 if (PyErr_Occurred()) SWIG_fail;
8801 }
8802 {
8803 #if wxUSE_UNICODE
8804 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8805 #else
8806 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8807 #endif
8808 }
8809 return resultobj;
8810 fail:
8811 return NULL;
8812 }
8813
8814
8815 static PyObject *_wrap_FontMapper_GetEncodingDescription(PyObject *, PyObject *args, PyObject *kwargs) {
8816 PyObject *resultobj;
8817 wxFontEncoding arg1 ;
8818 wxString result;
8819 PyObject * obj0 = 0 ;
8820 char *kwnames[] = {
8821 (char *) "encoding", NULL
8822 };
8823
8824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingDescription",kwnames,&obj0)) goto fail;
8825 {
8826 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8827 if (SWIG_arg_fail(1)) SWIG_fail;
8828 }
8829 {
8830 PyThreadState* __tstate = wxPyBeginAllowThreads();
8831 result = wxFontMapper::GetEncodingDescription((wxFontEncoding )arg1);
8832
8833 wxPyEndAllowThreads(__tstate);
8834 if (PyErr_Occurred()) SWIG_fail;
8835 }
8836 {
8837 #if wxUSE_UNICODE
8838 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8839 #else
8840 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8841 #endif
8842 }
8843 return resultobj;
8844 fail:
8845 return NULL;
8846 }
8847
8848
8849 static PyObject *_wrap_FontMapper_GetEncodingFromName(PyObject *, PyObject *args, PyObject *kwargs) {
8850 PyObject *resultobj;
8851 wxString *arg1 = 0 ;
8852 wxFontEncoding result;
8853 bool temp1 = false ;
8854 PyObject * obj0 = 0 ;
8855 char *kwnames[] = {
8856 (char *) "name", NULL
8857 };
8858
8859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingFromName",kwnames,&obj0)) goto fail;
8860 {
8861 arg1 = wxString_in_helper(obj0);
8862 if (arg1 == NULL) SWIG_fail;
8863 temp1 = true;
8864 }
8865 {
8866 PyThreadState* __tstate = wxPyBeginAllowThreads();
8867 result = (wxFontEncoding)wxFontMapper::GetEncodingFromName((wxString const &)*arg1);
8868
8869 wxPyEndAllowThreads(__tstate);
8870 if (PyErr_Occurred()) SWIG_fail;
8871 }
8872 resultobj = SWIG_From_int((result));
8873 {
8874 if (temp1)
8875 delete arg1;
8876 }
8877 return resultobj;
8878 fail:
8879 {
8880 if (temp1)
8881 delete arg1;
8882 }
8883 return NULL;
8884 }
8885
8886
8887 static PyObject *_wrap_FontMapper_SetConfig(PyObject *, PyObject *args, PyObject *kwargs) {
8888 PyObject *resultobj;
8889 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8890 wxConfigBase *arg2 = (wxConfigBase *) 0 ;
8891 PyObject * obj0 = 0 ;
8892 PyObject * obj1 = 0 ;
8893 char *kwnames[] = {
8894 (char *) "self",(char *) "config", NULL
8895 };
8896
8897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfig",kwnames,&obj0,&obj1)) goto fail;
8898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8899 if (SWIG_arg_fail(1)) SWIG_fail;
8900 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
8901 if (SWIG_arg_fail(2)) SWIG_fail;
8902 {
8903 PyThreadState* __tstate = wxPyBeginAllowThreads();
8904 (arg1)->SetConfig(arg2);
8905
8906 wxPyEndAllowThreads(__tstate);
8907 if (PyErr_Occurred()) SWIG_fail;
8908 }
8909 Py_INCREF(Py_None); resultobj = Py_None;
8910 return resultobj;
8911 fail:
8912 return NULL;
8913 }
8914
8915
8916 static PyObject *_wrap_FontMapper_SetConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
8917 PyObject *resultobj;
8918 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8919 wxString *arg2 = 0 ;
8920 bool temp2 = false ;
8921 PyObject * obj0 = 0 ;
8922 PyObject * obj1 = 0 ;
8923 char *kwnames[] = {
8924 (char *) "self",(char *) "prefix", NULL
8925 };
8926
8927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfigPath",kwnames,&obj0,&obj1)) goto fail;
8928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8929 if (SWIG_arg_fail(1)) SWIG_fail;
8930 {
8931 arg2 = wxString_in_helper(obj1);
8932 if (arg2 == NULL) SWIG_fail;
8933 temp2 = true;
8934 }
8935 {
8936 PyThreadState* __tstate = wxPyBeginAllowThreads();
8937 (arg1)->SetConfigPath((wxString const &)*arg2);
8938
8939 wxPyEndAllowThreads(__tstate);
8940 if (PyErr_Occurred()) SWIG_fail;
8941 }
8942 Py_INCREF(Py_None); resultobj = Py_None;
8943 {
8944 if (temp2)
8945 delete arg2;
8946 }
8947 return resultobj;
8948 fail:
8949 {
8950 if (temp2)
8951 delete arg2;
8952 }
8953 return NULL;
8954 }
8955
8956
8957 static PyObject *_wrap_FontMapper_GetDefaultConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
8958 PyObject *resultobj;
8959 wxString result;
8960 char *kwnames[] = {
8961 NULL
8962 };
8963
8964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetDefaultConfigPath",kwnames)) goto fail;
8965 {
8966 PyThreadState* __tstate = wxPyBeginAllowThreads();
8967 result = wxFontMapper::GetDefaultConfigPath();
8968
8969 wxPyEndAllowThreads(__tstate);
8970 if (PyErr_Occurred()) SWIG_fail;
8971 }
8972 {
8973 #if wxUSE_UNICODE
8974 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8975 #else
8976 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8977 #endif
8978 }
8979 return resultobj;
8980 fail:
8981 return NULL;
8982 }
8983
8984
8985 static PyObject *_wrap_FontMapper_GetAltForEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8986 PyObject *resultobj;
8987 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8988 wxFontEncoding arg2 ;
8989 wxString const &arg3_defvalue = wxPyEmptyString ;
8990 wxString *arg3 = (wxString *) &arg3_defvalue ;
8991 bool arg4 = (bool) true ;
8992 PyObject *result;
8993 bool temp3 = false ;
8994 PyObject * obj0 = 0 ;
8995 PyObject * obj1 = 0 ;
8996 PyObject * obj2 = 0 ;
8997 PyObject * obj3 = 0 ;
8998 char *kwnames[] = {
8999 (char *) "self",(char *) "encoding",(char *) "facename",(char *) "interactive", NULL
9000 };
9001
9002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:FontMapper_GetAltForEncoding",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9004 if (SWIG_arg_fail(1)) SWIG_fail;
9005 {
9006 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9007 if (SWIG_arg_fail(2)) SWIG_fail;
9008 }
9009 if (obj2) {
9010 {
9011 arg3 = wxString_in_helper(obj2);
9012 if (arg3 == NULL) SWIG_fail;
9013 temp3 = true;
9014 }
9015 }
9016 if (obj3) {
9017 {
9018 arg4 = (bool)(SWIG_As_bool(obj3));
9019 if (SWIG_arg_fail(4)) SWIG_fail;
9020 }
9021 }
9022 {
9023 PyThreadState* __tstate = wxPyBeginAllowThreads();
9024 result = (PyObject *)wxFontMapper_GetAltForEncoding(arg1,(wxFontEncoding )arg2,(wxString const &)*arg3,arg4);
9025
9026 wxPyEndAllowThreads(__tstate);
9027 if (PyErr_Occurred()) SWIG_fail;
9028 }
9029 resultobj = result;
9030 {
9031 if (temp3)
9032 delete arg3;
9033 }
9034 return resultobj;
9035 fail:
9036 {
9037 if (temp3)
9038 delete arg3;
9039 }
9040 return NULL;
9041 }
9042
9043
9044 static PyObject *_wrap_FontMapper_IsEncodingAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
9045 PyObject *resultobj;
9046 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9047 wxFontEncoding arg2 ;
9048 wxString const &arg3_defvalue = wxPyEmptyString ;
9049 wxString *arg3 = (wxString *) &arg3_defvalue ;
9050 bool result;
9051 bool temp3 = false ;
9052 PyObject * obj0 = 0 ;
9053 PyObject * obj1 = 0 ;
9054 PyObject * obj2 = 0 ;
9055 char *kwnames[] = {
9056 (char *) "self",(char *) "encoding",(char *) "facename", NULL
9057 };
9058
9059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_IsEncodingAvailable",kwnames,&obj0,&obj1,&obj2)) goto fail;
9060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9061 if (SWIG_arg_fail(1)) SWIG_fail;
9062 {
9063 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9064 if (SWIG_arg_fail(2)) SWIG_fail;
9065 }
9066 if (obj2) {
9067 {
9068 arg3 = wxString_in_helper(obj2);
9069 if (arg3 == NULL) SWIG_fail;
9070 temp3 = true;
9071 }
9072 }
9073 {
9074 PyThreadState* __tstate = wxPyBeginAllowThreads();
9075 result = (bool)(arg1)->IsEncodingAvailable((wxFontEncoding )arg2,(wxString const &)*arg3);
9076
9077 wxPyEndAllowThreads(__tstate);
9078 if (PyErr_Occurred()) SWIG_fail;
9079 }
9080 {
9081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9082 }
9083 {
9084 if (temp3)
9085 delete arg3;
9086 }
9087 return resultobj;
9088 fail:
9089 {
9090 if (temp3)
9091 delete arg3;
9092 }
9093 return NULL;
9094 }
9095
9096
9097 static PyObject *_wrap_FontMapper_SetDialogParent(PyObject *, PyObject *args, PyObject *kwargs) {
9098 PyObject *resultobj;
9099 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9100 wxWindow *arg2 = (wxWindow *) 0 ;
9101 PyObject * obj0 = 0 ;
9102 PyObject * obj1 = 0 ;
9103 char *kwnames[] = {
9104 (char *) "self",(char *) "parent", NULL
9105 };
9106
9107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogParent",kwnames,&obj0,&obj1)) goto fail;
9108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9109 if (SWIG_arg_fail(1)) SWIG_fail;
9110 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
9111 if (SWIG_arg_fail(2)) SWIG_fail;
9112 {
9113 PyThreadState* __tstate = wxPyBeginAllowThreads();
9114 (arg1)->SetDialogParent(arg2);
9115
9116 wxPyEndAllowThreads(__tstate);
9117 if (PyErr_Occurred()) SWIG_fail;
9118 }
9119 Py_INCREF(Py_None); resultobj = Py_None;
9120 return resultobj;
9121 fail:
9122 return NULL;
9123 }
9124
9125
9126 static PyObject *_wrap_FontMapper_SetDialogTitle(PyObject *, PyObject *args, PyObject *kwargs) {
9127 PyObject *resultobj;
9128 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9129 wxString *arg2 = 0 ;
9130 bool temp2 = false ;
9131 PyObject * obj0 = 0 ;
9132 PyObject * obj1 = 0 ;
9133 char *kwnames[] = {
9134 (char *) "self",(char *) "title", NULL
9135 };
9136
9137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogTitle",kwnames,&obj0,&obj1)) goto fail;
9138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9139 if (SWIG_arg_fail(1)) SWIG_fail;
9140 {
9141 arg2 = wxString_in_helper(obj1);
9142 if (arg2 == NULL) SWIG_fail;
9143 temp2 = true;
9144 }
9145 {
9146 PyThreadState* __tstate = wxPyBeginAllowThreads();
9147 (arg1)->SetDialogTitle((wxString const &)*arg2);
9148
9149 wxPyEndAllowThreads(__tstate);
9150 if (PyErr_Occurred()) SWIG_fail;
9151 }
9152 Py_INCREF(Py_None); resultobj = Py_None;
9153 {
9154 if (temp2)
9155 delete arg2;
9156 }
9157 return resultobj;
9158 fail:
9159 {
9160 if (temp2)
9161 delete arg2;
9162 }
9163 return NULL;
9164 }
9165
9166
9167 static PyObject * FontMapper_swigregister(PyObject *, PyObject *args) {
9168 PyObject *obj;
9169 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9170 SWIG_TypeClientData(SWIGTYPE_p_wxFontMapper, obj);
9171 Py_INCREF(obj);
9172 return Py_BuildValue((char *)"");
9173 }
9174 static PyObject *_wrap_new_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9175 PyObject *resultobj;
9176 int arg1 ;
9177 int arg2 ;
9178 int arg3 ;
9179 int arg4 ;
9180 bool arg5 = (bool) false ;
9181 wxString const &arg6_defvalue = wxPyEmptyString ;
9182 wxString *arg6 = (wxString *) &arg6_defvalue ;
9183 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9184 wxFont *result;
9185 bool temp6 = false ;
9186 PyObject * obj0 = 0 ;
9187 PyObject * obj1 = 0 ;
9188 PyObject * obj2 = 0 ;
9189 PyObject * obj3 = 0 ;
9190 PyObject * obj4 = 0 ;
9191 PyObject * obj5 = 0 ;
9192 PyObject * obj6 = 0 ;
9193 char *kwnames[] = {
9194 (char *) "pointSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "face",(char *) "encoding", NULL
9195 };
9196
9197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_Font",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9198 {
9199 arg1 = (int)(SWIG_As_int(obj0));
9200 if (SWIG_arg_fail(1)) SWIG_fail;
9201 }
9202 {
9203 arg2 = (int)(SWIG_As_int(obj1));
9204 if (SWIG_arg_fail(2)) SWIG_fail;
9205 }
9206 {
9207 arg3 = (int)(SWIG_As_int(obj2));
9208 if (SWIG_arg_fail(3)) SWIG_fail;
9209 }
9210 {
9211 arg4 = (int)(SWIG_As_int(obj3));
9212 if (SWIG_arg_fail(4)) SWIG_fail;
9213 }
9214 if (obj4) {
9215 {
9216 arg5 = (bool)(SWIG_As_bool(obj4));
9217 if (SWIG_arg_fail(5)) SWIG_fail;
9218 }
9219 }
9220 if (obj5) {
9221 {
9222 arg6 = wxString_in_helper(obj5);
9223 if (arg6 == NULL) SWIG_fail;
9224 temp6 = true;
9225 }
9226 }
9227 if (obj6) {
9228 {
9229 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
9230 if (SWIG_arg_fail(7)) SWIG_fail;
9231 }
9232 }
9233 {
9234 if (!wxPyCheckForApp()) SWIG_fail;
9235 PyThreadState* __tstate = wxPyBeginAllowThreads();
9236 result = (wxFont *)new wxFont(arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
9237
9238 wxPyEndAllowThreads(__tstate);
9239 if (PyErr_Occurred()) SWIG_fail;
9240 }
9241 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9242 {
9243 if (temp6)
9244 delete arg6;
9245 }
9246 return resultobj;
9247 fail:
9248 {
9249 if (temp6)
9250 delete arg6;
9251 }
9252 return NULL;
9253 }
9254
9255
9256 static PyObject *_wrap_delete_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9257 PyObject *resultobj;
9258 wxFont *arg1 = (wxFont *) 0 ;
9259 PyObject * obj0 = 0 ;
9260 char *kwnames[] = {
9261 (char *) "self", NULL
9262 };
9263
9264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Font",kwnames,&obj0)) goto fail;
9265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9266 if (SWIG_arg_fail(1)) SWIG_fail;
9267 {
9268 PyThreadState* __tstate = wxPyBeginAllowThreads();
9269 delete arg1;
9270
9271 wxPyEndAllowThreads(__tstate);
9272 if (PyErr_Occurred()) SWIG_fail;
9273 }
9274 Py_INCREF(Py_None); resultobj = Py_None;
9275 return resultobj;
9276 fail:
9277 return NULL;
9278 }
9279
9280
9281 static PyObject *_wrap_new_FontFromNativeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9282 PyObject *resultobj;
9283 wxNativeFontInfo *arg1 = 0 ;
9284 wxFont *result;
9285 PyObject * obj0 = 0 ;
9286 char *kwnames[] = {
9287 (char *) "info", NULL
9288 };
9289
9290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfo",kwnames,&obj0)) goto fail;
9291 {
9292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
9293 if (SWIG_arg_fail(1)) SWIG_fail;
9294 if (arg1 == NULL) {
9295 SWIG_null_ref("wxNativeFontInfo");
9296 }
9297 if (SWIG_arg_fail(1)) SWIG_fail;
9298 }
9299 {
9300 if (!wxPyCheckForApp()) SWIG_fail;
9301 PyThreadState* __tstate = wxPyBeginAllowThreads();
9302 result = (wxFont *)new wxFont((wxNativeFontInfo const &)*arg1);
9303
9304 wxPyEndAllowThreads(__tstate);
9305 if (PyErr_Occurred()) SWIG_fail;
9306 }
9307 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9308 return resultobj;
9309 fail:
9310 return NULL;
9311 }
9312
9313
9314 static PyObject *_wrap_new_FontFromNativeInfoString(PyObject *, PyObject *args, PyObject *kwargs) {
9315 PyObject *resultobj;
9316 wxString *arg1 = 0 ;
9317 wxFont *result;
9318 bool temp1 = false ;
9319 PyObject * obj0 = 0 ;
9320 char *kwnames[] = {
9321 (char *) "info", NULL
9322 };
9323
9324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfoString",kwnames,&obj0)) goto fail;
9325 {
9326 arg1 = wxString_in_helper(obj0);
9327 if (arg1 == NULL) SWIG_fail;
9328 temp1 = true;
9329 }
9330 {
9331 if (!wxPyCheckForApp()) SWIG_fail;
9332 PyThreadState* __tstate = wxPyBeginAllowThreads();
9333 result = (wxFont *)new_wxFont((wxString const &)*arg1);
9334
9335 wxPyEndAllowThreads(__tstate);
9336 if (PyErr_Occurred()) SWIG_fail;
9337 }
9338 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9339 {
9340 if (temp1)
9341 delete arg1;
9342 }
9343 return resultobj;
9344 fail:
9345 {
9346 if (temp1)
9347 delete arg1;
9348 }
9349 return NULL;
9350 }
9351
9352
9353 static PyObject *_wrap_new_Font2(PyObject *, PyObject *args, PyObject *kwargs) {
9354 PyObject *resultobj;
9355 int arg1 ;
9356 wxFontFamily arg2 ;
9357 int arg3 = (int) wxFONTFLAG_DEFAULT ;
9358 wxString const &arg4_defvalue = wxPyEmptyString ;
9359 wxString *arg4 = (wxString *) &arg4_defvalue ;
9360 wxFontEncoding arg5 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9361 wxFont *result;
9362 bool temp4 = false ;
9363 PyObject * obj0 = 0 ;
9364 PyObject * obj1 = 0 ;
9365 PyObject * obj2 = 0 ;
9366 PyObject * obj3 = 0 ;
9367 PyObject * obj4 = 0 ;
9368 char *kwnames[] = {
9369 (char *) "pointSize",(char *) "family",(char *) "flags",(char *) "face",(char *) "encoding", NULL
9370 };
9371
9372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_Font2",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
9373 {
9374 arg1 = (int)(SWIG_As_int(obj0));
9375 if (SWIG_arg_fail(1)) SWIG_fail;
9376 }
9377 {
9378 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
9379 if (SWIG_arg_fail(2)) SWIG_fail;
9380 }
9381 if (obj2) {
9382 {
9383 arg3 = (int)(SWIG_As_int(obj2));
9384 if (SWIG_arg_fail(3)) SWIG_fail;
9385 }
9386 }
9387 if (obj3) {
9388 {
9389 arg4 = wxString_in_helper(obj3);
9390 if (arg4 == NULL) SWIG_fail;
9391 temp4 = true;
9392 }
9393 }
9394 if (obj4) {
9395 {
9396 arg5 = (wxFontEncoding)(SWIG_As_int(obj4));
9397 if (SWIG_arg_fail(5)) SWIG_fail;
9398 }
9399 }
9400 {
9401 if (!wxPyCheckForApp()) SWIG_fail;
9402 PyThreadState* __tstate = wxPyBeginAllowThreads();
9403 result = (wxFont *)new_wxFont(arg1,(wxFontFamily )arg2,arg3,(wxString const &)*arg4,(wxFontEncoding )arg5);
9404
9405 wxPyEndAllowThreads(__tstate);
9406 if (PyErr_Occurred()) SWIG_fail;
9407 }
9408 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9409 {
9410 if (temp4)
9411 delete arg4;
9412 }
9413 return resultobj;
9414 fail:
9415 {
9416 if (temp4)
9417 delete arg4;
9418 }
9419 return NULL;
9420 }
9421
9422
9423 static PyObject *_wrap_new_FontFromPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
9424 PyObject *resultobj;
9425 wxSize *arg1 = 0 ;
9426 int arg2 ;
9427 int arg3 ;
9428 int arg4 ;
9429 bool arg5 = (bool) false ;
9430 wxString const &arg6_defvalue = wxEmptyString ;
9431 wxString *arg6 = (wxString *) &arg6_defvalue ;
9432 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9433 wxFont *result;
9434 wxSize temp1 ;
9435 bool temp6 = false ;
9436 PyObject * obj0 = 0 ;
9437 PyObject * obj1 = 0 ;
9438 PyObject * obj2 = 0 ;
9439 PyObject * obj3 = 0 ;
9440 PyObject * obj4 = 0 ;
9441 PyObject * obj5 = 0 ;
9442 PyObject * obj6 = 0 ;
9443 char *kwnames[] = {
9444 (char *) "pixelSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underlined",(char *) "face",(char *) "encoding", NULL
9445 };
9446
9447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_FontFromPixelSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9448 {
9449 arg1 = &temp1;
9450 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
9451 }
9452 {
9453 arg2 = (int)(SWIG_As_int(obj1));
9454 if (SWIG_arg_fail(2)) SWIG_fail;
9455 }
9456 {
9457 arg3 = (int)(SWIG_As_int(obj2));
9458 if (SWIG_arg_fail(3)) SWIG_fail;
9459 }
9460 {
9461 arg4 = (int)(SWIG_As_int(obj3));
9462 if (SWIG_arg_fail(4)) SWIG_fail;
9463 }
9464 if (obj4) {
9465 {
9466 arg5 = (bool)(SWIG_As_bool(obj4));
9467 if (SWIG_arg_fail(5)) SWIG_fail;
9468 }
9469 }
9470 if (obj5) {
9471 {
9472 arg6 = wxString_in_helper(obj5);
9473 if (arg6 == NULL) SWIG_fail;
9474 temp6 = true;
9475 }
9476 }
9477 if (obj6) {
9478 {
9479 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
9480 if (SWIG_arg_fail(7)) SWIG_fail;
9481 }
9482 }
9483 {
9484 if (!wxPyCheckForApp()) SWIG_fail;
9485 PyThreadState* __tstate = wxPyBeginAllowThreads();
9486 result = (wxFont *)new_wxFont((wxSize const &)*arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
9487
9488 wxPyEndAllowThreads(__tstate);
9489 if (PyErr_Occurred()) SWIG_fail;
9490 }
9491 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9492 {
9493 if (temp6)
9494 delete arg6;
9495 }
9496 return resultobj;
9497 fail:
9498 {
9499 if (temp6)
9500 delete arg6;
9501 }
9502 return NULL;
9503 }
9504
9505
9506 static PyObject *_wrap_Font_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
9507 PyObject *resultobj;
9508 wxFont *arg1 = (wxFont *) 0 ;
9509 bool result;
9510 PyObject * obj0 = 0 ;
9511 char *kwnames[] = {
9512 (char *) "self", NULL
9513 };
9514
9515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_Ok",kwnames,&obj0)) goto fail;
9516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9517 if (SWIG_arg_fail(1)) SWIG_fail;
9518 {
9519 PyThreadState* __tstate = wxPyBeginAllowThreads();
9520 result = (bool)((wxFont const *)arg1)->Ok();
9521
9522 wxPyEndAllowThreads(__tstate);
9523 if (PyErr_Occurred()) SWIG_fail;
9524 }
9525 {
9526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9527 }
9528 return resultobj;
9529 fail:
9530 return NULL;
9531 }
9532
9533
9534 static PyObject *_wrap_Font___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
9535 PyObject *resultobj;
9536 wxFont *arg1 = (wxFont *) 0 ;
9537 wxFont *arg2 = (wxFont *) 0 ;
9538 bool result;
9539 PyObject * obj0 = 0 ;
9540 PyObject * obj1 = 0 ;
9541 char *kwnames[] = {
9542 (char *) "self",(char *) "other", NULL
9543 };
9544
9545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___eq__",kwnames,&obj0,&obj1)) goto fail;
9546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9547 if (SWIG_arg_fail(1)) SWIG_fail;
9548 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9549 if (SWIG_arg_fail(2)) SWIG_fail;
9550 {
9551 PyThreadState* __tstate = wxPyBeginAllowThreads();
9552 result = (bool)wxFont___eq__(arg1,(wxFont const *)arg2);
9553
9554 wxPyEndAllowThreads(__tstate);
9555 if (PyErr_Occurred()) SWIG_fail;
9556 }
9557 {
9558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9559 }
9560 return resultobj;
9561 fail:
9562 return NULL;
9563 }
9564
9565
9566 static PyObject *_wrap_Font___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
9567 PyObject *resultobj;
9568 wxFont *arg1 = (wxFont *) 0 ;
9569 wxFont *arg2 = (wxFont *) 0 ;
9570 bool result;
9571 PyObject * obj0 = 0 ;
9572 PyObject * obj1 = 0 ;
9573 char *kwnames[] = {
9574 (char *) "self",(char *) "other", NULL
9575 };
9576
9577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___ne__",kwnames,&obj0,&obj1)) goto fail;
9578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9579 if (SWIG_arg_fail(1)) SWIG_fail;
9580 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9581 if (SWIG_arg_fail(2)) SWIG_fail;
9582 {
9583 PyThreadState* __tstate = wxPyBeginAllowThreads();
9584 result = (bool)wxFont___ne__(arg1,(wxFont const *)arg2);
9585
9586 wxPyEndAllowThreads(__tstate);
9587 if (PyErr_Occurred()) SWIG_fail;
9588 }
9589 {
9590 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9591 }
9592 return resultobj;
9593 fail:
9594 return NULL;
9595 }
9596
9597
9598 static PyObject *_wrap_Font_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
9599 PyObject *resultobj;
9600 wxFont *arg1 = (wxFont *) 0 ;
9601 int result;
9602 PyObject * obj0 = 0 ;
9603 char *kwnames[] = {
9604 (char *) "self", NULL
9605 };
9606
9607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPointSize",kwnames,&obj0)) goto fail;
9608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9609 if (SWIG_arg_fail(1)) SWIG_fail;
9610 {
9611 PyThreadState* __tstate = wxPyBeginAllowThreads();
9612 result = (int)((wxFont const *)arg1)->GetPointSize();
9613
9614 wxPyEndAllowThreads(__tstate);
9615 if (PyErr_Occurred()) SWIG_fail;
9616 }
9617 {
9618 resultobj = SWIG_From_int((int)(result));
9619 }
9620 return resultobj;
9621 fail:
9622 return NULL;
9623 }
9624
9625
9626 static PyObject *_wrap_Font_GetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
9627 PyObject *resultobj;
9628 wxFont *arg1 = (wxFont *) 0 ;
9629 wxSize result;
9630 PyObject * obj0 = 0 ;
9631 char *kwnames[] = {
9632 (char *) "self", NULL
9633 };
9634
9635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPixelSize",kwnames,&obj0)) goto fail;
9636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9637 if (SWIG_arg_fail(1)) SWIG_fail;
9638 {
9639 PyThreadState* __tstate = wxPyBeginAllowThreads();
9640 result = ((wxFont const *)arg1)->GetPixelSize();
9641
9642 wxPyEndAllowThreads(__tstate);
9643 if (PyErr_Occurred()) SWIG_fail;
9644 }
9645 {
9646 wxSize * resultptr;
9647 resultptr = new wxSize((wxSize &)(result));
9648 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
9649 }
9650 return resultobj;
9651 fail:
9652 return NULL;
9653 }
9654
9655
9656 static PyObject *_wrap_Font_IsUsingSizeInPixels(PyObject *, PyObject *args, PyObject *kwargs) {
9657 PyObject *resultobj;
9658 wxFont *arg1 = (wxFont *) 0 ;
9659 bool result;
9660 PyObject * obj0 = 0 ;
9661 char *kwnames[] = {
9662 (char *) "self", NULL
9663 };
9664
9665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsUsingSizeInPixels",kwnames,&obj0)) goto fail;
9666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9667 if (SWIG_arg_fail(1)) SWIG_fail;
9668 {
9669 PyThreadState* __tstate = wxPyBeginAllowThreads();
9670 result = (bool)((wxFont const *)arg1)->IsUsingSizeInPixels();
9671
9672 wxPyEndAllowThreads(__tstate);
9673 if (PyErr_Occurred()) SWIG_fail;
9674 }
9675 {
9676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9677 }
9678 return resultobj;
9679 fail:
9680 return NULL;
9681 }
9682
9683
9684 static PyObject *_wrap_Font_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
9685 PyObject *resultobj;
9686 wxFont *arg1 = (wxFont *) 0 ;
9687 int result;
9688 PyObject * obj0 = 0 ;
9689 char *kwnames[] = {
9690 (char *) "self", NULL
9691 };
9692
9693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamily",kwnames,&obj0)) goto fail;
9694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9695 if (SWIG_arg_fail(1)) SWIG_fail;
9696 {
9697 PyThreadState* __tstate = wxPyBeginAllowThreads();
9698 result = (int)((wxFont const *)arg1)->GetFamily();
9699
9700 wxPyEndAllowThreads(__tstate);
9701 if (PyErr_Occurred()) SWIG_fail;
9702 }
9703 {
9704 resultobj = SWIG_From_int((int)(result));
9705 }
9706 return resultobj;
9707 fail:
9708 return NULL;
9709 }
9710
9711
9712 static PyObject *_wrap_Font_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
9713 PyObject *resultobj;
9714 wxFont *arg1 = (wxFont *) 0 ;
9715 int result;
9716 PyObject * obj0 = 0 ;
9717 char *kwnames[] = {
9718 (char *) "self", NULL
9719 };
9720
9721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyle",kwnames,&obj0)) goto fail;
9722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9723 if (SWIG_arg_fail(1)) SWIG_fail;
9724 {
9725 PyThreadState* __tstate = wxPyBeginAllowThreads();
9726 result = (int)((wxFont const *)arg1)->GetStyle();
9727
9728 wxPyEndAllowThreads(__tstate);
9729 if (PyErr_Occurred()) SWIG_fail;
9730 }
9731 {
9732 resultobj = SWIG_From_int((int)(result));
9733 }
9734 return resultobj;
9735 fail:
9736 return NULL;
9737 }
9738
9739
9740 static PyObject *_wrap_Font_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
9741 PyObject *resultobj;
9742 wxFont *arg1 = (wxFont *) 0 ;
9743 int result;
9744 PyObject * obj0 = 0 ;
9745 char *kwnames[] = {
9746 (char *) "self", NULL
9747 };
9748
9749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeight",kwnames,&obj0)) goto fail;
9750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9751 if (SWIG_arg_fail(1)) SWIG_fail;
9752 {
9753 PyThreadState* __tstate = wxPyBeginAllowThreads();
9754 result = (int)((wxFont const *)arg1)->GetWeight();
9755
9756 wxPyEndAllowThreads(__tstate);
9757 if (PyErr_Occurred()) SWIG_fail;
9758 }
9759 {
9760 resultobj = SWIG_From_int((int)(result));
9761 }
9762 return resultobj;
9763 fail:
9764 return NULL;
9765 }
9766
9767
9768 static PyObject *_wrap_Font_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
9769 PyObject *resultobj;
9770 wxFont *arg1 = (wxFont *) 0 ;
9771 bool result;
9772 PyObject * obj0 = 0 ;
9773 char *kwnames[] = {
9774 (char *) "self", NULL
9775 };
9776
9777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetUnderlined",kwnames,&obj0)) goto fail;
9778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9779 if (SWIG_arg_fail(1)) SWIG_fail;
9780 {
9781 PyThreadState* __tstate = wxPyBeginAllowThreads();
9782 result = (bool)((wxFont const *)arg1)->GetUnderlined();
9783
9784 wxPyEndAllowThreads(__tstate);
9785 if (PyErr_Occurred()) SWIG_fail;
9786 }
9787 {
9788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9789 }
9790 return resultobj;
9791 fail:
9792 return NULL;
9793 }
9794
9795
9796 static PyObject *_wrap_Font_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
9797 PyObject *resultobj;
9798 wxFont *arg1 = (wxFont *) 0 ;
9799 wxString result;
9800 PyObject * obj0 = 0 ;
9801 char *kwnames[] = {
9802 (char *) "self", NULL
9803 };
9804
9805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFaceName",kwnames,&obj0)) goto fail;
9806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9807 if (SWIG_arg_fail(1)) SWIG_fail;
9808 {
9809 PyThreadState* __tstate = wxPyBeginAllowThreads();
9810 result = ((wxFont const *)arg1)->GetFaceName();
9811
9812 wxPyEndAllowThreads(__tstate);
9813 if (PyErr_Occurred()) SWIG_fail;
9814 }
9815 {
9816 #if wxUSE_UNICODE
9817 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9818 #else
9819 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9820 #endif
9821 }
9822 return resultobj;
9823 fail:
9824 return NULL;
9825 }
9826
9827
9828 static PyObject *_wrap_Font_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9829 PyObject *resultobj;
9830 wxFont *arg1 = (wxFont *) 0 ;
9831 wxFontEncoding result;
9832 PyObject * obj0 = 0 ;
9833 char *kwnames[] = {
9834 (char *) "self", NULL
9835 };
9836
9837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetEncoding",kwnames,&obj0)) goto fail;
9838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9839 if (SWIG_arg_fail(1)) SWIG_fail;
9840 {
9841 PyThreadState* __tstate = wxPyBeginAllowThreads();
9842 result = (wxFontEncoding)((wxFont const *)arg1)->GetEncoding();
9843
9844 wxPyEndAllowThreads(__tstate);
9845 if (PyErr_Occurred()) SWIG_fail;
9846 }
9847 resultobj = SWIG_From_int((result));
9848 return resultobj;
9849 fail:
9850 return NULL;
9851 }
9852
9853
9854 static PyObject *_wrap_Font_GetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9855 PyObject *resultobj;
9856 wxFont *arg1 = (wxFont *) 0 ;
9857 wxNativeFontInfo *result;
9858 PyObject * obj0 = 0 ;
9859 char *kwnames[] = {
9860 (char *) "self", NULL
9861 };
9862
9863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfo",kwnames,&obj0)) goto fail;
9864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9865 if (SWIG_arg_fail(1)) SWIG_fail;
9866 {
9867 PyThreadState* __tstate = wxPyBeginAllowThreads();
9868 result = (wxNativeFontInfo *)((wxFont const *)arg1)->GetNativeFontInfo();
9869
9870 wxPyEndAllowThreads(__tstate);
9871 if (PyErr_Occurred()) SWIG_fail;
9872 }
9873 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 0);
9874 return resultobj;
9875 fail:
9876 return NULL;
9877 }
9878
9879
9880 static PyObject *_wrap_Font_IsFixedWidth(PyObject *, PyObject *args, PyObject *kwargs) {
9881 PyObject *resultobj;
9882 wxFont *arg1 = (wxFont *) 0 ;
9883 bool result;
9884 PyObject * obj0 = 0 ;
9885 char *kwnames[] = {
9886 (char *) "self", NULL
9887 };
9888
9889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsFixedWidth",kwnames,&obj0)) goto fail;
9890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9891 if (SWIG_arg_fail(1)) SWIG_fail;
9892 {
9893 PyThreadState* __tstate = wxPyBeginAllowThreads();
9894 result = (bool)((wxFont const *)arg1)->IsFixedWidth();
9895
9896 wxPyEndAllowThreads(__tstate);
9897 if (PyErr_Occurred()) SWIG_fail;
9898 }
9899 {
9900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9901 }
9902 return resultobj;
9903 fail:
9904 return NULL;
9905 }
9906
9907
9908 static PyObject *_wrap_Font_GetNativeFontInfoDesc(PyObject *, PyObject *args, PyObject *kwargs) {
9909 PyObject *resultobj;
9910 wxFont *arg1 = (wxFont *) 0 ;
9911 wxString result;
9912 PyObject * obj0 = 0 ;
9913 char *kwnames[] = {
9914 (char *) "self", NULL
9915 };
9916
9917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoDesc",kwnames,&obj0)) goto fail;
9918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9919 if (SWIG_arg_fail(1)) SWIG_fail;
9920 {
9921 PyThreadState* __tstate = wxPyBeginAllowThreads();
9922 result = ((wxFont const *)arg1)->GetNativeFontInfoDesc();
9923
9924 wxPyEndAllowThreads(__tstate);
9925 if (PyErr_Occurred()) SWIG_fail;
9926 }
9927 {
9928 #if wxUSE_UNICODE
9929 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9930 #else
9931 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9932 #endif
9933 }
9934 return resultobj;
9935 fail:
9936 return NULL;
9937 }
9938
9939
9940 static PyObject *_wrap_Font_GetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
9941 PyObject *resultobj;
9942 wxFont *arg1 = (wxFont *) 0 ;
9943 wxString result;
9944 PyObject * obj0 = 0 ;
9945 char *kwnames[] = {
9946 (char *) "self", NULL
9947 };
9948
9949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoUserDesc",kwnames,&obj0)) goto fail;
9950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9951 if (SWIG_arg_fail(1)) SWIG_fail;
9952 {
9953 PyThreadState* __tstate = wxPyBeginAllowThreads();
9954 result = ((wxFont const *)arg1)->GetNativeFontInfoUserDesc();
9955
9956 wxPyEndAllowThreads(__tstate);
9957 if (PyErr_Occurred()) SWIG_fail;
9958 }
9959 {
9960 #if wxUSE_UNICODE
9961 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9962 #else
9963 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9964 #endif
9965 }
9966 return resultobj;
9967 fail:
9968 return NULL;
9969 }
9970
9971
9972 static PyObject *_wrap_Font_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
9973 PyObject *resultobj;
9974 wxFont *arg1 = (wxFont *) 0 ;
9975 int arg2 ;
9976 PyObject * obj0 = 0 ;
9977 PyObject * obj1 = 0 ;
9978 char *kwnames[] = {
9979 (char *) "self",(char *) "pointSize", NULL
9980 };
9981
9982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
9983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9984 if (SWIG_arg_fail(1)) SWIG_fail;
9985 {
9986 arg2 = (int)(SWIG_As_int(obj1));
9987 if (SWIG_arg_fail(2)) SWIG_fail;
9988 }
9989 {
9990 PyThreadState* __tstate = wxPyBeginAllowThreads();
9991 (arg1)->SetPointSize(arg2);
9992
9993 wxPyEndAllowThreads(__tstate);
9994 if (PyErr_Occurred()) SWIG_fail;
9995 }
9996 Py_INCREF(Py_None); resultobj = Py_None;
9997 return resultobj;
9998 fail:
9999 return NULL;
10000 }
10001
10002
10003 static PyObject *_wrap_Font_SetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
10004 PyObject *resultobj;
10005 wxFont *arg1 = (wxFont *) 0 ;
10006 wxSize *arg2 = 0 ;
10007 wxSize temp2 ;
10008 PyObject * obj0 = 0 ;
10009 PyObject * obj1 = 0 ;
10010 char *kwnames[] = {
10011 (char *) "self",(char *) "pixelSize", NULL
10012 };
10013
10014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPixelSize",kwnames,&obj0,&obj1)) goto fail;
10015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10016 if (SWIG_arg_fail(1)) SWIG_fail;
10017 {
10018 arg2 = &temp2;
10019 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
10020 }
10021 {
10022 PyThreadState* __tstate = wxPyBeginAllowThreads();
10023 (arg1)->SetPixelSize((wxSize const &)*arg2);
10024
10025 wxPyEndAllowThreads(__tstate);
10026 if (PyErr_Occurred()) SWIG_fail;
10027 }
10028 Py_INCREF(Py_None); resultobj = Py_None;
10029 return resultobj;
10030 fail:
10031 return NULL;
10032 }
10033
10034
10035 static PyObject *_wrap_Font_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
10036 PyObject *resultobj;
10037 wxFont *arg1 = (wxFont *) 0 ;
10038 int arg2 ;
10039 PyObject * obj0 = 0 ;
10040 PyObject * obj1 = 0 ;
10041 char *kwnames[] = {
10042 (char *) "self",(char *) "family", NULL
10043 };
10044
10045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFamily",kwnames,&obj0,&obj1)) goto fail;
10046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10047 if (SWIG_arg_fail(1)) SWIG_fail;
10048 {
10049 arg2 = (int)(SWIG_As_int(obj1));
10050 if (SWIG_arg_fail(2)) SWIG_fail;
10051 }
10052 {
10053 PyThreadState* __tstate = wxPyBeginAllowThreads();
10054 (arg1)->SetFamily(arg2);
10055
10056 wxPyEndAllowThreads(__tstate);
10057 if (PyErr_Occurred()) SWIG_fail;
10058 }
10059 Py_INCREF(Py_None); resultobj = Py_None;
10060 return resultobj;
10061 fail:
10062 return NULL;
10063 }
10064
10065
10066 static PyObject *_wrap_Font_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
10067 PyObject *resultobj;
10068 wxFont *arg1 = (wxFont *) 0 ;
10069 int arg2 ;
10070 PyObject * obj0 = 0 ;
10071 PyObject * obj1 = 0 ;
10072 char *kwnames[] = {
10073 (char *) "self",(char *) "style", NULL
10074 };
10075
10076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetStyle",kwnames,&obj0,&obj1)) goto fail;
10077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10078 if (SWIG_arg_fail(1)) SWIG_fail;
10079 {
10080 arg2 = (int)(SWIG_As_int(obj1));
10081 if (SWIG_arg_fail(2)) SWIG_fail;
10082 }
10083 {
10084 PyThreadState* __tstate = wxPyBeginAllowThreads();
10085 (arg1)->SetStyle(arg2);
10086
10087 wxPyEndAllowThreads(__tstate);
10088 if (PyErr_Occurred()) SWIG_fail;
10089 }
10090 Py_INCREF(Py_None); resultobj = Py_None;
10091 return resultobj;
10092 fail:
10093 return NULL;
10094 }
10095
10096
10097 static PyObject *_wrap_Font_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
10098 PyObject *resultobj;
10099 wxFont *arg1 = (wxFont *) 0 ;
10100 int arg2 ;
10101 PyObject * obj0 = 0 ;
10102 PyObject * obj1 = 0 ;
10103 char *kwnames[] = {
10104 (char *) "self",(char *) "weight", NULL
10105 };
10106
10107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetWeight",kwnames,&obj0,&obj1)) goto fail;
10108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10109 if (SWIG_arg_fail(1)) SWIG_fail;
10110 {
10111 arg2 = (int)(SWIG_As_int(obj1));
10112 if (SWIG_arg_fail(2)) SWIG_fail;
10113 }
10114 {
10115 PyThreadState* __tstate = wxPyBeginAllowThreads();
10116 (arg1)->SetWeight(arg2);
10117
10118 wxPyEndAllowThreads(__tstate);
10119 if (PyErr_Occurred()) SWIG_fail;
10120 }
10121 Py_INCREF(Py_None); resultobj = Py_None;
10122 return resultobj;
10123 fail:
10124 return NULL;
10125 }
10126
10127
10128 static PyObject *_wrap_Font_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
10129 PyObject *resultobj;
10130 wxFont *arg1 = (wxFont *) 0 ;
10131 wxString *arg2 = 0 ;
10132 bool temp2 = false ;
10133 PyObject * obj0 = 0 ;
10134 PyObject * obj1 = 0 ;
10135 char *kwnames[] = {
10136 (char *) "self",(char *) "faceName", NULL
10137 };
10138
10139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
10140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10141 if (SWIG_arg_fail(1)) SWIG_fail;
10142 {
10143 arg2 = wxString_in_helper(obj1);
10144 if (arg2 == NULL) SWIG_fail;
10145 temp2 = true;
10146 }
10147 {
10148 PyThreadState* __tstate = wxPyBeginAllowThreads();
10149 (arg1)->SetFaceName((wxString const &)*arg2);
10150
10151 wxPyEndAllowThreads(__tstate);
10152 if (PyErr_Occurred()) SWIG_fail;
10153 }
10154 Py_INCREF(Py_None); resultobj = Py_None;
10155 {
10156 if (temp2)
10157 delete arg2;
10158 }
10159 return resultobj;
10160 fail:
10161 {
10162 if (temp2)
10163 delete arg2;
10164 }
10165 return NULL;
10166 }
10167
10168
10169 static PyObject *_wrap_Font_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
10170 PyObject *resultobj;
10171 wxFont *arg1 = (wxFont *) 0 ;
10172 bool arg2 ;
10173 PyObject * obj0 = 0 ;
10174 PyObject * obj1 = 0 ;
10175 char *kwnames[] = {
10176 (char *) "self",(char *) "underlined", NULL
10177 };
10178
10179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
10180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10181 if (SWIG_arg_fail(1)) SWIG_fail;
10182 {
10183 arg2 = (bool)(SWIG_As_bool(obj1));
10184 if (SWIG_arg_fail(2)) SWIG_fail;
10185 }
10186 {
10187 PyThreadState* __tstate = wxPyBeginAllowThreads();
10188 (arg1)->SetUnderlined(arg2);
10189
10190 wxPyEndAllowThreads(__tstate);
10191 if (PyErr_Occurred()) SWIG_fail;
10192 }
10193 Py_INCREF(Py_None); resultobj = Py_None;
10194 return resultobj;
10195 fail:
10196 return NULL;
10197 }
10198
10199
10200 static PyObject *_wrap_Font_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10201 PyObject *resultobj;
10202 wxFont *arg1 = (wxFont *) 0 ;
10203 wxFontEncoding arg2 ;
10204 PyObject * obj0 = 0 ;
10205 PyObject * obj1 = 0 ;
10206 char *kwnames[] = {
10207 (char *) "self",(char *) "encoding", NULL
10208 };
10209
10210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
10211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10212 if (SWIG_arg_fail(1)) SWIG_fail;
10213 {
10214 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
10215 if (SWIG_arg_fail(2)) SWIG_fail;
10216 }
10217 {
10218 PyThreadState* __tstate = wxPyBeginAllowThreads();
10219 (arg1)->SetEncoding((wxFontEncoding )arg2);
10220
10221 wxPyEndAllowThreads(__tstate);
10222 if (PyErr_Occurred()) SWIG_fail;
10223 }
10224 Py_INCREF(Py_None); resultobj = Py_None;
10225 return resultobj;
10226 fail:
10227 return NULL;
10228 }
10229
10230
10231 static PyObject *_wrap_Font_SetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10232 PyObject *resultobj;
10233 wxFont *arg1 = (wxFont *) 0 ;
10234 wxNativeFontInfo *arg2 = 0 ;
10235 PyObject * obj0 = 0 ;
10236 PyObject * obj1 = 0 ;
10237 char *kwnames[] = {
10238 (char *) "self",(char *) "info", NULL
10239 };
10240
10241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfo",kwnames,&obj0,&obj1)) goto fail;
10242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10243 if (SWIG_arg_fail(1)) SWIG_fail;
10244 {
10245 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
10246 if (SWIG_arg_fail(2)) SWIG_fail;
10247 if (arg2 == NULL) {
10248 SWIG_null_ref("wxNativeFontInfo");
10249 }
10250 if (SWIG_arg_fail(2)) SWIG_fail;
10251 }
10252 {
10253 PyThreadState* __tstate = wxPyBeginAllowThreads();
10254 (arg1)->SetNativeFontInfo((wxNativeFontInfo const &)*arg2);
10255
10256 wxPyEndAllowThreads(__tstate);
10257 if (PyErr_Occurred()) SWIG_fail;
10258 }
10259 Py_INCREF(Py_None); resultobj = Py_None;
10260 return resultobj;
10261 fail:
10262 return NULL;
10263 }
10264
10265
10266 static PyObject *_wrap_Font_SetNativeFontInfoFromString(PyObject *, PyObject *args, PyObject *kwargs) {
10267 PyObject *resultobj;
10268 wxFont *arg1 = (wxFont *) 0 ;
10269 wxString *arg2 = 0 ;
10270 bool temp2 = false ;
10271 PyObject * obj0 = 0 ;
10272 PyObject * obj1 = 0 ;
10273 char *kwnames[] = {
10274 (char *) "self",(char *) "info", NULL
10275 };
10276
10277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoFromString",kwnames,&obj0,&obj1)) goto fail;
10278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10279 if (SWIG_arg_fail(1)) SWIG_fail;
10280 {
10281 arg2 = wxString_in_helper(obj1);
10282 if (arg2 == NULL) SWIG_fail;
10283 temp2 = true;
10284 }
10285 {
10286 PyThreadState* __tstate = wxPyBeginAllowThreads();
10287 (arg1)->SetNativeFontInfo((wxString const &)*arg2);
10288
10289 wxPyEndAllowThreads(__tstate);
10290 if (PyErr_Occurred()) SWIG_fail;
10291 }
10292 Py_INCREF(Py_None); resultobj = Py_None;
10293 {
10294 if (temp2)
10295 delete arg2;
10296 }
10297 return resultobj;
10298 fail:
10299 {
10300 if (temp2)
10301 delete arg2;
10302 }
10303 return NULL;
10304 }
10305
10306
10307 static PyObject *_wrap_Font_SetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10308 PyObject *resultobj;
10309 wxFont *arg1 = (wxFont *) 0 ;
10310 wxString *arg2 = 0 ;
10311 bool temp2 = false ;
10312 PyObject * obj0 = 0 ;
10313 PyObject * obj1 = 0 ;
10314 char *kwnames[] = {
10315 (char *) "self",(char *) "info", NULL
10316 };
10317
10318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoUserDesc",kwnames,&obj0,&obj1)) goto fail;
10319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10320 if (SWIG_arg_fail(1)) SWIG_fail;
10321 {
10322 arg2 = wxString_in_helper(obj1);
10323 if (arg2 == NULL) SWIG_fail;
10324 temp2 = true;
10325 }
10326 {
10327 PyThreadState* __tstate = wxPyBeginAllowThreads();
10328 (arg1)->SetNativeFontInfoUserDesc((wxString const &)*arg2);
10329
10330 wxPyEndAllowThreads(__tstate);
10331 if (PyErr_Occurred()) SWIG_fail;
10332 }
10333 Py_INCREF(Py_None); resultobj = Py_None;
10334 {
10335 if (temp2)
10336 delete arg2;
10337 }
10338 return resultobj;
10339 fail:
10340 {
10341 if (temp2)
10342 delete arg2;
10343 }
10344 return NULL;
10345 }
10346
10347
10348 static PyObject *_wrap_Font_GetFamilyString(PyObject *, PyObject *args, PyObject *kwargs) {
10349 PyObject *resultobj;
10350 wxFont *arg1 = (wxFont *) 0 ;
10351 wxString result;
10352 PyObject * obj0 = 0 ;
10353 char *kwnames[] = {
10354 (char *) "self", NULL
10355 };
10356
10357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamilyString",kwnames,&obj0)) goto fail;
10358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10359 if (SWIG_arg_fail(1)) SWIG_fail;
10360 {
10361 PyThreadState* __tstate = wxPyBeginAllowThreads();
10362 result = ((wxFont const *)arg1)->GetFamilyString();
10363
10364 wxPyEndAllowThreads(__tstate);
10365 if (PyErr_Occurred()) SWIG_fail;
10366 }
10367 {
10368 #if wxUSE_UNICODE
10369 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10370 #else
10371 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10372 #endif
10373 }
10374 return resultobj;
10375 fail:
10376 return NULL;
10377 }
10378
10379
10380 static PyObject *_wrap_Font_GetStyleString(PyObject *, PyObject *args, PyObject *kwargs) {
10381 PyObject *resultobj;
10382 wxFont *arg1 = (wxFont *) 0 ;
10383 wxString result;
10384 PyObject * obj0 = 0 ;
10385 char *kwnames[] = {
10386 (char *) "self", NULL
10387 };
10388
10389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyleString",kwnames,&obj0)) goto fail;
10390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10391 if (SWIG_arg_fail(1)) SWIG_fail;
10392 {
10393 PyThreadState* __tstate = wxPyBeginAllowThreads();
10394 result = ((wxFont const *)arg1)->GetStyleString();
10395
10396 wxPyEndAllowThreads(__tstate);
10397 if (PyErr_Occurred()) SWIG_fail;
10398 }
10399 {
10400 #if wxUSE_UNICODE
10401 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10402 #else
10403 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10404 #endif
10405 }
10406 return resultobj;
10407 fail:
10408 return NULL;
10409 }
10410
10411
10412 static PyObject *_wrap_Font_GetWeightString(PyObject *, PyObject *args, PyObject *kwargs) {
10413 PyObject *resultobj;
10414 wxFont *arg1 = (wxFont *) 0 ;
10415 wxString result;
10416 PyObject * obj0 = 0 ;
10417 char *kwnames[] = {
10418 (char *) "self", NULL
10419 };
10420
10421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeightString",kwnames,&obj0)) goto fail;
10422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10423 if (SWIG_arg_fail(1)) SWIG_fail;
10424 {
10425 PyThreadState* __tstate = wxPyBeginAllowThreads();
10426 result = ((wxFont const *)arg1)->GetWeightString();
10427
10428 wxPyEndAllowThreads(__tstate);
10429 if (PyErr_Occurred()) SWIG_fail;
10430 }
10431 {
10432 #if wxUSE_UNICODE
10433 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10434 #else
10435 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10436 #endif
10437 }
10438 return resultobj;
10439 fail:
10440 return NULL;
10441 }
10442
10443
10444 static PyObject *_wrap_Font_SetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
10445 PyObject *resultobj;
10446 wxFont *arg1 = (wxFont *) 0 ;
10447 bool arg2 = (bool) true ;
10448 PyObject * obj0 = 0 ;
10449 PyObject * obj1 = 0 ;
10450 char *kwnames[] = {
10451 (char *) "self",(char *) "no", NULL
10452 };
10453
10454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Font_SetNoAntiAliasing",kwnames,&obj0,&obj1)) goto fail;
10455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10456 if (SWIG_arg_fail(1)) SWIG_fail;
10457 if (obj1) {
10458 {
10459 arg2 = (bool)(SWIG_As_bool(obj1));
10460 if (SWIG_arg_fail(2)) SWIG_fail;
10461 }
10462 }
10463 {
10464 PyThreadState* __tstate = wxPyBeginAllowThreads();
10465 (arg1)->SetNoAntiAliasing(arg2);
10466
10467 wxPyEndAllowThreads(__tstate);
10468 if (PyErr_Occurred()) SWIG_fail;
10469 }
10470 Py_INCREF(Py_None); resultobj = Py_None;
10471 return resultobj;
10472 fail:
10473 return NULL;
10474 }
10475
10476
10477 static PyObject *_wrap_Font_GetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
10478 PyObject *resultobj;
10479 wxFont *arg1 = (wxFont *) 0 ;
10480 bool result;
10481 PyObject * obj0 = 0 ;
10482 char *kwnames[] = {
10483 (char *) "self", NULL
10484 };
10485
10486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNoAntiAliasing",kwnames,&obj0)) goto fail;
10487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10488 if (SWIG_arg_fail(1)) SWIG_fail;
10489 {
10490 PyThreadState* __tstate = wxPyBeginAllowThreads();
10491 result = (bool)((wxFont const *)arg1)->GetNoAntiAliasing();
10492
10493 wxPyEndAllowThreads(__tstate);
10494 if (PyErr_Occurred()) SWIG_fail;
10495 }
10496 {
10497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10498 }
10499 return resultobj;
10500 fail:
10501 return NULL;
10502 }
10503
10504
10505 static PyObject *_wrap_Font_GetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10506 PyObject *resultobj;
10507 wxFontEncoding result;
10508 char *kwnames[] = {
10509 NULL
10510 };
10511
10512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Font_GetDefaultEncoding",kwnames)) goto fail;
10513 {
10514 if (!wxPyCheckForApp()) SWIG_fail;
10515 PyThreadState* __tstate = wxPyBeginAllowThreads();
10516 result = (wxFontEncoding)wxFont::GetDefaultEncoding();
10517
10518 wxPyEndAllowThreads(__tstate);
10519 if (PyErr_Occurred()) SWIG_fail;
10520 }
10521 resultobj = SWIG_From_int((result));
10522 return resultobj;
10523 fail:
10524 return NULL;
10525 }
10526
10527
10528 static PyObject *_wrap_Font_SetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10529 PyObject *resultobj;
10530 wxFontEncoding arg1 ;
10531 PyObject * obj0 = 0 ;
10532 char *kwnames[] = {
10533 (char *) "encoding", NULL
10534 };
10535
10536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_SetDefaultEncoding",kwnames,&obj0)) goto fail;
10537 {
10538 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
10539 if (SWIG_arg_fail(1)) SWIG_fail;
10540 }
10541 {
10542 if (!wxPyCheckForApp()) SWIG_fail;
10543 PyThreadState* __tstate = wxPyBeginAllowThreads();
10544 wxFont::SetDefaultEncoding((wxFontEncoding )arg1);
10545
10546 wxPyEndAllowThreads(__tstate);
10547 if (PyErr_Occurred()) SWIG_fail;
10548 }
10549 Py_INCREF(Py_None); resultobj = Py_None;
10550 return resultobj;
10551 fail:
10552 return NULL;
10553 }
10554
10555
10556 static PyObject * Font_swigregister(PyObject *, PyObject *args) {
10557 PyObject *obj;
10558 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10559 SWIG_TypeClientData(SWIGTYPE_p_wxFont, obj);
10560 Py_INCREF(obj);
10561 return Py_BuildValue((char *)"");
10562 }
10563 static PyObject *_wrap_new_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
10564 PyObject *resultobj;
10565 wxPyFontEnumerator *result;
10566 char *kwnames[] = {
10567 NULL
10568 };
10569
10570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontEnumerator",kwnames)) goto fail;
10571 {
10572 if (!wxPyCheckForApp()) SWIG_fail;
10573 PyThreadState* __tstate = wxPyBeginAllowThreads();
10574 result = (wxPyFontEnumerator *)new wxPyFontEnumerator();
10575
10576 wxPyEndAllowThreads(__tstate);
10577 if (PyErr_Occurred()) SWIG_fail;
10578 }
10579 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFontEnumerator, 1);
10580 return resultobj;
10581 fail:
10582 return NULL;
10583 }
10584
10585
10586 static PyObject *_wrap_delete_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
10587 PyObject *resultobj;
10588 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10589 PyObject * obj0 = 0 ;
10590 char *kwnames[] = {
10591 (char *) "self", NULL
10592 };
10593
10594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontEnumerator",kwnames,&obj0)) goto fail;
10595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10596 if (SWIG_arg_fail(1)) SWIG_fail;
10597 {
10598 PyThreadState* __tstate = wxPyBeginAllowThreads();
10599 delete arg1;
10600
10601 wxPyEndAllowThreads(__tstate);
10602 if (PyErr_Occurred()) SWIG_fail;
10603 }
10604 Py_INCREF(Py_None); resultobj = Py_None;
10605 return resultobj;
10606 fail:
10607 return NULL;
10608 }
10609
10610
10611 static PyObject *_wrap_FontEnumerator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10612 PyObject *resultobj;
10613 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10614 PyObject *arg2 = (PyObject *) 0 ;
10615 PyObject *arg3 = (PyObject *) 0 ;
10616 bool arg4 ;
10617 PyObject * obj0 = 0 ;
10618 PyObject * obj1 = 0 ;
10619 PyObject * obj2 = 0 ;
10620 PyObject * obj3 = 0 ;
10621 char *kwnames[] = {
10622 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
10623 };
10624
10625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FontEnumerator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10627 if (SWIG_arg_fail(1)) SWIG_fail;
10628 arg2 = obj1;
10629 arg3 = obj2;
10630 {
10631 arg4 = (bool)(SWIG_As_bool(obj3));
10632 if (SWIG_arg_fail(4)) SWIG_fail;
10633 }
10634 {
10635 PyThreadState* __tstate = wxPyBeginAllowThreads();
10636 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
10637
10638 wxPyEndAllowThreads(__tstate);
10639 if (PyErr_Occurred()) SWIG_fail;
10640 }
10641 Py_INCREF(Py_None); resultobj = Py_None;
10642 return resultobj;
10643 fail:
10644 return NULL;
10645 }
10646
10647
10648 static PyObject *_wrap_FontEnumerator_EnumerateFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
10649 PyObject *resultobj;
10650 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10651 wxFontEncoding arg2 = (wxFontEncoding) wxFONTENCODING_SYSTEM ;
10652 bool arg3 = (bool) false ;
10653 bool result;
10654 PyObject * obj0 = 0 ;
10655 PyObject * obj1 = 0 ;
10656 PyObject * obj2 = 0 ;
10657 char *kwnames[] = {
10658 (char *) "self",(char *) "encoding",(char *) "fixedWidthOnly", NULL
10659 };
10660
10661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FontEnumerator_EnumerateFacenames",kwnames,&obj0,&obj1,&obj2)) goto fail;
10662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10663 if (SWIG_arg_fail(1)) SWIG_fail;
10664 if (obj1) {
10665 {
10666 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
10667 if (SWIG_arg_fail(2)) SWIG_fail;
10668 }
10669 }
10670 if (obj2) {
10671 {
10672 arg3 = (bool)(SWIG_As_bool(obj2));
10673 if (SWIG_arg_fail(3)) SWIG_fail;
10674 }
10675 }
10676 {
10677 PyThreadState* __tstate = wxPyBeginAllowThreads();
10678 result = (bool)(arg1)->EnumerateFacenames((wxFontEncoding )arg2,arg3);
10679
10680 wxPyEndAllowThreads(__tstate);
10681 if (PyErr_Occurred()) SWIG_fail;
10682 }
10683 {
10684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10685 }
10686 return resultobj;
10687 fail:
10688 return NULL;
10689 }
10690
10691
10692 static PyObject *_wrap_FontEnumerator_EnumerateEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
10693 PyObject *resultobj;
10694 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10695 wxString const &arg2_defvalue = wxPyEmptyString ;
10696 wxString *arg2 = (wxString *) &arg2_defvalue ;
10697 bool result;
10698 bool temp2 = false ;
10699 PyObject * obj0 = 0 ;
10700 PyObject * obj1 = 0 ;
10701 char *kwnames[] = {
10702 (char *) "self",(char *) "facename", NULL
10703 };
10704
10705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FontEnumerator_EnumerateEncodings",kwnames,&obj0,&obj1)) goto fail;
10706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10707 if (SWIG_arg_fail(1)) SWIG_fail;
10708 if (obj1) {
10709 {
10710 arg2 = wxString_in_helper(obj1);
10711 if (arg2 == NULL) SWIG_fail;
10712 temp2 = true;
10713 }
10714 }
10715 {
10716 PyThreadState* __tstate = wxPyBeginAllowThreads();
10717 result = (bool)(arg1)->EnumerateEncodings((wxString const &)*arg2);
10718
10719 wxPyEndAllowThreads(__tstate);
10720 if (PyErr_Occurred()) SWIG_fail;
10721 }
10722 {
10723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10724 }
10725 {
10726 if (temp2)
10727 delete arg2;
10728 }
10729 return resultobj;
10730 fail:
10731 {
10732 if (temp2)
10733 delete arg2;
10734 }
10735 return NULL;
10736 }
10737
10738
10739 static PyObject *_wrap_FontEnumerator_GetEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
10740 PyObject *resultobj;
10741 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10742 PyObject *result;
10743 PyObject * obj0 = 0 ;
10744 char *kwnames[] = {
10745 (char *) "self", NULL
10746 };
10747
10748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetEncodings",kwnames,&obj0)) goto fail;
10749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10750 if (SWIG_arg_fail(1)) SWIG_fail;
10751 {
10752 PyThreadState* __tstate = wxPyBeginAllowThreads();
10753 result = (PyObject *)wxPyFontEnumerator_GetEncodings(arg1);
10754
10755 wxPyEndAllowThreads(__tstate);
10756 if (PyErr_Occurred()) SWIG_fail;
10757 }
10758 resultobj = result;
10759 return resultobj;
10760 fail:
10761 return NULL;
10762 }
10763
10764
10765 static PyObject *_wrap_FontEnumerator_GetFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
10766 PyObject *resultobj;
10767 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10768 PyObject *result;
10769 PyObject * obj0 = 0 ;
10770 char *kwnames[] = {
10771 (char *) "self", NULL
10772 };
10773
10774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetFacenames",kwnames,&obj0)) goto fail;
10775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10776 if (SWIG_arg_fail(1)) SWIG_fail;
10777 {
10778 PyThreadState* __tstate = wxPyBeginAllowThreads();
10779 result = (PyObject *)wxPyFontEnumerator_GetFacenames(arg1);
10780
10781 wxPyEndAllowThreads(__tstate);
10782 if (PyErr_Occurred()) SWIG_fail;
10783 }
10784 resultobj = result;
10785 return resultobj;
10786 fail:
10787 return NULL;
10788 }
10789
10790
10791 static PyObject * FontEnumerator_swigregister(PyObject *, PyObject *args) {
10792 PyObject *obj;
10793 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10794 SWIG_TypeClientData(SWIGTYPE_p_wxPyFontEnumerator, obj);
10795 Py_INCREF(obj);
10796 return Py_BuildValue((char *)"");
10797 }
10798 static PyObject *_wrap_LanguageInfo_Language_set(PyObject *, PyObject *args, PyObject *kwargs) {
10799 PyObject *resultobj;
10800 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10801 int arg2 ;
10802 PyObject * obj0 = 0 ;
10803 PyObject * obj1 = 0 ;
10804 char *kwnames[] = {
10805 (char *) "self",(char *) "Language", NULL
10806 };
10807
10808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Language_set",kwnames,&obj0,&obj1)) goto fail;
10809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10810 if (SWIG_arg_fail(1)) SWIG_fail;
10811 {
10812 arg2 = (int)(SWIG_As_int(obj1));
10813 if (SWIG_arg_fail(2)) SWIG_fail;
10814 }
10815 if (arg1) (arg1)->Language = arg2;
10816
10817 Py_INCREF(Py_None); resultobj = Py_None;
10818 return resultobj;
10819 fail:
10820 return NULL;
10821 }
10822
10823
10824 static PyObject *_wrap_LanguageInfo_Language_get(PyObject *, PyObject *args, PyObject *kwargs) {
10825 PyObject *resultobj;
10826 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10827 int result;
10828 PyObject * obj0 = 0 ;
10829 char *kwnames[] = {
10830 (char *) "self", NULL
10831 };
10832
10833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Language_get",kwnames,&obj0)) goto fail;
10834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10835 if (SWIG_arg_fail(1)) SWIG_fail;
10836 result = (int) ((arg1)->Language);
10837
10838 {
10839 resultobj = SWIG_From_int((int)(result));
10840 }
10841 return resultobj;
10842 fail:
10843 return NULL;
10844 }
10845
10846
10847 static PyObject *_wrap_LanguageInfo_CanonicalName_set(PyObject *, PyObject *args, PyObject *kwargs) {
10848 PyObject *resultobj;
10849 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10850 wxString *arg2 = (wxString *) 0 ;
10851 bool temp2 = false ;
10852 PyObject * obj0 = 0 ;
10853 PyObject * obj1 = 0 ;
10854 char *kwnames[] = {
10855 (char *) "self",(char *) "CanonicalName", NULL
10856 };
10857
10858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_CanonicalName_set",kwnames,&obj0,&obj1)) goto fail;
10859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10860 if (SWIG_arg_fail(1)) SWIG_fail;
10861 {
10862 arg2 = wxString_in_helper(obj1);
10863 if (arg2 == NULL) SWIG_fail;
10864 temp2 = true;
10865 }
10866 if (arg1) (arg1)->CanonicalName = *arg2;
10867
10868 Py_INCREF(Py_None); resultobj = Py_None;
10869 {
10870 if (temp2)
10871 delete arg2;
10872 }
10873 return resultobj;
10874 fail:
10875 {
10876 if (temp2)
10877 delete arg2;
10878 }
10879 return NULL;
10880 }
10881
10882
10883 static PyObject *_wrap_LanguageInfo_CanonicalName_get(PyObject *, PyObject *args, PyObject *kwargs) {
10884 PyObject *resultobj;
10885 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10886 wxString *result;
10887 PyObject * obj0 = 0 ;
10888 char *kwnames[] = {
10889 (char *) "self", NULL
10890 };
10891
10892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_CanonicalName_get",kwnames,&obj0)) goto fail;
10893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10894 if (SWIG_arg_fail(1)) SWIG_fail;
10895 result = (wxString *)& ((arg1)->CanonicalName);
10896
10897 {
10898 #if wxUSE_UNICODE
10899 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10900 #else
10901 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10902 #endif
10903 }
10904 return resultobj;
10905 fail:
10906 return NULL;
10907 }
10908
10909
10910 static PyObject *_wrap_LanguageInfo_Description_set(PyObject *, PyObject *args, PyObject *kwargs) {
10911 PyObject *resultobj;
10912 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10913 wxString *arg2 = (wxString *) 0 ;
10914 bool temp2 = false ;
10915 PyObject * obj0 = 0 ;
10916 PyObject * obj1 = 0 ;
10917 char *kwnames[] = {
10918 (char *) "self",(char *) "Description", NULL
10919 };
10920
10921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Description_set",kwnames,&obj0,&obj1)) goto fail;
10922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10923 if (SWIG_arg_fail(1)) SWIG_fail;
10924 {
10925 arg2 = wxString_in_helper(obj1);
10926 if (arg2 == NULL) SWIG_fail;
10927 temp2 = true;
10928 }
10929 if (arg1) (arg1)->Description = *arg2;
10930
10931 Py_INCREF(Py_None); resultobj = Py_None;
10932 {
10933 if (temp2)
10934 delete arg2;
10935 }
10936 return resultobj;
10937 fail:
10938 {
10939 if (temp2)
10940 delete arg2;
10941 }
10942 return NULL;
10943 }
10944
10945
10946 static PyObject *_wrap_LanguageInfo_Description_get(PyObject *, PyObject *args, PyObject *kwargs) {
10947 PyObject *resultobj;
10948 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10949 wxString *result;
10950 PyObject * obj0 = 0 ;
10951 char *kwnames[] = {
10952 (char *) "self", NULL
10953 };
10954
10955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Description_get",kwnames,&obj0)) goto fail;
10956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10957 if (SWIG_arg_fail(1)) SWIG_fail;
10958 result = (wxString *)& ((arg1)->Description);
10959
10960 {
10961 #if wxUSE_UNICODE
10962 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10963 #else
10964 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10965 #endif
10966 }
10967 return resultobj;
10968 fail:
10969 return NULL;
10970 }
10971
10972
10973 static PyObject * LanguageInfo_swigregister(PyObject *, PyObject *args) {
10974 PyObject *obj;
10975 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10976 SWIG_TypeClientData(SWIGTYPE_p_wxLanguageInfo, obj);
10977 Py_INCREF(obj);
10978 return Py_BuildValue((char *)"");
10979 }
10980 static PyObject *_wrap_new_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
10981 PyObject *resultobj;
10982 int arg1 = (int) -1 ;
10983 int arg2 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
10984 wxLocale *result;
10985 PyObject * obj0 = 0 ;
10986 PyObject * obj1 = 0 ;
10987 char *kwnames[] = {
10988 (char *) "language",(char *) "flags", NULL
10989 };
10990
10991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Locale",kwnames,&obj0,&obj1)) goto fail;
10992 if (obj0) {
10993 {
10994 arg1 = (int)(SWIG_As_int(obj0));
10995 if (SWIG_arg_fail(1)) SWIG_fail;
10996 }
10997 }
10998 if (obj1) {
10999 {
11000 arg2 = (int)(SWIG_As_int(obj1));
11001 if (SWIG_arg_fail(2)) SWIG_fail;
11002 }
11003 }
11004 {
11005 PyThreadState* __tstate = wxPyBeginAllowThreads();
11006 result = (wxLocale *)new_wxLocale(arg1,arg2);
11007
11008 wxPyEndAllowThreads(__tstate);
11009 if (PyErr_Occurred()) SWIG_fail;
11010 }
11011 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 1);
11012 return resultobj;
11013 fail:
11014 return NULL;
11015 }
11016
11017
11018 static PyObject *_wrap_delete_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
11019 PyObject *resultobj;
11020 wxLocale *arg1 = (wxLocale *) 0 ;
11021 PyObject * obj0 = 0 ;
11022 char *kwnames[] = {
11023 (char *) "self", NULL
11024 };
11025
11026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Locale",kwnames,&obj0)) goto fail;
11027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11028 if (SWIG_arg_fail(1)) SWIG_fail;
11029 {
11030 PyThreadState* __tstate = wxPyBeginAllowThreads();
11031 delete arg1;
11032
11033 wxPyEndAllowThreads(__tstate);
11034 if (PyErr_Occurred()) SWIG_fail;
11035 }
11036 Py_INCREF(Py_None); resultobj = Py_None;
11037 return resultobj;
11038 fail:
11039 return NULL;
11040 }
11041
11042
11043 static PyObject *_wrap_Locale_Init1(PyObject *, PyObject *args, PyObject *kwargs) {
11044 PyObject *resultobj;
11045 wxLocale *arg1 = (wxLocale *) 0 ;
11046 wxString *arg2 = 0 ;
11047 wxString const &arg3_defvalue = wxPyEmptyString ;
11048 wxString *arg3 = (wxString *) &arg3_defvalue ;
11049 wxString const &arg4_defvalue = wxPyEmptyString ;
11050 wxString *arg4 = (wxString *) &arg4_defvalue ;
11051 bool arg5 = (bool) true ;
11052 bool arg6 = (bool) false ;
11053 bool result;
11054 bool temp2 = false ;
11055 bool temp3 = false ;
11056 bool temp4 = false ;
11057 PyObject * obj0 = 0 ;
11058 PyObject * obj1 = 0 ;
11059 PyObject * obj2 = 0 ;
11060 PyObject * obj3 = 0 ;
11061 PyObject * obj4 = 0 ;
11062 PyObject * obj5 = 0 ;
11063 char *kwnames[] = {
11064 (char *) "self",(char *) "szName",(char *) "szShort",(char *) "szLocale",(char *) "bLoadDefault",(char *) "bConvertEncoding", NULL
11065 };
11066
11067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Locale_Init1",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11069 if (SWIG_arg_fail(1)) SWIG_fail;
11070 {
11071 arg2 = wxString_in_helper(obj1);
11072 if (arg2 == NULL) SWIG_fail;
11073 temp2 = true;
11074 }
11075 if (obj2) {
11076 {
11077 arg3 = wxString_in_helper(obj2);
11078 if (arg3 == NULL) SWIG_fail;
11079 temp3 = true;
11080 }
11081 }
11082 if (obj3) {
11083 {
11084 arg4 = wxString_in_helper(obj3);
11085 if (arg4 == NULL) SWIG_fail;
11086 temp4 = true;
11087 }
11088 }
11089 if (obj4) {
11090 {
11091 arg5 = (bool)(SWIG_As_bool(obj4));
11092 if (SWIG_arg_fail(5)) SWIG_fail;
11093 }
11094 }
11095 if (obj5) {
11096 {
11097 arg6 = (bool)(SWIG_As_bool(obj5));
11098 if (SWIG_arg_fail(6)) SWIG_fail;
11099 }
11100 }
11101 {
11102 PyThreadState* __tstate = wxPyBeginAllowThreads();
11103 result = (bool)wxLocale_Init1(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
11104
11105 wxPyEndAllowThreads(__tstate);
11106 if (PyErr_Occurred()) SWIG_fail;
11107 }
11108 {
11109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11110 }
11111 {
11112 if (temp2)
11113 delete arg2;
11114 }
11115 {
11116 if (temp3)
11117 delete arg3;
11118 }
11119 {
11120 if (temp4)
11121 delete arg4;
11122 }
11123 return resultobj;
11124 fail:
11125 {
11126 if (temp2)
11127 delete arg2;
11128 }
11129 {
11130 if (temp3)
11131 delete arg3;
11132 }
11133 {
11134 if (temp4)
11135 delete arg4;
11136 }
11137 return NULL;
11138 }
11139
11140
11141 static PyObject *_wrap_Locale_Init2(PyObject *, PyObject *args, PyObject *kwargs) {
11142 PyObject *resultobj;
11143 wxLocale *arg1 = (wxLocale *) 0 ;
11144 int arg2 = (int) wxLANGUAGE_DEFAULT ;
11145 int arg3 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
11146 bool result;
11147 PyObject * obj0 = 0 ;
11148 PyObject * obj1 = 0 ;
11149 PyObject * obj2 = 0 ;
11150 char *kwnames[] = {
11151 (char *) "self",(char *) "language",(char *) "flags", NULL
11152 };
11153
11154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Locale_Init2",kwnames,&obj0,&obj1,&obj2)) goto fail;
11155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11156 if (SWIG_arg_fail(1)) SWIG_fail;
11157 if (obj1) {
11158 {
11159 arg2 = (int)(SWIG_As_int(obj1));
11160 if (SWIG_arg_fail(2)) SWIG_fail;
11161 }
11162 }
11163 if (obj2) {
11164 {
11165 arg3 = (int)(SWIG_As_int(obj2));
11166 if (SWIG_arg_fail(3)) SWIG_fail;
11167 }
11168 }
11169 {
11170 PyThreadState* __tstate = wxPyBeginAllowThreads();
11171 result = (bool)wxLocale_Init2(arg1,arg2,arg3);
11172
11173 wxPyEndAllowThreads(__tstate);
11174 if (PyErr_Occurred()) SWIG_fail;
11175 }
11176 {
11177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11178 }
11179 return resultobj;
11180 fail:
11181 return NULL;
11182 }
11183
11184
11185 static PyObject *_wrap_Locale_GetSystemLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11186 PyObject *resultobj;
11187 int result;
11188 char *kwnames[] = {
11189 NULL
11190 };
11191
11192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemLanguage",kwnames)) goto fail;
11193 {
11194 PyThreadState* __tstate = wxPyBeginAllowThreads();
11195 result = (int)wxLocale::GetSystemLanguage();
11196
11197 wxPyEndAllowThreads(__tstate);
11198 if (PyErr_Occurred()) SWIG_fail;
11199 }
11200 {
11201 resultobj = SWIG_From_int((int)(result));
11202 }
11203 return resultobj;
11204 fail:
11205 return NULL;
11206 }
11207
11208
11209 static PyObject *_wrap_Locale_GetSystemEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
11210 PyObject *resultobj;
11211 wxFontEncoding result;
11212 char *kwnames[] = {
11213 NULL
11214 };
11215
11216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncoding",kwnames)) goto fail;
11217 {
11218 PyThreadState* __tstate = wxPyBeginAllowThreads();
11219 result = (wxFontEncoding)wxLocale::GetSystemEncoding();
11220
11221 wxPyEndAllowThreads(__tstate);
11222 if (PyErr_Occurred()) SWIG_fail;
11223 }
11224 resultobj = SWIG_From_int((result));
11225 return resultobj;
11226 fail:
11227 return NULL;
11228 }
11229
11230
11231 static PyObject *_wrap_Locale_GetSystemEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
11232 PyObject *resultobj;
11233 wxString result;
11234 char *kwnames[] = {
11235 NULL
11236 };
11237
11238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncodingName",kwnames)) goto fail;
11239 {
11240 PyThreadState* __tstate = wxPyBeginAllowThreads();
11241 result = wxLocale::GetSystemEncodingName();
11242
11243 wxPyEndAllowThreads(__tstate);
11244 if (PyErr_Occurred()) SWIG_fail;
11245 }
11246 {
11247 #if wxUSE_UNICODE
11248 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11249 #else
11250 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11251 #endif
11252 }
11253 return resultobj;
11254 fail:
11255 return NULL;
11256 }
11257
11258
11259 static PyObject *_wrap_Locale_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11260 PyObject *resultobj;
11261 wxLocale *arg1 = (wxLocale *) 0 ;
11262 bool result;
11263 PyObject * obj0 = 0 ;
11264 char *kwnames[] = {
11265 (char *) "self", NULL
11266 };
11267
11268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_IsOk",kwnames,&obj0)) goto fail;
11269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11270 if (SWIG_arg_fail(1)) SWIG_fail;
11271 {
11272 PyThreadState* __tstate = wxPyBeginAllowThreads();
11273 result = (bool)((wxLocale const *)arg1)->IsOk();
11274
11275 wxPyEndAllowThreads(__tstate);
11276 if (PyErr_Occurred()) SWIG_fail;
11277 }
11278 {
11279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11280 }
11281 return resultobj;
11282 fail:
11283 return NULL;
11284 }
11285
11286
11287 static PyObject *_wrap_Locale_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
11288 PyObject *resultobj;
11289 wxLocale *arg1 = (wxLocale *) 0 ;
11290 wxString result;
11291 PyObject * obj0 = 0 ;
11292 char *kwnames[] = {
11293 (char *) "self", NULL
11294 };
11295
11296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLocale",kwnames,&obj0)) goto fail;
11297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11298 if (SWIG_arg_fail(1)) SWIG_fail;
11299 {
11300 PyThreadState* __tstate = wxPyBeginAllowThreads();
11301 result = ((wxLocale const *)arg1)->GetLocale();
11302
11303 wxPyEndAllowThreads(__tstate);
11304 if (PyErr_Occurred()) SWIG_fail;
11305 }
11306 {
11307 #if wxUSE_UNICODE
11308 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11309 #else
11310 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11311 #endif
11312 }
11313 return resultobj;
11314 fail:
11315 return NULL;
11316 }
11317
11318
11319 static PyObject *_wrap_Locale_GetLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11320 PyObject *resultobj;
11321 wxLocale *arg1 = (wxLocale *) 0 ;
11322 int result;
11323 PyObject * obj0 = 0 ;
11324 char *kwnames[] = {
11325 (char *) "self", NULL
11326 };
11327
11328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguage",kwnames,&obj0)) goto fail;
11329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11330 if (SWIG_arg_fail(1)) SWIG_fail;
11331 {
11332 PyThreadState* __tstate = wxPyBeginAllowThreads();
11333 result = (int)((wxLocale const *)arg1)->GetLanguage();
11334
11335 wxPyEndAllowThreads(__tstate);
11336 if (PyErr_Occurred()) SWIG_fail;
11337 }
11338 {
11339 resultobj = SWIG_From_int((int)(result));
11340 }
11341 return resultobj;
11342 fail:
11343 return NULL;
11344 }
11345
11346
11347 static PyObject *_wrap_Locale_GetSysName(PyObject *, PyObject *args, PyObject *kwargs) {
11348 PyObject *resultobj;
11349 wxLocale *arg1 = (wxLocale *) 0 ;
11350 wxString result;
11351 PyObject * obj0 = 0 ;
11352 char *kwnames[] = {
11353 (char *) "self", NULL
11354 };
11355
11356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetSysName",kwnames,&obj0)) goto fail;
11357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11358 if (SWIG_arg_fail(1)) SWIG_fail;
11359 {
11360 PyThreadState* __tstate = wxPyBeginAllowThreads();
11361 result = ((wxLocale const *)arg1)->GetSysName();
11362
11363 wxPyEndAllowThreads(__tstate);
11364 if (PyErr_Occurred()) SWIG_fail;
11365 }
11366 {
11367 #if wxUSE_UNICODE
11368 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11369 #else
11370 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11371 #endif
11372 }
11373 return resultobj;
11374 fail:
11375 return NULL;
11376 }
11377
11378
11379 static PyObject *_wrap_Locale_GetCanonicalName(PyObject *, PyObject *args, PyObject *kwargs) {
11380 PyObject *resultobj;
11381 wxLocale *arg1 = (wxLocale *) 0 ;
11382 wxString result;
11383 PyObject * obj0 = 0 ;
11384 char *kwnames[] = {
11385 (char *) "self", NULL
11386 };
11387
11388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetCanonicalName",kwnames,&obj0)) goto fail;
11389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11390 if (SWIG_arg_fail(1)) SWIG_fail;
11391 {
11392 PyThreadState* __tstate = wxPyBeginAllowThreads();
11393 result = ((wxLocale const *)arg1)->GetCanonicalName();
11394
11395 wxPyEndAllowThreads(__tstate);
11396 if (PyErr_Occurred()) SWIG_fail;
11397 }
11398 {
11399 #if wxUSE_UNICODE
11400 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11401 #else
11402 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11403 #endif
11404 }
11405 return resultobj;
11406 fail:
11407 return NULL;
11408 }
11409
11410
11411 static PyObject *_wrap_Locale_AddCatalogLookupPathPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
11412 PyObject *resultobj;
11413 wxString *arg1 = 0 ;
11414 bool temp1 = false ;
11415 PyObject * obj0 = 0 ;
11416 char *kwnames[] = {
11417 (char *) "prefix", NULL
11418 };
11419
11420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddCatalogLookupPathPrefix",kwnames,&obj0)) goto fail;
11421 {
11422 arg1 = wxString_in_helper(obj0);
11423 if (arg1 == NULL) SWIG_fail;
11424 temp1 = true;
11425 }
11426 {
11427 PyThreadState* __tstate = wxPyBeginAllowThreads();
11428 wxLocale::AddCatalogLookupPathPrefix((wxString const &)*arg1);
11429
11430 wxPyEndAllowThreads(__tstate);
11431 if (PyErr_Occurred()) SWIG_fail;
11432 }
11433 Py_INCREF(Py_None); resultobj = Py_None;
11434 {
11435 if (temp1)
11436 delete arg1;
11437 }
11438 return resultobj;
11439 fail:
11440 {
11441 if (temp1)
11442 delete arg1;
11443 }
11444 return NULL;
11445 }
11446
11447
11448 static PyObject *_wrap_Locale_AddCatalog(PyObject *, PyObject *args, PyObject *kwargs) {
11449 PyObject *resultobj;
11450 wxLocale *arg1 = (wxLocale *) 0 ;
11451 wxString *arg2 = 0 ;
11452 bool result;
11453 bool temp2 = false ;
11454 PyObject * obj0 = 0 ;
11455 PyObject * obj1 = 0 ;
11456 char *kwnames[] = {
11457 (char *) "self",(char *) "szDomain", NULL
11458 };
11459
11460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_AddCatalog",kwnames,&obj0,&obj1)) goto fail;
11461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11462 if (SWIG_arg_fail(1)) SWIG_fail;
11463 {
11464 arg2 = wxString_in_helper(obj1);
11465 if (arg2 == NULL) SWIG_fail;
11466 temp2 = true;
11467 }
11468 {
11469 PyThreadState* __tstate = wxPyBeginAllowThreads();
11470 result = (bool)(arg1)->AddCatalog((wxString const &)*arg2);
11471
11472 wxPyEndAllowThreads(__tstate);
11473 if (PyErr_Occurred()) SWIG_fail;
11474 }
11475 {
11476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11477 }
11478 {
11479 if (temp2)
11480 delete arg2;
11481 }
11482 return resultobj;
11483 fail:
11484 {
11485 if (temp2)
11486 delete arg2;
11487 }
11488 return NULL;
11489 }
11490
11491
11492 static PyObject *_wrap_Locale_IsLoaded(PyObject *, PyObject *args, PyObject *kwargs) {
11493 PyObject *resultobj;
11494 wxLocale *arg1 = (wxLocale *) 0 ;
11495 wxString *arg2 = 0 ;
11496 bool result;
11497 bool temp2 = false ;
11498 PyObject * obj0 = 0 ;
11499 PyObject * obj1 = 0 ;
11500 char *kwnames[] = {
11501 (char *) "self",(char *) "szDomain", NULL
11502 };
11503
11504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_IsLoaded",kwnames,&obj0,&obj1)) goto fail;
11505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11506 if (SWIG_arg_fail(1)) SWIG_fail;
11507 {
11508 arg2 = wxString_in_helper(obj1);
11509 if (arg2 == NULL) SWIG_fail;
11510 temp2 = true;
11511 }
11512 {
11513 PyThreadState* __tstate = wxPyBeginAllowThreads();
11514 result = (bool)((wxLocale const *)arg1)->IsLoaded((wxString const &)*arg2);
11515
11516 wxPyEndAllowThreads(__tstate);
11517 if (PyErr_Occurred()) SWIG_fail;
11518 }
11519 {
11520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11521 }
11522 {
11523 if (temp2)
11524 delete arg2;
11525 }
11526 return resultobj;
11527 fail:
11528 {
11529 if (temp2)
11530 delete arg2;
11531 }
11532 return NULL;
11533 }
11534
11535
11536 static PyObject *_wrap_Locale_GetLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11537 PyObject *resultobj;
11538 int arg1 ;
11539 wxLanguageInfo *result;
11540 PyObject * obj0 = 0 ;
11541 char *kwnames[] = {
11542 (char *) "lang", NULL
11543 };
11544
11545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageInfo",kwnames,&obj0)) goto fail;
11546 {
11547 arg1 = (int)(SWIG_As_int(obj0));
11548 if (SWIG_arg_fail(1)) SWIG_fail;
11549 }
11550 {
11551 PyThreadState* __tstate = wxPyBeginAllowThreads();
11552 result = (wxLanguageInfo *)wxLocale::GetLanguageInfo(arg1);
11553
11554 wxPyEndAllowThreads(__tstate);
11555 if (PyErr_Occurred()) SWIG_fail;
11556 }
11557 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
11558 return resultobj;
11559 fail:
11560 return NULL;
11561 }
11562
11563
11564 static PyObject *_wrap_Locale_GetLanguageName(PyObject *, PyObject *args, PyObject *kwargs) {
11565 PyObject *resultobj;
11566 int arg1 ;
11567 wxString result;
11568 PyObject * obj0 = 0 ;
11569 char *kwnames[] = {
11570 (char *) "lang", NULL
11571 };
11572
11573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageName",kwnames,&obj0)) goto fail;
11574 {
11575 arg1 = (int)(SWIG_As_int(obj0));
11576 if (SWIG_arg_fail(1)) SWIG_fail;
11577 }
11578 {
11579 PyThreadState* __tstate = wxPyBeginAllowThreads();
11580 result = wxLocale::GetLanguageName(arg1);
11581
11582 wxPyEndAllowThreads(__tstate);
11583 if (PyErr_Occurred()) SWIG_fail;
11584 }
11585 {
11586 #if wxUSE_UNICODE
11587 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11588 #else
11589 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11590 #endif
11591 }
11592 return resultobj;
11593 fail:
11594 return NULL;
11595 }
11596
11597
11598 static PyObject *_wrap_Locale_FindLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11599 PyObject *resultobj;
11600 wxString *arg1 = 0 ;
11601 wxLanguageInfo *result;
11602 bool temp1 = false ;
11603 PyObject * obj0 = 0 ;
11604 char *kwnames[] = {
11605 (char *) "locale", NULL
11606 };
11607
11608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_FindLanguageInfo",kwnames,&obj0)) goto fail;
11609 {
11610 arg1 = wxString_in_helper(obj0);
11611 if (arg1 == NULL) SWIG_fail;
11612 temp1 = true;
11613 }
11614 {
11615 PyThreadState* __tstate = wxPyBeginAllowThreads();
11616 result = (wxLanguageInfo *)wxLocale::FindLanguageInfo((wxString const &)*arg1);
11617
11618 wxPyEndAllowThreads(__tstate);
11619 if (PyErr_Occurred()) SWIG_fail;
11620 }
11621 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
11622 {
11623 if (temp1)
11624 delete arg1;
11625 }
11626 return resultobj;
11627 fail:
11628 {
11629 if (temp1)
11630 delete arg1;
11631 }
11632 return NULL;
11633 }
11634
11635
11636 static PyObject *_wrap_Locale_AddLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11637 PyObject *resultobj;
11638 wxLanguageInfo *arg1 = 0 ;
11639 PyObject * obj0 = 0 ;
11640 char *kwnames[] = {
11641 (char *) "info", NULL
11642 };
11643
11644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddLanguage",kwnames,&obj0)) goto fail;
11645 {
11646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11647 if (SWIG_arg_fail(1)) SWIG_fail;
11648 if (arg1 == NULL) {
11649 SWIG_null_ref("wxLanguageInfo");
11650 }
11651 if (SWIG_arg_fail(1)) SWIG_fail;
11652 }
11653 {
11654 PyThreadState* __tstate = wxPyBeginAllowThreads();
11655 wxLocale::AddLanguage((wxLanguageInfo const &)*arg1);
11656
11657 wxPyEndAllowThreads(__tstate);
11658 if (PyErr_Occurred()) SWIG_fail;
11659 }
11660 Py_INCREF(Py_None); resultobj = Py_None;
11661 return resultobj;
11662 fail:
11663 return NULL;
11664 }
11665
11666
11667 static PyObject *_wrap_Locale_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
11668 PyObject *resultobj;
11669 wxLocale *arg1 = (wxLocale *) 0 ;
11670 wxString *arg2 = 0 ;
11671 wxString const &arg3_defvalue = wxPyEmptyString ;
11672 wxString *arg3 = (wxString *) &arg3_defvalue ;
11673 wxString result;
11674 bool temp2 = false ;
11675 bool temp3 = false ;
11676 PyObject * obj0 = 0 ;
11677 PyObject * obj1 = 0 ;
11678 PyObject * obj2 = 0 ;
11679 char *kwnames[] = {
11680 (char *) "self",(char *) "szOrigString",(char *) "szDomain", NULL
11681 };
11682
11683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Locale_GetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
11684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11685 if (SWIG_arg_fail(1)) SWIG_fail;
11686 {
11687 arg2 = wxString_in_helper(obj1);
11688 if (arg2 == NULL) SWIG_fail;
11689 temp2 = true;
11690 }
11691 if (obj2) {
11692 {
11693 arg3 = wxString_in_helper(obj2);
11694 if (arg3 == NULL) SWIG_fail;
11695 temp3 = true;
11696 }
11697 }
11698 {
11699 PyThreadState* __tstate = wxPyBeginAllowThreads();
11700 result = ((wxLocale const *)arg1)->GetString((wxString const &)*arg2,(wxString const &)*arg3);
11701
11702 wxPyEndAllowThreads(__tstate);
11703 if (PyErr_Occurred()) SWIG_fail;
11704 }
11705 {
11706 #if wxUSE_UNICODE
11707 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11708 #else
11709 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11710 #endif
11711 }
11712 {
11713 if (temp2)
11714 delete arg2;
11715 }
11716 {
11717 if (temp3)
11718 delete arg3;
11719 }
11720 return resultobj;
11721 fail:
11722 {
11723 if (temp2)
11724 delete arg2;
11725 }
11726 {
11727 if (temp3)
11728 delete arg3;
11729 }
11730 return NULL;
11731 }
11732
11733
11734 static PyObject *_wrap_Locale_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
11735 PyObject *resultobj;
11736 wxLocale *arg1 = (wxLocale *) 0 ;
11737 wxString *result;
11738 PyObject * obj0 = 0 ;
11739 char *kwnames[] = {
11740 (char *) "self", NULL
11741 };
11742
11743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetName",kwnames,&obj0)) goto fail;
11744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11745 if (SWIG_arg_fail(1)) SWIG_fail;
11746 {
11747 PyThreadState* __tstate = wxPyBeginAllowThreads();
11748 {
11749 wxString const &_result_ref = ((wxLocale const *)arg1)->GetName();
11750 result = (wxString *) &_result_ref;
11751 }
11752
11753 wxPyEndAllowThreads(__tstate);
11754 if (PyErr_Occurred()) SWIG_fail;
11755 }
11756 {
11757 #if wxUSE_UNICODE
11758 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
11759 #else
11760 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
11761 #endif
11762 }
11763 return resultobj;
11764 fail:
11765 return NULL;
11766 }
11767
11768
11769 static PyObject * Locale_swigregister(PyObject *, PyObject *args) {
11770 PyObject *obj;
11771 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11772 SWIG_TypeClientData(SWIGTYPE_p_wxLocale, obj);
11773 Py_INCREF(obj);
11774 return Py_BuildValue((char *)"");
11775 }
11776 static PyObject *_wrap_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
11777 PyObject *resultobj;
11778 wxLocale *result;
11779 char *kwnames[] = {
11780 NULL
11781 };
11782
11783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocale",kwnames)) goto fail;
11784 {
11785 PyThreadState* __tstate = wxPyBeginAllowThreads();
11786 result = (wxLocale *)wxGetLocale();
11787
11788 wxPyEndAllowThreads(__tstate);
11789 if (PyErr_Occurred()) SWIG_fail;
11790 }
11791 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 0);
11792 return resultobj;
11793 fail:
11794 return NULL;
11795 }
11796
11797
11798 static PyObject *_wrap_GetTranslation__SWIG_0(PyObject *, PyObject *args) {
11799 PyObject *resultobj;
11800 wxString *arg1 = 0 ;
11801 wxString result;
11802 bool temp1 = false ;
11803 PyObject * obj0 = 0 ;
11804
11805 if(!PyArg_ParseTuple(args,(char *)"O:GetTranslation",&obj0)) goto fail;
11806 {
11807 arg1 = wxString_in_helper(obj0);
11808 if (arg1 == NULL) SWIG_fail;
11809 temp1 = true;
11810 }
11811 {
11812 PyThreadState* __tstate = wxPyBeginAllowThreads();
11813 result = wxGetTranslation((wxString const &)*arg1);
11814
11815 wxPyEndAllowThreads(__tstate);
11816 if (PyErr_Occurred()) SWIG_fail;
11817 }
11818 {
11819 #if wxUSE_UNICODE
11820 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11821 #else
11822 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11823 #endif
11824 }
11825 {
11826 if (temp1)
11827 delete arg1;
11828 }
11829 return resultobj;
11830 fail:
11831 {
11832 if (temp1)
11833 delete arg1;
11834 }
11835 return NULL;
11836 }
11837
11838
11839 static PyObject *_wrap_GetTranslation__SWIG_1(PyObject *, PyObject *args) {
11840 PyObject *resultobj;
11841 wxString *arg1 = 0 ;
11842 wxString *arg2 = 0 ;
11843 size_t arg3 ;
11844 wxString result;
11845 bool temp1 = false ;
11846 bool temp2 = false ;
11847 PyObject * obj0 = 0 ;
11848 PyObject * obj1 = 0 ;
11849 PyObject * obj2 = 0 ;
11850
11851 if(!PyArg_ParseTuple(args,(char *)"OOO:GetTranslation",&obj0,&obj1,&obj2)) goto fail;
11852 {
11853 arg1 = wxString_in_helper(obj0);
11854 if (arg1 == NULL) SWIG_fail;
11855 temp1 = true;
11856 }
11857 {
11858 arg2 = wxString_in_helper(obj1);
11859 if (arg2 == NULL) SWIG_fail;
11860 temp2 = true;
11861 }
11862 {
11863 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
11864 if (SWIG_arg_fail(3)) SWIG_fail;
11865 }
11866 {
11867 PyThreadState* __tstate = wxPyBeginAllowThreads();
11868 result = wxGetTranslation((wxString const &)*arg1,(wxString const &)*arg2,arg3);
11869
11870 wxPyEndAllowThreads(__tstate);
11871 if (PyErr_Occurred()) SWIG_fail;
11872 }
11873 {
11874 #if wxUSE_UNICODE
11875 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11876 #else
11877 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11878 #endif
11879 }
11880 {
11881 if (temp1)
11882 delete arg1;
11883 }
11884 {
11885 if (temp2)
11886 delete arg2;
11887 }
11888 return resultobj;
11889 fail:
11890 {
11891 if (temp1)
11892 delete arg1;
11893 }
11894 {
11895 if (temp2)
11896 delete arg2;
11897 }
11898 return NULL;
11899 }
11900
11901
11902 static PyObject *_wrap_GetTranslation(PyObject *self, PyObject *args) {
11903 int argc;
11904 PyObject *argv[4];
11905 int ii;
11906
11907 argc = PyObject_Length(args);
11908 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
11909 argv[ii] = PyTuple_GetItem(args,ii);
11910 }
11911 if (argc == 1) {
11912 int _v;
11913 {
11914 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
11915 }
11916 if (_v) {
11917 return _wrap_GetTranslation__SWIG_0(self,args);
11918 }
11919 }
11920 if (argc == 3) {
11921 int _v;
11922 {
11923 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
11924 }
11925 if (_v) {
11926 {
11927 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
11928 }
11929 if (_v) {
11930 _v = SWIG_Check_unsigned_SS_long(argv[2]);
11931 if (_v) {
11932 return _wrap_GetTranslation__SWIG_1(self,args);
11933 }
11934 }
11935 }
11936 }
11937
11938 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GetTranslation'");
11939 return NULL;
11940 }
11941
11942
11943 static PyObject *_wrap_new_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
11944 PyObject *resultobj;
11945 wxEncodingConverter *result;
11946 char *kwnames[] = {
11947 NULL
11948 };
11949
11950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EncodingConverter",kwnames)) goto fail;
11951 {
11952 PyThreadState* __tstate = wxPyBeginAllowThreads();
11953 result = (wxEncodingConverter *)new wxEncodingConverter();
11954
11955 wxPyEndAllowThreads(__tstate);
11956 if (PyErr_Occurred()) SWIG_fail;
11957 }
11958 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEncodingConverter, 1);
11959 return resultobj;
11960 fail:
11961 return NULL;
11962 }
11963
11964
11965 static PyObject *_wrap_delete_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
11966 PyObject *resultobj;
11967 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
11968 PyObject * obj0 = 0 ;
11969 char *kwnames[] = {
11970 (char *) "self", NULL
11971 };
11972
11973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EncodingConverter",kwnames,&obj0)) goto fail;
11974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
11975 if (SWIG_arg_fail(1)) SWIG_fail;
11976 {
11977 PyThreadState* __tstate = wxPyBeginAllowThreads();
11978 delete arg1;
11979
11980 wxPyEndAllowThreads(__tstate);
11981 if (PyErr_Occurred()) SWIG_fail;
11982 }
11983 Py_INCREF(Py_None); resultobj = Py_None;
11984 return resultobj;
11985 fail:
11986 return NULL;
11987 }
11988
11989
11990 static PyObject *_wrap_EncodingConverter_Init(PyObject *, PyObject *args, PyObject *kwargs) {
11991 PyObject *resultobj;
11992 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
11993 wxFontEncoding arg2 ;
11994 wxFontEncoding arg3 ;
11995 int arg4 = (int) wxCONVERT_STRICT ;
11996 bool result;
11997 PyObject * obj0 = 0 ;
11998 PyObject * obj1 = 0 ;
11999 PyObject * obj2 = 0 ;
12000 PyObject * obj3 = 0 ;
12001 char *kwnames[] = {
12002 (char *) "self",(char *) "input_enc",(char *) "output_enc",(char *) "method", NULL
12003 };
12004
12005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:EncodingConverter_Init",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12007 if (SWIG_arg_fail(1)) SWIG_fail;
12008 {
12009 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12010 if (SWIG_arg_fail(2)) SWIG_fail;
12011 }
12012 {
12013 arg3 = (wxFontEncoding)(SWIG_As_int(obj2));
12014 if (SWIG_arg_fail(3)) SWIG_fail;
12015 }
12016 if (obj3) {
12017 {
12018 arg4 = (int)(SWIG_As_int(obj3));
12019 if (SWIG_arg_fail(4)) SWIG_fail;
12020 }
12021 }
12022 {
12023 PyThreadState* __tstate = wxPyBeginAllowThreads();
12024 result = (bool)(arg1)->Init((wxFontEncoding )arg2,(wxFontEncoding )arg3,arg4);
12025
12026 wxPyEndAllowThreads(__tstate);
12027 if (PyErr_Occurred()) SWIG_fail;
12028 }
12029 {
12030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12031 }
12032 return resultobj;
12033 fail:
12034 return NULL;
12035 }
12036
12037
12038 static PyObject *_wrap_EncodingConverter_Convert(PyObject *, PyObject *args, PyObject *kwargs) {
12039 PyObject *resultobj;
12040 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12041 wxString *arg2 = 0 ;
12042 wxString result;
12043 bool temp2 = false ;
12044 PyObject * obj0 = 0 ;
12045 PyObject * obj1 = 0 ;
12046 char *kwnames[] = {
12047 (char *) "self",(char *) "input", NULL
12048 };
12049
12050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_Convert",kwnames,&obj0,&obj1)) goto fail;
12051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12052 if (SWIG_arg_fail(1)) SWIG_fail;
12053 {
12054 arg2 = wxString_in_helper(obj1);
12055 if (arg2 == NULL) SWIG_fail;
12056 temp2 = true;
12057 }
12058 {
12059 PyThreadState* __tstate = wxPyBeginAllowThreads();
12060 result = (arg1)->Convert((wxString const &)*arg2);
12061
12062 wxPyEndAllowThreads(__tstate);
12063 if (PyErr_Occurred()) SWIG_fail;
12064 }
12065 {
12066 #if wxUSE_UNICODE
12067 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12068 #else
12069 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12070 #endif
12071 }
12072 {
12073 if (temp2)
12074 delete arg2;
12075 }
12076 return resultobj;
12077 fail:
12078 {
12079 if (temp2)
12080 delete arg2;
12081 }
12082 return NULL;
12083 }
12084
12085
12086 static PyObject *_wrap_EncodingConverter_GetPlatformEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12087 PyObject *resultobj;
12088 wxFontEncoding arg1 ;
12089 int arg2 = (int) wxPLATFORM_CURRENT ;
12090 wxFontEncodingArray result;
12091 PyObject * obj0 = 0 ;
12092 PyObject * obj1 = 0 ;
12093 char *kwnames[] = {
12094 (char *) "enc",(char *) "platform", NULL
12095 };
12096
12097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EncodingConverter_GetPlatformEquivalents",kwnames,&obj0,&obj1)) goto fail;
12098 {
12099 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12100 if (SWIG_arg_fail(1)) SWIG_fail;
12101 }
12102 if (obj1) {
12103 {
12104 arg2 = (int)(SWIG_As_int(obj1));
12105 if (SWIG_arg_fail(2)) SWIG_fail;
12106 }
12107 }
12108 {
12109 PyThreadState* __tstate = wxPyBeginAllowThreads();
12110 result = wxEncodingConverter::GetPlatformEquivalents((wxFontEncoding )arg1,arg2);
12111
12112 wxPyEndAllowThreads(__tstate);
12113 if (PyErr_Occurred()) SWIG_fail;
12114 }
12115 {
12116 resultobj = PyList_New(0);
12117 for (size_t i=0; i < (&result)->GetCount(); i++) {
12118 PyObject* number = PyInt_FromLong((&result)->Item(i));
12119 PyList_Append(resultobj, number);
12120 Py_DECREF(number);
12121 }
12122 }
12123 return resultobj;
12124 fail:
12125 return NULL;
12126 }
12127
12128
12129 static PyObject *_wrap_EncodingConverter_GetAllEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12130 PyObject *resultobj;
12131 wxFontEncoding arg1 ;
12132 wxFontEncodingArray result;
12133 PyObject * obj0 = 0 ;
12134 char *kwnames[] = {
12135 (char *) "enc", NULL
12136 };
12137
12138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EncodingConverter_GetAllEquivalents",kwnames,&obj0)) goto fail;
12139 {
12140 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12141 if (SWIG_arg_fail(1)) SWIG_fail;
12142 }
12143 {
12144 PyThreadState* __tstate = wxPyBeginAllowThreads();
12145 result = wxEncodingConverter::GetAllEquivalents((wxFontEncoding )arg1);
12146
12147 wxPyEndAllowThreads(__tstate);
12148 if (PyErr_Occurred()) SWIG_fail;
12149 }
12150 {
12151 resultobj = PyList_New(0);
12152 for (size_t i=0; i < (&result)->GetCount(); i++) {
12153 PyObject* number = PyInt_FromLong((&result)->Item(i));
12154 PyList_Append(resultobj, number);
12155 Py_DECREF(number);
12156 }
12157 }
12158 return resultobj;
12159 fail:
12160 return NULL;
12161 }
12162
12163
12164 static PyObject *_wrap_EncodingConverter_CanConvert(PyObject *, PyObject *args, PyObject *kwargs) {
12165 PyObject *resultobj;
12166 wxFontEncoding arg1 ;
12167 wxFontEncoding arg2 ;
12168 bool result;
12169 PyObject * obj0 = 0 ;
12170 PyObject * obj1 = 0 ;
12171 char *kwnames[] = {
12172 (char *) "encIn",(char *) "encOut", NULL
12173 };
12174
12175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_CanConvert",kwnames,&obj0,&obj1)) goto fail;
12176 {
12177 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12178 if (SWIG_arg_fail(1)) SWIG_fail;
12179 }
12180 {
12181 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12182 if (SWIG_arg_fail(2)) SWIG_fail;
12183 }
12184 {
12185 PyThreadState* __tstate = wxPyBeginAllowThreads();
12186 result = (bool)wxEncodingConverter::CanConvert((wxFontEncoding )arg1,(wxFontEncoding )arg2);
12187
12188 wxPyEndAllowThreads(__tstate);
12189 if (PyErr_Occurred()) SWIG_fail;
12190 }
12191 {
12192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12193 }
12194 return resultobj;
12195 fail:
12196 return NULL;
12197 }
12198
12199
12200 static PyObject * EncodingConverter_swigregister(PyObject *, PyObject *args) {
12201 PyObject *obj;
12202 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12203 SWIG_TypeClientData(SWIGTYPE_p_wxEncodingConverter, obj);
12204 Py_INCREF(obj);
12205 return Py_BuildValue((char *)"");
12206 }
12207 static PyObject *_wrap_delete_DC(PyObject *, PyObject *args, PyObject *kwargs) {
12208 PyObject *resultobj;
12209 wxDC *arg1 = (wxDC *) 0 ;
12210 PyObject * obj0 = 0 ;
12211 char *kwnames[] = {
12212 (char *) "self", NULL
12213 };
12214
12215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DC",kwnames,&obj0)) goto fail;
12216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12217 if (SWIG_arg_fail(1)) SWIG_fail;
12218 {
12219 PyThreadState* __tstate = wxPyBeginAllowThreads();
12220 delete arg1;
12221
12222 wxPyEndAllowThreads(__tstate);
12223 if (PyErr_Occurred()) SWIG_fail;
12224 }
12225 Py_INCREF(Py_None); resultobj = Py_None;
12226 return resultobj;
12227 fail:
12228 return NULL;
12229 }
12230
12231
12232 static PyObject *_wrap_DC_BeginDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12233 PyObject *resultobj;
12234 wxDC *arg1 = (wxDC *) 0 ;
12235 PyObject * obj0 = 0 ;
12236 char *kwnames[] = {
12237 (char *) "self", NULL
12238 };
12239
12240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_BeginDrawing",kwnames,&obj0)) goto fail;
12241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12242 if (SWIG_arg_fail(1)) SWIG_fail;
12243 {
12244 PyThreadState* __tstate = wxPyBeginAllowThreads();
12245 (arg1)->BeginDrawing();
12246
12247 wxPyEndAllowThreads(__tstate);
12248 if (PyErr_Occurred()) SWIG_fail;
12249 }
12250 Py_INCREF(Py_None); resultobj = Py_None;
12251 return resultobj;
12252 fail:
12253 return NULL;
12254 }
12255
12256
12257 static PyObject *_wrap_DC_EndDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12258 PyObject *resultobj;
12259 wxDC *arg1 = (wxDC *) 0 ;
12260 PyObject * obj0 = 0 ;
12261 char *kwnames[] = {
12262 (char *) "self", NULL
12263 };
12264
12265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDrawing",kwnames,&obj0)) goto fail;
12266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12267 if (SWIG_arg_fail(1)) SWIG_fail;
12268 {
12269 PyThreadState* __tstate = wxPyBeginAllowThreads();
12270 (arg1)->EndDrawing();
12271
12272 wxPyEndAllowThreads(__tstate);
12273 if (PyErr_Occurred()) SWIG_fail;
12274 }
12275 Py_INCREF(Py_None); resultobj = Py_None;
12276 return resultobj;
12277 fail:
12278 return NULL;
12279 }
12280
12281
12282 static PyObject *_wrap_DC_FloodFill(PyObject *, PyObject *args, PyObject *kwargs) {
12283 PyObject *resultobj;
12284 wxDC *arg1 = (wxDC *) 0 ;
12285 int arg2 ;
12286 int arg3 ;
12287 wxColour *arg4 = 0 ;
12288 int arg5 = (int) wxFLOOD_SURFACE ;
12289 bool result;
12290 wxColour temp4 ;
12291 PyObject * obj0 = 0 ;
12292 PyObject * obj1 = 0 ;
12293 PyObject * obj2 = 0 ;
12294 PyObject * obj3 = 0 ;
12295 PyObject * obj4 = 0 ;
12296 char *kwnames[] = {
12297 (char *) "self",(char *) "x",(char *) "y",(char *) "col",(char *) "style", NULL
12298 };
12299
12300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_FloodFill",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12302 if (SWIG_arg_fail(1)) SWIG_fail;
12303 {
12304 arg2 = (int)(SWIG_As_int(obj1));
12305 if (SWIG_arg_fail(2)) SWIG_fail;
12306 }
12307 {
12308 arg3 = (int)(SWIG_As_int(obj2));
12309 if (SWIG_arg_fail(3)) SWIG_fail;
12310 }
12311 {
12312 arg4 = &temp4;
12313 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
12314 }
12315 if (obj4) {
12316 {
12317 arg5 = (int)(SWIG_As_int(obj4));
12318 if (SWIG_arg_fail(5)) SWIG_fail;
12319 }
12320 }
12321 {
12322 PyThreadState* __tstate = wxPyBeginAllowThreads();
12323 result = (bool)(arg1)->FloodFill(arg2,arg3,(wxColour const &)*arg4,arg5);
12324
12325 wxPyEndAllowThreads(__tstate);
12326 if (PyErr_Occurred()) SWIG_fail;
12327 }
12328 {
12329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12330 }
12331 return resultobj;
12332 fail:
12333 return NULL;
12334 }
12335
12336
12337 static PyObject *_wrap_DC_FloodFillPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12338 PyObject *resultobj;
12339 wxDC *arg1 = (wxDC *) 0 ;
12340 wxPoint *arg2 = 0 ;
12341 wxColour *arg3 = 0 ;
12342 int arg4 = (int) wxFLOOD_SURFACE ;
12343 bool result;
12344 wxPoint temp2 ;
12345 wxColour temp3 ;
12346 PyObject * obj0 = 0 ;
12347 PyObject * obj1 = 0 ;
12348 PyObject * obj2 = 0 ;
12349 PyObject * obj3 = 0 ;
12350 char *kwnames[] = {
12351 (char *) "self",(char *) "pt",(char *) "col",(char *) "style", NULL
12352 };
12353
12354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_FloodFillPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12356 if (SWIG_arg_fail(1)) SWIG_fail;
12357 {
12358 arg2 = &temp2;
12359 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12360 }
12361 {
12362 arg3 = &temp3;
12363 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
12364 }
12365 if (obj3) {
12366 {
12367 arg4 = (int)(SWIG_As_int(obj3));
12368 if (SWIG_arg_fail(4)) SWIG_fail;
12369 }
12370 }
12371 {
12372 PyThreadState* __tstate = wxPyBeginAllowThreads();
12373 result = (bool)(arg1)->FloodFill((wxPoint const &)*arg2,(wxColour const &)*arg3,arg4);
12374
12375 wxPyEndAllowThreads(__tstate);
12376 if (PyErr_Occurred()) SWIG_fail;
12377 }
12378 {
12379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12380 }
12381 return resultobj;
12382 fail:
12383 return NULL;
12384 }
12385
12386
12387 static PyObject *_wrap_DC_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
12388 PyObject *resultobj;
12389 wxDC *arg1 = (wxDC *) 0 ;
12390 int arg2 ;
12391 int arg3 ;
12392 wxColour result;
12393 PyObject * obj0 = 0 ;
12394 PyObject * obj1 = 0 ;
12395 PyObject * obj2 = 0 ;
12396 char *kwnames[] = {
12397 (char *) "self",(char *) "x",(char *) "y", NULL
12398 };
12399
12400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_GetPixel",kwnames,&obj0,&obj1,&obj2)) goto fail;
12401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12402 if (SWIG_arg_fail(1)) SWIG_fail;
12403 {
12404 arg2 = (int)(SWIG_As_int(obj1));
12405 if (SWIG_arg_fail(2)) SWIG_fail;
12406 }
12407 {
12408 arg3 = (int)(SWIG_As_int(obj2));
12409 if (SWIG_arg_fail(3)) SWIG_fail;
12410 }
12411 {
12412 PyThreadState* __tstate = wxPyBeginAllowThreads();
12413 result = wxDC_GetPixel(arg1,arg2,arg3);
12414
12415 wxPyEndAllowThreads(__tstate);
12416 if (PyErr_Occurred()) SWIG_fail;
12417 }
12418 {
12419 wxColour * resultptr;
12420 resultptr = new wxColour((wxColour &)(result));
12421 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12422 }
12423 return resultobj;
12424 fail:
12425 return NULL;
12426 }
12427
12428
12429 static PyObject *_wrap_DC_GetPixelPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12430 PyObject *resultobj;
12431 wxDC *arg1 = (wxDC *) 0 ;
12432 wxPoint *arg2 = 0 ;
12433 wxColour result;
12434 wxPoint temp2 ;
12435 PyObject * obj0 = 0 ;
12436 PyObject * obj1 = 0 ;
12437 char *kwnames[] = {
12438 (char *) "self",(char *) "pt", NULL
12439 };
12440
12441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPixelPoint",kwnames,&obj0,&obj1)) goto fail;
12442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12443 if (SWIG_arg_fail(1)) SWIG_fail;
12444 {
12445 arg2 = &temp2;
12446 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12447 }
12448 {
12449 PyThreadState* __tstate = wxPyBeginAllowThreads();
12450 result = wxDC_GetPixelPoint(arg1,(wxPoint const &)*arg2);
12451
12452 wxPyEndAllowThreads(__tstate);
12453 if (PyErr_Occurred()) SWIG_fail;
12454 }
12455 {
12456 wxColour * resultptr;
12457 resultptr = new wxColour((wxColour &)(result));
12458 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12459 }
12460 return resultobj;
12461 fail:
12462 return NULL;
12463 }
12464
12465
12466 static PyObject *_wrap_DC_DrawLine(PyObject *, PyObject *args, PyObject *kwargs) {
12467 PyObject *resultobj;
12468 wxDC *arg1 = (wxDC *) 0 ;
12469 int arg2 ;
12470 int arg3 ;
12471 int arg4 ;
12472 int arg5 ;
12473 PyObject * obj0 = 0 ;
12474 PyObject * obj1 = 0 ;
12475 PyObject * obj2 = 0 ;
12476 PyObject * obj3 = 0 ;
12477 PyObject * obj4 = 0 ;
12478 char *kwnames[] = {
12479 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2", NULL
12480 };
12481
12482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawLine",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12484 if (SWIG_arg_fail(1)) SWIG_fail;
12485 {
12486 arg2 = (int)(SWIG_As_int(obj1));
12487 if (SWIG_arg_fail(2)) SWIG_fail;
12488 }
12489 {
12490 arg3 = (int)(SWIG_As_int(obj2));
12491 if (SWIG_arg_fail(3)) SWIG_fail;
12492 }
12493 {
12494 arg4 = (int)(SWIG_As_int(obj3));
12495 if (SWIG_arg_fail(4)) SWIG_fail;
12496 }
12497 {
12498 arg5 = (int)(SWIG_As_int(obj4));
12499 if (SWIG_arg_fail(5)) SWIG_fail;
12500 }
12501 {
12502 PyThreadState* __tstate = wxPyBeginAllowThreads();
12503 (arg1)->DrawLine(arg2,arg3,arg4,arg5);
12504
12505 wxPyEndAllowThreads(__tstate);
12506 if (PyErr_Occurred()) SWIG_fail;
12507 }
12508 Py_INCREF(Py_None); resultobj = Py_None;
12509 return resultobj;
12510 fail:
12511 return NULL;
12512 }
12513
12514
12515 static PyObject *_wrap_DC_DrawLinePoint(PyObject *, PyObject *args, PyObject *kwargs) {
12516 PyObject *resultobj;
12517 wxDC *arg1 = (wxDC *) 0 ;
12518 wxPoint *arg2 = 0 ;
12519 wxPoint *arg3 = 0 ;
12520 wxPoint temp2 ;
12521 wxPoint temp3 ;
12522 PyObject * obj0 = 0 ;
12523 PyObject * obj1 = 0 ;
12524 PyObject * obj2 = 0 ;
12525 char *kwnames[] = {
12526 (char *) "self",(char *) "pt1",(char *) "pt2", NULL
12527 };
12528
12529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawLinePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
12530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12531 if (SWIG_arg_fail(1)) SWIG_fail;
12532 {
12533 arg2 = &temp2;
12534 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12535 }
12536 {
12537 arg3 = &temp3;
12538 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12539 }
12540 {
12541 PyThreadState* __tstate = wxPyBeginAllowThreads();
12542 (arg1)->DrawLine((wxPoint const &)*arg2,(wxPoint const &)*arg3);
12543
12544 wxPyEndAllowThreads(__tstate);
12545 if (PyErr_Occurred()) SWIG_fail;
12546 }
12547 Py_INCREF(Py_None); resultobj = Py_None;
12548 return resultobj;
12549 fail:
12550 return NULL;
12551 }
12552
12553
12554 static PyObject *_wrap_DC_CrossHair(PyObject *, PyObject *args, PyObject *kwargs) {
12555 PyObject *resultobj;
12556 wxDC *arg1 = (wxDC *) 0 ;
12557 int arg2 ;
12558 int arg3 ;
12559 PyObject * obj0 = 0 ;
12560 PyObject * obj1 = 0 ;
12561 PyObject * obj2 = 0 ;
12562 char *kwnames[] = {
12563 (char *) "self",(char *) "x",(char *) "y", NULL
12564 };
12565
12566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CrossHair",kwnames,&obj0,&obj1,&obj2)) goto fail;
12567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12568 if (SWIG_arg_fail(1)) SWIG_fail;
12569 {
12570 arg2 = (int)(SWIG_As_int(obj1));
12571 if (SWIG_arg_fail(2)) SWIG_fail;
12572 }
12573 {
12574 arg3 = (int)(SWIG_As_int(obj2));
12575 if (SWIG_arg_fail(3)) SWIG_fail;
12576 }
12577 {
12578 PyThreadState* __tstate = wxPyBeginAllowThreads();
12579 (arg1)->CrossHair(arg2,arg3);
12580
12581 wxPyEndAllowThreads(__tstate);
12582 if (PyErr_Occurred()) SWIG_fail;
12583 }
12584 Py_INCREF(Py_None); resultobj = Py_None;
12585 return resultobj;
12586 fail:
12587 return NULL;
12588 }
12589
12590
12591 static PyObject *_wrap_DC_CrossHairPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12592 PyObject *resultobj;
12593 wxDC *arg1 = (wxDC *) 0 ;
12594 wxPoint *arg2 = 0 ;
12595 wxPoint temp2 ;
12596 PyObject * obj0 = 0 ;
12597 PyObject * obj1 = 0 ;
12598 char *kwnames[] = {
12599 (char *) "self",(char *) "pt", NULL
12600 };
12601
12602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CrossHairPoint",kwnames,&obj0,&obj1)) goto fail;
12603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12604 if (SWIG_arg_fail(1)) SWIG_fail;
12605 {
12606 arg2 = &temp2;
12607 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12608 }
12609 {
12610 PyThreadState* __tstate = wxPyBeginAllowThreads();
12611 (arg1)->CrossHair((wxPoint const &)*arg2);
12612
12613 wxPyEndAllowThreads(__tstate);
12614 if (PyErr_Occurred()) SWIG_fail;
12615 }
12616 Py_INCREF(Py_None); resultobj = Py_None;
12617 return resultobj;
12618 fail:
12619 return NULL;
12620 }
12621
12622
12623 static PyObject *_wrap_DC_DrawArc(PyObject *, PyObject *args, PyObject *kwargs) {
12624 PyObject *resultobj;
12625 wxDC *arg1 = (wxDC *) 0 ;
12626 int arg2 ;
12627 int arg3 ;
12628 int arg4 ;
12629 int arg5 ;
12630 int arg6 ;
12631 int arg7 ;
12632 PyObject * obj0 = 0 ;
12633 PyObject * obj1 = 0 ;
12634 PyObject * obj2 = 0 ;
12635 PyObject * obj3 = 0 ;
12636 PyObject * obj4 = 0 ;
12637 PyObject * obj5 = 0 ;
12638 PyObject * obj6 = 0 ;
12639 char *kwnames[] = {
12640 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2",(char *) "xc",(char *) "yc", NULL
12641 };
12642
12643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12645 if (SWIG_arg_fail(1)) SWIG_fail;
12646 {
12647 arg2 = (int)(SWIG_As_int(obj1));
12648 if (SWIG_arg_fail(2)) SWIG_fail;
12649 }
12650 {
12651 arg3 = (int)(SWIG_As_int(obj2));
12652 if (SWIG_arg_fail(3)) SWIG_fail;
12653 }
12654 {
12655 arg4 = (int)(SWIG_As_int(obj3));
12656 if (SWIG_arg_fail(4)) SWIG_fail;
12657 }
12658 {
12659 arg5 = (int)(SWIG_As_int(obj4));
12660 if (SWIG_arg_fail(5)) SWIG_fail;
12661 }
12662 {
12663 arg6 = (int)(SWIG_As_int(obj5));
12664 if (SWIG_arg_fail(6)) SWIG_fail;
12665 }
12666 {
12667 arg7 = (int)(SWIG_As_int(obj6));
12668 if (SWIG_arg_fail(7)) SWIG_fail;
12669 }
12670 {
12671 PyThreadState* __tstate = wxPyBeginAllowThreads();
12672 (arg1)->DrawArc(arg2,arg3,arg4,arg5,arg6,arg7);
12673
12674 wxPyEndAllowThreads(__tstate);
12675 if (PyErr_Occurred()) SWIG_fail;
12676 }
12677 Py_INCREF(Py_None); resultobj = Py_None;
12678 return resultobj;
12679 fail:
12680 return NULL;
12681 }
12682
12683
12684 static PyObject *_wrap_DC_DrawArcPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12685 PyObject *resultobj;
12686 wxDC *arg1 = (wxDC *) 0 ;
12687 wxPoint *arg2 = 0 ;
12688 wxPoint *arg3 = 0 ;
12689 wxPoint *arg4 = 0 ;
12690 wxPoint temp2 ;
12691 wxPoint temp3 ;
12692 wxPoint temp4 ;
12693 PyObject * obj0 = 0 ;
12694 PyObject * obj1 = 0 ;
12695 PyObject * obj2 = 0 ;
12696 PyObject * obj3 = 0 ;
12697 char *kwnames[] = {
12698 (char *) "self",(char *) "pt1",(char *) "pt2",(char *) "center", NULL
12699 };
12700
12701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawArcPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12703 if (SWIG_arg_fail(1)) SWIG_fail;
12704 {
12705 arg2 = &temp2;
12706 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12707 }
12708 {
12709 arg3 = &temp3;
12710 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12711 }
12712 {
12713 arg4 = &temp4;
12714 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
12715 }
12716 {
12717 PyThreadState* __tstate = wxPyBeginAllowThreads();
12718 (arg1)->DrawArc((wxPoint const &)*arg2,(wxPoint const &)*arg3,(wxPoint const &)*arg4);
12719
12720 wxPyEndAllowThreads(__tstate);
12721 if (PyErr_Occurred()) SWIG_fail;
12722 }
12723 Py_INCREF(Py_None); resultobj = Py_None;
12724 return resultobj;
12725 fail:
12726 return NULL;
12727 }
12728
12729
12730 static PyObject *_wrap_DC_DrawCheckMark(PyObject *, PyObject *args, PyObject *kwargs) {
12731 PyObject *resultobj;
12732 wxDC *arg1 = (wxDC *) 0 ;
12733 int arg2 ;
12734 int arg3 ;
12735 int arg4 ;
12736 int arg5 ;
12737 PyObject * obj0 = 0 ;
12738 PyObject * obj1 = 0 ;
12739 PyObject * obj2 = 0 ;
12740 PyObject * obj3 = 0 ;
12741 PyObject * obj4 = 0 ;
12742 char *kwnames[] = {
12743 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
12744 };
12745
12746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawCheckMark",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12748 if (SWIG_arg_fail(1)) SWIG_fail;
12749 {
12750 arg2 = (int)(SWIG_As_int(obj1));
12751 if (SWIG_arg_fail(2)) SWIG_fail;
12752 }
12753 {
12754 arg3 = (int)(SWIG_As_int(obj2));
12755 if (SWIG_arg_fail(3)) SWIG_fail;
12756 }
12757 {
12758 arg4 = (int)(SWIG_As_int(obj3));
12759 if (SWIG_arg_fail(4)) SWIG_fail;
12760 }
12761 {
12762 arg5 = (int)(SWIG_As_int(obj4));
12763 if (SWIG_arg_fail(5)) SWIG_fail;
12764 }
12765 {
12766 PyThreadState* __tstate = wxPyBeginAllowThreads();
12767 (arg1)->DrawCheckMark(arg2,arg3,arg4,arg5);
12768
12769 wxPyEndAllowThreads(__tstate);
12770 if (PyErr_Occurred()) SWIG_fail;
12771 }
12772 Py_INCREF(Py_None); resultobj = Py_None;
12773 return resultobj;
12774 fail:
12775 return NULL;
12776 }
12777
12778
12779 static PyObject *_wrap_DC_DrawCheckMarkRect(PyObject *, PyObject *args, PyObject *kwargs) {
12780 PyObject *resultobj;
12781 wxDC *arg1 = (wxDC *) 0 ;
12782 wxRect *arg2 = 0 ;
12783 wxRect temp2 ;
12784 PyObject * obj0 = 0 ;
12785 PyObject * obj1 = 0 ;
12786 char *kwnames[] = {
12787 (char *) "self",(char *) "rect", NULL
12788 };
12789
12790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawCheckMarkRect",kwnames,&obj0,&obj1)) goto fail;
12791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12792 if (SWIG_arg_fail(1)) SWIG_fail;
12793 {
12794 arg2 = &temp2;
12795 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12796 }
12797 {
12798 PyThreadState* __tstate = wxPyBeginAllowThreads();
12799 (arg1)->DrawCheckMark((wxRect const &)*arg2);
12800
12801 wxPyEndAllowThreads(__tstate);
12802 if (PyErr_Occurred()) SWIG_fail;
12803 }
12804 Py_INCREF(Py_None); resultobj = Py_None;
12805 return resultobj;
12806 fail:
12807 return NULL;
12808 }
12809
12810
12811 static PyObject *_wrap_DC_DrawEllipticArc(PyObject *, PyObject *args, PyObject *kwargs) {
12812 PyObject *resultobj;
12813 wxDC *arg1 = (wxDC *) 0 ;
12814 int arg2 ;
12815 int arg3 ;
12816 int arg4 ;
12817 int arg5 ;
12818 double arg6 ;
12819 double arg7 ;
12820 PyObject * obj0 = 0 ;
12821 PyObject * obj1 = 0 ;
12822 PyObject * obj2 = 0 ;
12823 PyObject * obj3 = 0 ;
12824 PyObject * obj4 = 0 ;
12825 PyObject * obj5 = 0 ;
12826 PyObject * obj6 = 0 ;
12827 char *kwnames[] = {
12828 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h",(char *) "start",(char *) "end", NULL
12829 };
12830
12831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawEllipticArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12833 if (SWIG_arg_fail(1)) SWIG_fail;
12834 {
12835 arg2 = (int)(SWIG_As_int(obj1));
12836 if (SWIG_arg_fail(2)) SWIG_fail;
12837 }
12838 {
12839 arg3 = (int)(SWIG_As_int(obj2));
12840 if (SWIG_arg_fail(3)) SWIG_fail;
12841 }
12842 {
12843 arg4 = (int)(SWIG_As_int(obj3));
12844 if (SWIG_arg_fail(4)) SWIG_fail;
12845 }
12846 {
12847 arg5 = (int)(SWIG_As_int(obj4));
12848 if (SWIG_arg_fail(5)) SWIG_fail;
12849 }
12850 {
12851 arg6 = (double)(SWIG_As_double(obj5));
12852 if (SWIG_arg_fail(6)) SWIG_fail;
12853 }
12854 {
12855 arg7 = (double)(SWIG_As_double(obj6));
12856 if (SWIG_arg_fail(7)) SWIG_fail;
12857 }
12858 {
12859 PyThreadState* __tstate = wxPyBeginAllowThreads();
12860 (arg1)->DrawEllipticArc(arg2,arg3,arg4,arg5,arg6,arg7);
12861
12862 wxPyEndAllowThreads(__tstate);
12863 if (PyErr_Occurred()) SWIG_fail;
12864 }
12865 Py_INCREF(Py_None); resultobj = Py_None;
12866 return resultobj;
12867 fail:
12868 return NULL;
12869 }
12870
12871
12872 static PyObject *_wrap_DC_DrawEllipticArcPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
12873 PyObject *resultobj;
12874 wxDC *arg1 = (wxDC *) 0 ;
12875 wxPoint *arg2 = 0 ;
12876 wxSize *arg3 = 0 ;
12877 double arg4 ;
12878 double arg5 ;
12879 wxPoint temp2 ;
12880 wxSize temp3 ;
12881 PyObject * obj0 = 0 ;
12882 PyObject * obj1 = 0 ;
12883 PyObject * obj2 = 0 ;
12884 PyObject * obj3 = 0 ;
12885 PyObject * obj4 = 0 ;
12886 char *kwnames[] = {
12887 (char *) "self",(char *) "pt",(char *) "sz",(char *) "start",(char *) "end", NULL
12888 };
12889
12890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipticArcPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12892 if (SWIG_arg_fail(1)) SWIG_fail;
12893 {
12894 arg2 = &temp2;
12895 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12896 }
12897 {
12898 arg3 = &temp3;
12899 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
12900 }
12901 {
12902 arg4 = (double)(SWIG_As_double(obj3));
12903 if (SWIG_arg_fail(4)) SWIG_fail;
12904 }
12905 {
12906 arg5 = (double)(SWIG_As_double(obj4));
12907 if (SWIG_arg_fail(5)) SWIG_fail;
12908 }
12909 {
12910 PyThreadState* __tstate = wxPyBeginAllowThreads();
12911 (arg1)->DrawEllipticArc((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,arg5);
12912
12913 wxPyEndAllowThreads(__tstate);
12914 if (PyErr_Occurred()) SWIG_fail;
12915 }
12916 Py_INCREF(Py_None); resultobj = Py_None;
12917 return resultobj;
12918 fail:
12919 return NULL;
12920 }
12921
12922
12923 static PyObject *_wrap_DC_DrawPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12924 PyObject *resultobj;
12925 wxDC *arg1 = (wxDC *) 0 ;
12926 int arg2 ;
12927 int arg3 ;
12928 PyObject * obj0 = 0 ;
12929 PyObject * obj1 = 0 ;
12930 PyObject * obj2 = 0 ;
12931 char *kwnames[] = {
12932 (char *) "self",(char *) "x",(char *) "y", NULL
12933 };
12934
12935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
12936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12937 if (SWIG_arg_fail(1)) SWIG_fail;
12938 {
12939 arg2 = (int)(SWIG_As_int(obj1));
12940 if (SWIG_arg_fail(2)) SWIG_fail;
12941 }
12942 {
12943 arg3 = (int)(SWIG_As_int(obj2));
12944 if (SWIG_arg_fail(3)) SWIG_fail;
12945 }
12946 {
12947 PyThreadState* __tstate = wxPyBeginAllowThreads();
12948 (arg1)->DrawPoint(arg2,arg3);
12949
12950 wxPyEndAllowThreads(__tstate);
12951 if (PyErr_Occurred()) SWIG_fail;
12952 }
12953 Py_INCREF(Py_None); resultobj = Py_None;
12954 return resultobj;
12955 fail:
12956 return NULL;
12957 }
12958
12959
12960 static PyObject *_wrap_DC_DrawPointPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12961 PyObject *resultobj;
12962 wxDC *arg1 = (wxDC *) 0 ;
12963 wxPoint *arg2 = 0 ;
12964 wxPoint temp2 ;
12965 PyObject * obj0 = 0 ;
12966 PyObject * obj1 = 0 ;
12967 char *kwnames[] = {
12968 (char *) "self",(char *) "pt", NULL
12969 };
12970
12971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawPointPoint",kwnames,&obj0,&obj1)) goto fail;
12972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12973 if (SWIG_arg_fail(1)) SWIG_fail;
12974 {
12975 arg2 = &temp2;
12976 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12977 }
12978 {
12979 PyThreadState* __tstate = wxPyBeginAllowThreads();
12980 (arg1)->DrawPoint((wxPoint const &)*arg2);
12981
12982 wxPyEndAllowThreads(__tstate);
12983 if (PyErr_Occurred()) SWIG_fail;
12984 }
12985 Py_INCREF(Py_None); resultobj = Py_None;
12986 return resultobj;
12987 fail:
12988 return NULL;
12989 }
12990
12991
12992 static PyObject *_wrap_DC_DrawRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
12993 PyObject *resultobj;
12994 wxDC *arg1 = (wxDC *) 0 ;
12995 int arg2 ;
12996 int arg3 ;
12997 int arg4 ;
12998 int arg5 ;
12999 PyObject * obj0 = 0 ;
13000 PyObject * obj1 = 0 ;
13001 PyObject * obj2 = 0 ;
13002 PyObject * obj3 = 0 ;
13003 PyObject * obj4 = 0 ;
13004 char *kwnames[] = {
13005 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13006 };
13007
13008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13010 if (SWIG_arg_fail(1)) SWIG_fail;
13011 {
13012 arg2 = (int)(SWIG_As_int(obj1));
13013 if (SWIG_arg_fail(2)) SWIG_fail;
13014 }
13015 {
13016 arg3 = (int)(SWIG_As_int(obj2));
13017 if (SWIG_arg_fail(3)) SWIG_fail;
13018 }
13019 {
13020 arg4 = (int)(SWIG_As_int(obj3));
13021 if (SWIG_arg_fail(4)) SWIG_fail;
13022 }
13023 {
13024 arg5 = (int)(SWIG_As_int(obj4));
13025 if (SWIG_arg_fail(5)) SWIG_fail;
13026 }
13027 {
13028 PyThreadState* __tstate = wxPyBeginAllowThreads();
13029 (arg1)->DrawRectangle(arg2,arg3,arg4,arg5);
13030
13031 wxPyEndAllowThreads(__tstate);
13032 if (PyErr_Occurred()) SWIG_fail;
13033 }
13034 Py_INCREF(Py_None); resultobj = Py_None;
13035 return resultobj;
13036 fail:
13037 return NULL;
13038 }
13039
13040
13041 static PyObject *_wrap_DC_DrawRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13042 PyObject *resultobj;
13043 wxDC *arg1 = (wxDC *) 0 ;
13044 wxRect *arg2 = 0 ;
13045 wxRect temp2 ;
13046 PyObject * obj0 = 0 ;
13047 PyObject * obj1 = 0 ;
13048 char *kwnames[] = {
13049 (char *) "self",(char *) "rect", NULL
13050 };
13051
13052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawRectangleRect",kwnames,&obj0,&obj1)) goto fail;
13053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13054 if (SWIG_arg_fail(1)) SWIG_fail;
13055 {
13056 arg2 = &temp2;
13057 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13058 }
13059 {
13060 PyThreadState* __tstate = wxPyBeginAllowThreads();
13061 (arg1)->DrawRectangle((wxRect const &)*arg2);
13062
13063 wxPyEndAllowThreads(__tstate);
13064 if (PyErr_Occurred()) SWIG_fail;
13065 }
13066 Py_INCREF(Py_None); resultobj = Py_None;
13067 return resultobj;
13068 fail:
13069 return NULL;
13070 }
13071
13072
13073 static PyObject *_wrap_DC_DrawRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13074 PyObject *resultobj;
13075 wxDC *arg1 = (wxDC *) 0 ;
13076 wxPoint *arg2 = 0 ;
13077 wxSize *arg3 = 0 ;
13078 wxPoint temp2 ;
13079 wxSize temp3 ;
13080 PyObject * obj0 = 0 ;
13081 PyObject * obj1 = 0 ;
13082 PyObject * obj2 = 0 ;
13083 char *kwnames[] = {
13084 (char *) "self",(char *) "pt",(char *) "sz", NULL
13085 };
13086
13087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRectanglePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13089 if (SWIG_arg_fail(1)) SWIG_fail;
13090 {
13091 arg2 = &temp2;
13092 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13093 }
13094 {
13095 arg3 = &temp3;
13096 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13097 }
13098 {
13099 PyThreadState* __tstate = wxPyBeginAllowThreads();
13100 (arg1)->DrawRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3);
13101
13102 wxPyEndAllowThreads(__tstate);
13103 if (PyErr_Occurred()) SWIG_fail;
13104 }
13105 Py_INCREF(Py_None); resultobj = Py_None;
13106 return resultobj;
13107 fail:
13108 return NULL;
13109 }
13110
13111
13112 static PyObject *_wrap_DC_DrawRoundedRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
13113 PyObject *resultobj;
13114 wxDC *arg1 = (wxDC *) 0 ;
13115 int arg2 ;
13116 int arg3 ;
13117 int arg4 ;
13118 int arg5 ;
13119 double arg6 ;
13120 PyObject * obj0 = 0 ;
13121 PyObject * obj1 = 0 ;
13122 PyObject * obj2 = 0 ;
13123 PyObject * obj3 = 0 ;
13124 PyObject * obj4 = 0 ;
13125 PyObject * obj5 = 0 ;
13126 char *kwnames[] = {
13127 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "radius", NULL
13128 };
13129
13130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:DC_DrawRoundedRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
13131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13132 if (SWIG_arg_fail(1)) SWIG_fail;
13133 {
13134 arg2 = (int)(SWIG_As_int(obj1));
13135 if (SWIG_arg_fail(2)) SWIG_fail;
13136 }
13137 {
13138 arg3 = (int)(SWIG_As_int(obj2));
13139 if (SWIG_arg_fail(3)) SWIG_fail;
13140 }
13141 {
13142 arg4 = (int)(SWIG_As_int(obj3));
13143 if (SWIG_arg_fail(4)) SWIG_fail;
13144 }
13145 {
13146 arg5 = (int)(SWIG_As_int(obj4));
13147 if (SWIG_arg_fail(5)) SWIG_fail;
13148 }
13149 {
13150 arg6 = (double)(SWIG_As_double(obj5));
13151 if (SWIG_arg_fail(6)) SWIG_fail;
13152 }
13153 {
13154 PyThreadState* __tstate = wxPyBeginAllowThreads();
13155 (arg1)->DrawRoundedRectangle(arg2,arg3,arg4,arg5,arg6);
13156
13157 wxPyEndAllowThreads(__tstate);
13158 if (PyErr_Occurred()) SWIG_fail;
13159 }
13160 Py_INCREF(Py_None); resultobj = Py_None;
13161 return resultobj;
13162 fail:
13163 return NULL;
13164 }
13165
13166
13167 static PyObject *_wrap_DC_DrawRoundedRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13168 PyObject *resultobj;
13169 wxDC *arg1 = (wxDC *) 0 ;
13170 wxRect *arg2 = 0 ;
13171 double arg3 ;
13172 wxRect temp2 ;
13173 PyObject * obj0 = 0 ;
13174 PyObject * obj1 = 0 ;
13175 PyObject * obj2 = 0 ;
13176 char *kwnames[] = {
13177 (char *) "self",(char *) "r",(char *) "radius", NULL
13178 };
13179
13180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRoundedRectangleRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
13181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13182 if (SWIG_arg_fail(1)) SWIG_fail;
13183 {
13184 arg2 = &temp2;
13185 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13186 }
13187 {
13188 arg3 = (double)(SWIG_As_double(obj2));
13189 if (SWIG_arg_fail(3)) SWIG_fail;
13190 }
13191 {
13192 PyThreadState* __tstate = wxPyBeginAllowThreads();
13193 (arg1)->DrawRoundedRectangle((wxRect const &)*arg2,arg3);
13194
13195 wxPyEndAllowThreads(__tstate);
13196 if (PyErr_Occurred()) SWIG_fail;
13197 }
13198 Py_INCREF(Py_None); resultobj = Py_None;
13199 return resultobj;
13200 fail:
13201 return NULL;
13202 }
13203
13204
13205 static PyObject *_wrap_DC_DrawRoundedRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13206 PyObject *resultobj;
13207 wxDC *arg1 = (wxDC *) 0 ;
13208 wxPoint *arg2 = 0 ;
13209 wxSize *arg3 = 0 ;
13210 double arg4 ;
13211 wxPoint temp2 ;
13212 wxSize temp3 ;
13213 PyObject * obj0 = 0 ;
13214 PyObject * obj1 = 0 ;
13215 PyObject * obj2 = 0 ;
13216 PyObject * obj3 = 0 ;
13217 char *kwnames[] = {
13218 (char *) "self",(char *) "pt",(char *) "sz",(char *) "radius", NULL
13219 };
13220
13221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRoundedRectanglePointSize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13223 if (SWIG_arg_fail(1)) SWIG_fail;
13224 {
13225 arg2 = &temp2;
13226 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13227 }
13228 {
13229 arg3 = &temp3;
13230 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13231 }
13232 {
13233 arg4 = (double)(SWIG_As_double(obj3));
13234 if (SWIG_arg_fail(4)) SWIG_fail;
13235 }
13236 {
13237 PyThreadState* __tstate = wxPyBeginAllowThreads();
13238 (arg1)->DrawRoundedRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4);
13239
13240 wxPyEndAllowThreads(__tstate);
13241 if (PyErr_Occurred()) SWIG_fail;
13242 }
13243 Py_INCREF(Py_None); resultobj = Py_None;
13244 return resultobj;
13245 fail:
13246 return NULL;
13247 }
13248
13249
13250 static PyObject *_wrap_DC_DrawCircle(PyObject *, PyObject *args, PyObject *kwargs) {
13251 PyObject *resultobj;
13252 wxDC *arg1 = (wxDC *) 0 ;
13253 int arg2 ;
13254 int arg3 ;
13255 int arg4 ;
13256 PyObject * obj0 = 0 ;
13257 PyObject * obj1 = 0 ;
13258 PyObject * obj2 = 0 ;
13259 PyObject * obj3 = 0 ;
13260 char *kwnames[] = {
13261 (char *) "self",(char *) "x",(char *) "y",(char *) "radius", NULL
13262 };
13263
13264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawCircle",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13266 if (SWIG_arg_fail(1)) SWIG_fail;
13267 {
13268 arg2 = (int)(SWIG_As_int(obj1));
13269 if (SWIG_arg_fail(2)) SWIG_fail;
13270 }
13271 {
13272 arg3 = (int)(SWIG_As_int(obj2));
13273 if (SWIG_arg_fail(3)) SWIG_fail;
13274 }
13275 {
13276 arg4 = (int)(SWIG_As_int(obj3));
13277 if (SWIG_arg_fail(4)) SWIG_fail;
13278 }
13279 {
13280 PyThreadState* __tstate = wxPyBeginAllowThreads();
13281 (arg1)->DrawCircle(arg2,arg3,arg4);
13282
13283 wxPyEndAllowThreads(__tstate);
13284 if (PyErr_Occurred()) SWIG_fail;
13285 }
13286 Py_INCREF(Py_None); resultobj = Py_None;
13287 return resultobj;
13288 fail:
13289 return NULL;
13290 }
13291
13292
13293 static PyObject *_wrap_DC_DrawCirclePoint(PyObject *, PyObject *args, PyObject *kwargs) {
13294 PyObject *resultobj;
13295 wxDC *arg1 = (wxDC *) 0 ;
13296 wxPoint *arg2 = 0 ;
13297 int arg3 ;
13298 wxPoint temp2 ;
13299 PyObject * obj0 = 0 ;
13300 PyObject * obj1 = 0 ;
13301 PyObject * obj2 = 0 ;
13302 char *kwnames[] = {
13303 (char *) "self",(char *) "pt",(char *) "radius", NULL
13304 };
13305
13306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawCirclePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13308 if (SWIG_arg_fail(1)) SWIG_fail;
13309 {
13310 arg2 = &temp2;
13311 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13312 }
13313 {
13314 arg3 = (int)(SWIG_As_int(obj2));
13315 if (SWIG_arg_fail(3)) SWIG_fail;
13316 }
13317 {
13318 PyThreadState* __tstate = wxPyBeginAllowThreads();
13319 (arg1)->DrawCircle((wxPoint const &)*arg2,arg3);
13320
13321 wxPyEndAllowThreads(__tstate);
13322 if (PyErr_Occurred()) SWIG_fail;
13323 }
13324 Py_INCREF(Py_None); resultobj = Py_None;
13325 return resultobj;
13326 fail:
13327 return NULL;
13328 }
13329
13330
13331 static PyObject *_wrap_DC_DrawEllipse(PyObject *, PyObject *args, PyObject *kwargs) {
13332 PyObject *resultobj;
13333 wxDC *arg1 = (wxDC *) 0 ;
13334 int arg2 ;
13335 int arg3 ;
13336 int arg4 ;
13337 int arg5 ;
13338 PyObject * obj0 = 0 ;
13339 PyObject * obj1 = 0 ;
13340 PyObject * obj2 = 0 ;
13341 PyObject * obj3 = 0 ;
13342 PyObject * obj4 = 0 ;
13343 char *kwnames[] = {
13344 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13345 };
13346
13347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipse",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13349 if (SWIG_arg_fail(1)) SWIG_fail;
13350 {
13351 arg2 = (int)(SWIG_As_int(obj1));
13352 if (SWIG_arg_fail(2)) SWIG_fail;
13353 }
13354 {
13355 arg3 = (int)(SWIG_As_int(obj2));
13356 if (SWIG_arg_fail(3)) SWIG_fail;
13357 }
13358 {
13359 arg4 = (int)(SWIG_As_int(obj3));
13360 if (SWIG_arg_fail(4)) SWIG_fail;
13361 }
13362 {
13363 arg5 = (int)(SWIG_As_int(obj4));
13364 if (SWIG_arg_fail(5)) SWIG_fail;
13365 }
13366 {
13367 PyThreadState* __tstate = wxPyBeginAllowThreads();
13368 (arg1)->DrawEllipse(arg2,arg3,arg4,arg5);
13369
13370 wxPyEndAllowThreads(__tstate);
13371 if (PyErr_Occurred()) SWIG_fail;
13372 }
13373 Py_INCREF(Py_None); resultobj = Py_None;
13374 return resultobj;
13375 fail:
13376 return NULL;
13377 }
13378
13379
13380 static PyObject *_wrap_DC_DrawEllipseRect(PyObject *, PyObject *args, PyObject *kwargs) {
13381 PyObject *resultobj;
13382 wxDC *arg1 = (wxDC *) 0 ;
13383 wxRect *arg2 = 0 ;
13384 wxRect temp2 ;
13385 PyObject * obj0 = 0 ;
13386 PyObject * obj1 = 0 ;
13387 char *kwnames[] = {
13388 (char *) "self",(char *) "rect", NULL
13389 };
13390
13391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawEllipseRect",kwnames,&obj0,&obj1)) goto fail;
13392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13393 if (SWIG_arg_fail(1)) SWIG_fail;
13394 {
13395 arg2 = &temp2;
13396 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13397 }
13398 {
13399 PyThreadState* __tstate = wxPyBeginAllowThreads();
13400 (arg1)->DrawEllipse((wxRect const &)*arg2);
13401
13402 wxPyEndAllowThreads(__tstate);
13403 if (PyErr_Occurred()) SWIG_fail;
13404 }
13405 Py_INCREF(Py_None); resultobj = Py_None;
13406 return resultobj;
13407 fail:
13408 return NULL;
13409 }
13410
13411
13412 static PyObject *_wrap_DC_DrawEllipsePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13413 PyObject *resultobj;
13414 wxDC *arg1 = (wxDC *) 0 ;
13415 wxPoint *arg2 = 0 ;
13416 wxSize *arg3 = 0 ;
13417 wxPoint temp2 ;
13418 wxSize temp3 ;
13419 PyObject * obj0 = 0 ;
13420 PyObject * obj1 = 0 ;
13421 PyObject * obj2 = 0 ;
13422 char *kwnames[] = {
13423 (char *) "self",(char *) "pt",(char *) "sz", NULL
13424 };
13425
13426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawEllipsePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13428 if (SWIG_arg_fail(1)) SWIG_fail;
13429 {
13430 arg2 = &temp2;
13431 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13432 }
13433 {
13434 arg3 = &temp3;
13435 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13436 }
13437 {
13438 PyThreadState* __tstate = wxPyBeginAllowThreads();
13439 (arg1)->DrawEllipse((wxPoint const &)*arg2,(wxSize const &)*arg3);
13440
13441 wxPyEndAllowThreads(__tstate);
13442 if (PyErr_Occurred()) SWIG_fail;
13443 }
13444 Py_INCREF(Py_None); resultobj = Py_None;
13445 return resultobj;
13446 fail:
13447 return NULL;
13448 }
13449
13450
13451 static PyObject *_wrap_DC_DrawIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13452 PyObject *resultobj;
13453 wxDC *arg1 = (wxDC *) 0 ;
13454 wxIcon *arg2 = 0 ;
13455 int arg3 ;
13456 int arg4 ;
13457 PyObject * obj0 = 0 ;
13458 PyObject * obj1 = 0 ;
13459 PyObject * obj2 = 0 ;
13460 PyObject * obj3 = 0 ;
13461 char *kwnames[] = {
13462 (char *) "self",(char *) "icon",(char *) "x",(char *) "y", NULL
13463 };
13464
13465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawIcon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13467 if (SWIG_arg_fail(1)) SWIG_fail;
13468 {
13469 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
13470 if (SWIG_arg_fail(2)) SWIG_fail;
13471 if (arg2 == NULL) {
13472 SWIG_null_ref("wxIcon");
13473 }
13474 if (SWIG_arg_fail(2)) SWIG_fail;
13475 }
13476 {
13477 arg3 = (int)(SWIG_As_int(obj2));
13478 if (SWIG_arg_fail(3)) SWIG_fail;
13479 }
13480 {
13481 arg4 = (int)(SWIG_As_int(obj3));
13482 if (SWIG_arg_fail(4)) SWIG_fail;
13483 }
13484 {
13485 PyThreadState* __tstate = wxPyBeginAllowThreads();
13486 (arg1)->DrawIcon((wxIcon const &)*arg2,arg3,arg4);
13487
13488 wxPyEndAllowThreads(__tstate);
13489 if (PyErr_Occurred()) SWIG_fail;
13490 }
13491 Py_INCREF(Py_None); resultobj = Py_None;
13492 return resultobj;
13493 fail:
13494 return NULL;
13495 }
13496
13497
13498 static PyObject *_wrap_DC_DrawIconPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13499 PyObject *resultobj;
13500 wxDC *arg1 = (wxDC *) 0 ;
13501 wxIcon *arg2 = 0 ;
13502 wxPoint *arg3 = 0 ;
13503 wxPoint temp3 ;
13504 PyObject * obj0 = 0 ;
13505 PyObject * obj1 = 0 ;
13506 PyObject * obj2 = 0 ;
13507 char *kwnames[] = {
13508 (char *) "self",(char *) "icon",(char *) "pt", NULL
13509 };
13510
13511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawIconPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13513 if (SWIG_arg_fail(1)) SWIG_fail;
13514 {
13515 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
13516 if (SWIG_arg_fail(2)) SWIG_fail;
13517 if (arg2 == NULL) {
13518 SWIG_null_ref("wxIcon");
13519 }
13520 if (SWIG_arg_fail(2)) SWIG_fail;
13521 }
13522 {
13523 arg3 = &temp3;
13524 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13525 }
13526 {
13527 PyThreadState* __tstate = wxPyBeginAllowThreads();
13528 (arg1)->DrawIcon((wxIcon const &)*arg2,(wxPoint const &)*arg3);
13529
13530 wxPyEndAllowThreads(__tstate);
13531 if (PyErr_Occurred()) SWIG_fail;
13532 }
13533 Py_INCREF(Py_None); resultobj = Py_None;
13534 return resultobj;
13535 fail:
13536 return NULL;
13537 }
13538
13539
13540 static PyObject *_wrap_DC_DrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13541 PyObject *resultobj;
13542 wxDC *arg1 = (wxDC *) 0 ;
13543 wxBitmap *arg2 = 0 ;
13544 int arg3 ;
13545 int arg4 ;
13546 bool arg5 = (bool) false ;
13547 PyObject * obj0 = 0 ;
13548 PyObject * obj1 = 0 ;
13549 PyObject * obj2 = 0 ;
13550 PyObject * obj3 = 0 ;
13551 PyObject * obj4 = 0 ;
13552 char *kwnames[] = {
13553 (char *) "self",(char *) "bmp",(char *) "x",(char *) "y",(char *) "useMask", NULL
13554 };
13555
13556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_DrawBitmap",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13558 if (SWIG_arg_fail(1)) SWIG_fail;
13559 {
13560 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
13561 if (SWIG_arg_fail(2)) SWIG_fail;
13562 if (arg2 == NULL) {
13563 SWIG_null_ref("wxBitmap");
13564 }
13565 if (SWIG_arg_fail(2)) SWIG_fail;
13566 }
13567 {
13568 arg3 = (int)(SWIG_As_int(obj2));
13569 if (SWIG_arg_fail(3)) SWIG_fail;
13570 }
13571 {
13572 arg4 = (int)(SWIG_As_int(obj3));
13573 if (SWIG_arg_fail(4)) SWIG_fail;
13574 }
13575 if (obj4) {
13576 {
13577 arg5 = (bool)(SWIG_As_bool(obj4));
13578 if (SWIG_arg_fail(5)) SWIG_fail;
13579 }
13580 }
13581 {
13582 PyThreadState* __tstate = wxPyBeginAllowThreads();
13583 (arg1)->DrawBitmap((wxBitmap const &)*arg2,arg3,arg4,arg5);
13584
13585 wxPyEndAllowThreads(__tstate);
13586 if (PyErr_Occurred()) SWIG_fail;
13587 }
13588 Py_INCREF(Py_None); resultobj = Py_None;
13589 return resultobj;
13590 fail:
13591 return NULL;
13592 }
13593
13594
13595 static PyObject *_wrap_DC_DrawBitmapPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13596 PyObject *resultobj;
13597 wxDC *arg1 = (wxDC *) 0 ;
13598 wxBitmap *arg2 = 0 ;
13599 wxPoint *arg3 = 0 ;
13600 bool arg4 = (bool) false ;
13601 wxPoint temp3 ;
13602 PyObject * obj0 = 0 ;
13603 PyObject * obj1 = 0 ;
13604 PyObject * obj2 = 0 ;
13605 PyObject * obj3 = 0 ;
13606 char *kwnames[] = {
13607 (char *) "self",(char *) "bmp",(char *) "pt",(char *) "useMask", NULL
13608 };
13609
13610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_DrawBitmapPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13612 if (SWIG_arg_fail(1)) SWIG_fail;
13613 {
13614 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
13615 if (SWIG_arg_fail(2)) SWIG_fail;
13616 if (arg2 == NULL) {
13617 SWIG_null_ref("wxBitmap");
13618 }
13619 if (SWIG_arg_fail(2)) SWIG_fail;
13620 }
13621 {
13622 arg3 = &temp3;
13623 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13624 }
13625 if (obj3) {
13626 {
13627 arg4 = (bool)(SWIG_As_bool(obj3));
13628 if (SWIG_arg_fail(4)) SWIG_fail;
13629 }
13630 }
13631 {
13632 PyThreadState* __tstate = wxPyBeginAllowThreads();
13633 (arg1)->DrawBitmap((wxBitmap const &)*arg2,(wxPoint const &)*arg3,arg4);
13634
13635 wxPyEndAllowThreads(__tstate);
13636 if (PyErr_Occurred()) SWIG_fail;
13637 }
13638 Py_INCREF(Py_None); resultobj = Py_None;
13639 return resultobj;
13640 fail:
13641 return NULL;
13642 }
13643
13644
13645 static PyObject *_wrap_DC_DrawText(PyObject *, PyObject *args, PyObject *kwargs) {
13646 PyObject *resultobj;
13647 wxDC *arg1 = (wxDC *) 0 ;
13648 wxString *arg2 = 0 ;
13649 int arg3 ;
13650 int arg4 ;
13651 bool temp2 = false ;
13652 PyObject * obj0 = 0 ;
13653 PyObject * obj1 = 0 ;
13654 PyObject * obj2 = 0 ;
13655 PyObject * obj3 = 0 ;
13656 char *kwnames[] = {
13657 (char *) "self",(char *) "text",(char *) "x",(char *) "y", NULL
13658 };
13659
13660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawText",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13662 if (SWIG_arg_fail(1)) SWIG_fail;
13663 {
13664 arg2 = wxString_in_helper(obj1);
13665 if (arg2 == NULL) SWIG_fail;
13666 temp2 = true;
13667 }
13668 {
13669 arg3 = (int)(SWIG_As_int(obj2));
13670 if (SWIG_arg_fail(3)) SWIG_fail;
13671 }
13672 {
13673 arg4 = (int)(SWIG_As_int(obj3));
13674 if (SWIG_arg_fail(4)) SWIG_fail;
13675 }
13676 {
13677 PyThreadState* __tstate = wxPyBeginAllowThreads();
13678 (arg1)->DrawText((wxString const &)*arg2,arg3,arg4);
13679
13680 wxPyEndAllowThreads(__tstate);
13681 if (PyErr_Occurred()) SWIG_fail;
13682 }
13683 Py_INCREF(Py_None); resultobj = Py_None;
13684 {
13685 if (temp2)
13686 delete arg2;
13687 }
13688 return resultobj;
13689 fail:
13690 {
13691 if (temp2)
13692 delete arg2;
13693 }
13694 return NULL;
13695 }
13696
13697
13698 static PyObject *_wrap_DC_DrawTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13699 PyObject *resultobj;
13700 wxDC *arg1 = (wxDC *) 0 ;
13701 wxString *arg2 = 0 ;
13702 wxPoint *arg3 = 0 ;
13703 bool temp2 = false ;
13704 wxPoint temp3 ;
13705 PyObject * obj0 = 0 ;
13706 PyObject * obj1 = 0 ;
13707 PyObject * obj2 = 0 ;
13708 char *kwnames[] = {
13709 (char *) "self",(char *) "text",(char *) "pt", NULL
13710 };
13711
13712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawTextPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13714 if (SWIG_arg_fail(1)) SWIG_fail;
13715 {
13716 arg2 = wxString_in_helper(obj1);
13717 if (arg2 == NULL) SWIG_fail;
13718 temp2 = true;
13719 }
13720 {
13721 arg3 = &temp3;
13722 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13723 }
13724 {
13725 PyThreadState* __tstate = wxPyBeginAllowThreads();
13726 (arg1)->DrawText((wxString const &)*arg2,(wxPoint const &)*arg3);
13727
13728 wxPyEndAllowThreads(__tstate);
13729 if (PyErr_Occurred()) SWIG_fail;
13730 }
13731 Py_INCREF(Py_None); resultobj = Py_None;
13732 {
13733 if (temp2)
13734 delete arg2;
13735 }
13736 return resultobj;
13737 fail:
13738 {
13739 if (temp2)
13740 delete arg2;
13741 }
13742 return NULL;
13743 }
13744
13745
13746 static PyObject *_wrap_DC_DrawRotatedText(PyObject *, PyObject *args, PyObject *kwargs) {
13747 PyObject *resultobj;
13748 wxDC *arg1 = (wxDC *) 0 ;
13749 wxString *arg2 = 0 ;
13750 int arg3 ;
13751 int arg4 ;
13752 double arg5 ;
13753 bool temp2 = false ;
13754 PyObject * obj0 = 0 ;
13755 PyObject * obj1 = 0 ;
13756 PyObject * obj2 = 0 ;
13757 PyObject * obj3 = 0 ;
13758 PyObject * obj4 = 0 ;
13759 char *kwnames[] = {
13760 (char *) "self",(char *) "text",(char *) "x",(char *) "y",(char *) "angle", NULL
13761 };
13762
13763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRotatedText",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13765 if (SWIG_arg_fail(1)) SWIG_fail;
13766 {
13767 arg2 = wxString_in_helper(obj1);
13768 if (arg2 == NULL) SWIG_fail;
13769 temp2 = true;
13770 }
13771 {
13772 arg3 = (int)(SWIG_As_int(obj2));
13773 if (SWIG_arg_fail(3)) SWIG_fail;
13774 }
13775 {
13776 arg4 = (int)(SWIG_As_int(obj3));
13777 if (SWIG_arg_fail(4)) SWIG_fail;
13778 }
13779 {
13780 arg5 = (double)(SWIG_As_double(obj4));
13781 if (SWIG_arg_fail(5)) SWIG_fail;
13782 }
13783 {
13784 PyThreadState* __tstate = wxPyBeginAllowThreads();
13785 (arg1)->DrawRotatedText((wxString const &)*arg2,arg3,arg4,arg5);
13786
13787 wxPyEndAllowThreads(__tstate);
13788 if (PyErr_Occurred()) SWIG_fail;
13789 }
13790 Py_INCREF(Py_None); resultobj = Py_None;
13791 {
13792 if (temp2)
13793 delete arg2;
13794 }
13795 return resultobj;
13796 fail:
13797 {
13798 if (temp2)
13799 delete arg2;
13800 }
13801 return NULL;
13802 }
13803
13804
13805 static PyObject *_wrap_DC_DrawRotatedTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13806 PyObject *resultobj;
13807 wxDC *arg1 = (wxDC *) 0 ;
13808 wxString *arg2 = 0 ;
13809 wxPoint *arg3 = 0 ;
13810 double arg4 ;
13811 bool temp2 = false ;
13812 wxPoint temp3 ;
13813 PyObject * obj0 = 0 ;
13814 PyObject * obj1 = 0 ;
13815 PyObject * obj2 = 0 ;
13816 PyObject * obj3 = 0 ;
13817 char *kwnames[] = {
13818 (char *) "self",(char *) "text",(char *) "pt",(char *) "angle", NULL
13819 };
13820
13821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRotatedTextPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13823 if (SWIG_arg_fail(1)) SWIG_fail;
13824 {
13825 arg2 = wxString_in_helper(obj1);
13826 if (arg2 == NULL) SWIG_fail;
13827 temp2 = true;
13828 }
13829 {
13830 arg3 = &temp3;
13831 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13832 }
13833 {
13834 arg4 = (double)(SWIG_As_double(obj3));
13835 if (SWIG_arg_fail(4)) SWIG_fail;
13836 }
13837 {
13838 PyThreadState* __tstate = wxPyBeginAllowThreads();
13839 (arg1)->DrawRotatedText((wxString const &)*arg2,(wxPoint const &)*arg3,arg4);
13840
13841 wxPyEndAllowThreads(__tstate);
13842 if (PyErr_Occurred()) SWIG_fail;
13843 }
13844 Py_INCREF(Py_None); resultobj = Py_None;
13845 {
13846 if (temp2)
13847 delete arg2;
13848 }
13849 return resultobj;
13850 fail:
13851 {
13852 if (temp2)
13853 delete arg2;
13854 }
13855 return NULL;
13856 }
13857
13858
13859 static PyObject *_wrap_DC_Blit(PyObject *, PyObject *args, PyObject *kwargs) {
13860 PyObject *resultobj;
13861 wxDC *arg1 = (wxDC *) 0 ;
13862 int arg2 ;
13863 int arg3 ;
13864 int arg4 ;
13865 int arg5 ;
13866 wxDC *arg6 = (wxDC *) 0 ;
13867 int arg7 ;
13868 int arg8 ;
13869 int arg9 = (int) wxCOPY ;
13870 bool arg10 = (bool) false ;
13871 int arg11 = (int) -1 ;
13872 int arg12 = (int) -1 ;
13873 bool result;
13874 PyObject * obj0 = 0 ;
13875 PyObject * obj1 = 0 ;
13876 PyObject * obj2 = 0 ;
13877 PyObject * obj3 = 0 ;
13878 PyObject * obj4 = 0 ;
13879 PyObject * obj5 = 0 ;
13880 PyObject * obj6 = 0 ;
13881 PyObject * obj7 = 0 ;
13882 PyObject * obj8 = 0 ;
13883 PyObject * obj9 = 0 ;
13884 PyObject * obj10 = 0 ;
13885 PyObject * obj11 = 0 ;
13886 char *kwnames[] = {
13887 (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
13888 };
13889
13890 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;
13891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13892 if (SWIG_arg_fail(1)) SWIG_fail;
13893 {
13894 arg2 = (int)(SWIG_As_int(obj1));
13895 if (SWIG_arg_fail(2)) SWIG_fail;
13896 }
13897 {
13898 arg3 = (int)(SWIG_As_int(obj2));
13899 if (SWIG_arg_fail(3)) SWIG_fail;
13900 }
13901 {
13902 arg4 = (int)(SWIG_As_int(obj3));
13903 if (SWIG_arg_fail(4)) SWIG_fail;
13904 }
13905 {
13906 arg5 = (int)(SWIG_As_int(obj4));
13907 if (SWIG_arg_fail(5)) SWIG_fail;
13908 }
13909 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13910 if (SWIG_arg_fail(6)) SWIG_fail;
13911 {
13912 arg7 = (int)(SWIG_As_int(obj6));
13913 if (SWIG_arg_fail(7)) SWIG_fail;
13914 }
13915 {
13916 arg8 = (int)(SWIG_As_int(obj7));
13917 if (SWIG_arg_fail(8)) SWIG_fail;
13918 }
13919 if (obj8) {
13920 {
13921 arg9 = (int)(SWIG_As_int(obj8));
13922 if (SWIG_arg_fail(9)) SWIG_fail;
13923 }
13924 }
13925 if (obj9) {
13926 {
13927 arg10 = (bool)(SWIG_As_bool(obj9));
13928 if (SWIG_arg_fail(10)) SWIG_fail;
13929 }
13930 }
13931 if (obj10) {
13932 {
13933 arg11 = (int)(SWIG_As_int(obj10));
13934 if (SWIG_arg_fail(11)) SWIG_fail;
13935 }
13936 }
13937 if (obj11) {
13938 {
13939 arg12 = (int)(SWIG_As_int(obj11));
13940 if (SWIG_arg_fail(12)) SWIG_fail;
13941 }
13942 }
13943 {
13944 PyThreadState* __tstate = wxPyBeginAllowThreads();
13945 result = (bool)(arg1)->Blit(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
13946
13947 wxPyEndAllowThreads(__tstate);
13948 if (PyErr_Occurred()) SWIG_fail;
13949 }
13950 {
13951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13952 }
13953 return resultobj;
13954 fail:
13955 return NULL;
13956 }
13957
13958
13959 static PyObject *_wrap_DC_BlitPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13960 PyObject *resultobj;
13961 wxDC *arg1 = (wxDC *) 0 ;
13962 wxPoint *arg2 = 0 ;
13963 wxSize *arg3 = 0 ;
13964 wxDC *arg4 = (wxDC *) 0 ;
13965 wxPoint *arg5 = 0 ;
13966 int arg6 = (int) wxCOPY ;
13967 bool arg7 = (bool) false ;
13968 wxPoint const &arg8_defvalue = wxDefaultPosition ;
13969 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
13970 bool result;
13971 wxPoint temp2 ;
13972 wxSize temp3 ;
13973 wxPoint temp5 ;
13974 wxPoint temp8 ;
13975 PyObject * obj0 = 0 ;
13976 PyObject * obj1 = 0 ;
13977 PyObject * obj2 = 0 ;
13978 PyObject * obj3 = 0 ;
13979 PyObject * obj4 = 0 ;
13980 PyObject * obj5 = 0 ;
13981 PyObject * obj6 = 0 ;
13982 PyObject * obj7 = 0 ;
13983 char *kwnames[] = {
13984 (char *) "self",(char *) "destPt",(char *) "sz",(char *) "source",(char *) "srcPt",(char *) "rop",(char *) "useMask",(char *) "srcPtMask", NULL
13985 };
13986
13987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:DC_BlitPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
13988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13989 if (SWIG_arg_fail(1)) SWIG_fail;
13990 {
13991 arg2 = &temp2;
13992 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13993 }
13994 {
13995 arg3 = &temp3;
13996 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13997 }
13998 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13999 if (SWIG_arg_fail(4)) SWIG_fail;
14000 {
14001 arg5 = &temp5;
14002 if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
14003 }
14004 if (obj5) {
14005 {
14006 arg6 = (int)(SWIG_As_int(obj5));
14007 if (SWIG_arg_fail(6)) SWIG_fail;
14008 }
14009 }
14010 if (obj6) {
14011 {
14012 arg7 = (bool)(SWIG_As_bool(obj6));
14013 if (SWIG_arg_fail(7)) SWIG_fail;
14014 }
14015 }
14016 if (obj7) {
14017 {
14018 arg8 = &temp8;
14019 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
14020 }
14021 }
14022 {
14023 PyThreadState* __tstate = wxPyBeginAllowThreads();
14024 result = (bool)(arg1)->Blit((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,(wxPoint const &)*arg5,arg6,arg7,(wxPoint const &)*arg8);
14025
14026 wxPyEndAllowThreads(__tstate);
14027 if (PyErr_Occurred()) SWIG_fail;
14028 }
14029 {
14030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14031 }
14032 return resultobj;
14033 fail:
14034 return NULL;
14035 }
14036
14037
14038 static PyObject *_wrap_DC_SetClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14039 PyObject *resultobj;
14040 wxDC *arg1 = (wxDC *) 0 ;
14041 int arg2 ;
14042 int arg3 ;
14043 int arg4 ;
14044 int arg5 ;
14045 PyObject * obj0 = 0 ;
14046 PyObject * obj1 = 0 ;
14047 PyObject * obj2 = 0 ;
14048 PyObject * obj3 = 0 ;
14049 PyObject * obj4 = 0 ;
14050 char *kwnames[] = {
14051 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
14052 };
14053
14054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_SetClippingRegion",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14056 if (SWIG_arg_fail(1)) SWIG_fail;
14057 {
14058 arg2 = (int)(SWIG_As_int(obj1));
14059 if (SWIG_arg_fail(2)) SWIG_fail;
14060 }
14061 {
14062 arg3 = (int)(SWIG_As_int(obj2));
14063 if (SWIG_arg_fail(3)) SWIG_fail;
14064 }
14065 {
14066 arg4 = (int)(SWIG_As_int(obj3));
14067 if (SWIG_arg_fail(4)) SWIG_fail;
14068 }
14069 {
14070 arg5 = (int)(SWIG_As_int(obj4));
14071 if (SWIG_arg_fail(5)) SWIG_fail;
14072 }
14073 {
14074 PyThreadState* __tstate = wxPyBeginAllowThreads();
14075 (arg1)->SetClippingRegion(arg2,arg3,arg4,arg5);
14076
14077 wxPyEndAllowThreads(__tstate);
14078 if (PyErr_Occurred()) SWIG_fail;
14079 }
14080 Py_INCREF(Py_None); resultobj = Py_None;
14081 return resultobj;
14082 fail:
14083 return NULL;
14084 }
14085
14086
14087 static PyObject *_wrap_DC_SetClippingRegionPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14088 PyObject *resultobj;
14089 wxDC *arg1 = (wxDC *) 0 ;
14090 wxPoint *arg2 = 0 ;
14091 wxSize *arg3 = 0 ;
14092 wxPoint temp2 ;
14093 wxSize temp3 ;
14094 PyObject * obj0 = 0 ;
14095 PyObject * obj1 = 0 ;
14096 PyObject * obj2 = 0 ;
14097 char *kwnames[] = {
14098 (char *) "self",(char *) "pt",(char *) "sz", NULL
14099 };
14100
14101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetClippingRegionPointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14103 if (SWIG_arg_fail(1)) SWIG_fail;
14104 {
14105 arg2 = &temp2;
14106 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14107 }
14108 {
14109 arg3 = &temp3;
14110 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14111 }
14112 {
14113 PyThreadState* __tstate = wxPyBeginAllowThreads();
14114 (arg1)->SetClippingRegion((wxPoint const &)*arg2,(wxSize const &)*arg3);
14115
14116 wxPyEndAllowThreads(__tstate);
14117 if (PyErr_Occurred()) SWIG_fail;
14118 }
14119 Py_INCREF(Py_None); resultobj = Py_None;
14120 return resultobj;
14121 fail:
14122 return NULL;
14123 }
14124
14125
14126 static PyObject *_wrap_DC_SetClippingRegionAsRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14127 PyObject *resultobj;
14128 wxDC *arg1 = (wxDC *) 0 ;
14129 wxRegion *arg2 = 0 ;
14130 PyObject * obj0 = 0 ;
14131 PyObject * obj1 = 0 ;
14132 char *kwnames[] = {
14133 (char *) "self",(char *) "region", NULL
14134 };
14135
14136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRegionAsRegion",kwnames,&obj0,&obj1)) goto fail;
14137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14138 if (SWIG_arg_fail(1)) SWIG_fail;
14139 {
14140 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
14141 if (SWIG_arg_fail(2)) SWIG_fail;
14142 if (arg2 == NULL) {
14143 SWIG_null_ref("wxRegion");
14144 }
14145 if (SWIG_arg_fail(2)) SWIG_fail;
14146 }
14147 {
14148 PyThreadState* __tstate = wxPyBeginAllowThreads();
14149 (arg1)->SetClippingRegion((wxRegion const &)*arg2);
14150
14151 wxPyEndAllowThreads(__tstate);
14152 if (PyErr_Occurred()) SWIG_fail;
14153 }
14154 Py_INCREF(Py_None); resultobj = Py_None;
14155 return resultobj;
14156 fail:
14157 return NULL;
14158 }
14159
14160
14161 static PyObject *_wrap_DC_SetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
14162 PyObject *resultobj;
14163 wxDC *arg1 = (wxDC *) 0 ;
14164 wxRect *arg2 = 0 ;
14165 wxRect temp2 ;
14166 PyObject * obj0 = 0 ;
14167 PyObject * obj1 = 0 ;
14168 char *kwnames[] = {
14169 (char *) "self",(char *) "rect", NULL
14170 };
14171
14172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRect",kwnames,&obj0,&obj1)) goto fail;
14173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14174 if (SWIG_arg_fail(1)) SWIG_fail;
14175 {
14176 arg2 = &temp2;
14177 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14178 }
14179 {
14180 PyThreadState* __tstate = wxPyBeginAllowThreads();
14181 (arg1)->SetClippingRegion((wxRect const &)*arg2);
14182
14183 wxPyEndAllowThreads(__tstate);
14184 if (PyErr_Occurred()) SWIG_fail;
14185 }
14186 Py_INCREF(Py_None); resultobj = Py_None;
14187 return resultobj;
14188 fail:
14189 return NULL;
14190 }
14191
14192
14193 static PyObject *_wrap_DC_DrawLines(PyObject *, PyObject *args, PyObject *kwargs) {
14194 PyObject *resultobj;
14195 wxDC *arg1 = (wxDC *) 0 ;
14196 int arg2 ;
14197 wxPoint *arg3 = (wxPoint *) 0 ;
14198 int arg4 = (int) 0 ;
14199 int arg5 = (int) 0 ;
14200 PyObject * obj0 = 0 ;
14201 PyObject * obj1 = 0 ;
14202 PyObject * obj2 = 0 ;
14203 PyObject * obj3 = 0 ;
14204 char *kwnames[] = {
14205 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset", NULL
14206 };
14207
14208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DC_DrawLines",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14210 if (SWIG_arg_fail(1)) SWIG_fail;
14211 {
14212 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14213 if (arg3 == NULL) SWIG_fail;
14214 }
14215 if (obj2) {
14216 {
14217 arg4 = (int)(SWIG_As_int(obj2));
14218 if (SWIG_arg_fail(4)) SWIG_fail;
14219 }
14220 }
14221 if (obj3) {
14222 {
14223 arg5 = (int)(SWIG_As_int(obj3));
14224 if (SWIG_arg_fail(5)) SWIG_fail;
14225 }
14226 }
14227 {
14228 PyThreadState* __tstate = wxPyBeginAllowThreads();
14229 (arg1)->DrawLines(arg2,arg3,arg4,arg5);
14230
14231 wxPyEndAllowThreads(__tstate);
14232 if (PyErr_Occurred()) SWIG_fail;
14233 }
14234 Py_INCREF(Py_None); resultobj = Py_None;
14235 {
14236 if (arg3) delete [] arg3;
14237 }
14238 return resultobj;
14239 fail:
14240 {
14241 if (arg3) delete [] arg3;
14242 }
14243 return NULL;
14244 }
14245
14246
14247 static PyObject *_wrap_DC_DrawPolygon(PyObject *, PyObject *args, PyObject *kwargs) {
14248 PyObject *resultobj;
14249 wxDC *arg1 = (wxDC *) 0 ;
14250 int arg2 ;
14251 wxPoint *arg3 = (wxPoint *) 0 ;
14252 int arg4 = (int) 0 ;
14253 int arg5 = (int) 0 ;
14254 int arg6 = (int) wxODDEVEN_RULE ;
14255 PyObject * obj0 = 0 ;
14256 PyObject * obj1 = 0 ;
14257 PyObject * obj2 = 0 ;
14258 PyObject * obj3 = 0 ;
14259 PyObject * obj4 = 0 ;
14260 char *kwnames[] = {
14261 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset",(char *) "fillStyle", NULL
14262 };
14263
14264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DC_DrawPolygon",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14266 if (SWIG_arg_fail(1)) SWIG_fail;
14267 {
14268 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14269 if (arg3 == NULL) SWIG_fail;
14270 }
14271 if (obj2) {
14272 {
14273 arg4 = (int)(SWIG_As_int(obj2));
14274 if (SWIG_arg_fail(4)) SWIG_fail;
14275 }
14276 }
14277 if (obj3) {
14278 {
14279 arg5 = (int)(SWIG_As_int(obj3));
14280 if (SWIG_arg_fail(5)) SWIG_fail;
14281 }
14282 }
14283 if (obj4) {
14284 {
14285 arg6 = (int)(SWIG_As_int(obj4));
14286 if (SWIG_arg_fail(6)) SWIG_fail;
14287 }
14288 }
14289 {
14290 PyThreadState* __tstate = wxPyBeginAllowThreads();
14291 (arg1)->DrawPolygon(arg2,arg3,arg4,arg5,arg6);
14292
14293 wxPyEndAllowThreads(__tstate);
14294 if (PyErr_Occurred()) SWIG_fail;
14295 }
14296 Py_INCREF(Py_None); resultobj = Py_None;
14297 {
14298 if (arg3) delete [] arg3;
14299 }
14300 return resultobj;
14301 fail:
14302 {
14303 if (arg3) delete [] arg3;
14304 }
14305 return NULL;
14306 }
14307
14308
14309 static PyObject *_wrap_DC_DrawLabel(PyObject *, PyObject *args, PyObject *kwargs) {
14310 PyObject *resultobj;
14311 wxDC *arg1 = (wxDC *) 0 ;
14312 wxString *arg2 = 0 ;
14313 wxRect *arg3 = 0 ;
14314 int arg4 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
14315 int arg5 = (int) -1 ;
14316 bool temp2 = false ;
14317 wxRect temp3 ;
14318 PyObject * obj0 = 0 ;
14319 PyObject * obj1 = 0 ;
14320 PyObject * obj2 = 0 ;
14321 PyObject * obj3 = 0 ;
14322 PyObject * obj4 = 0 ;
14323 char *kwnames[] = {
14324 (char *) "self",(char *) "text",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
14325 };
14326
14327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:DC_DrawLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14329 if (SWIG_arg_fail(1)) SWIG_fail;
14330 {
14331 arg2 = wxString_in_helper(obj1);
14332 if (arg2 == NULL) SWIG_fail;
14333 temp2 = true;
14334 }
14335 {
14336 arg3 = &temp3;
14337 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
14338 }
14339 if (obj3) {
14340 {
14341 arg4 = (int)(SWIG_As_int(obj3));
14342 if (SWIG_arg_fail(4)) SWIG_fail;
14343 }
14344 }
14345 if (obj4) {
14346 {
14347 arg5 = (int)(SWIG_As_int(obj4));
14348 if (SWIG_arg_fail(5)) SWIG_fail;
14349 }
14350 }
14351 {
14352 PyThreadState* __tstate = wxPyBeginAllowThreads();
14353 (arg1)->DrawLabel((wxString const &)*arg2,(wxRect const &)*arg3,arg4,arg5);
14354
14355 wxPyEndAllowThreads(__tstate);
14356 if (PyErr_Occurred()) SWIG_fail;
14357 }
14358 Py_INCREF(Py_None); resultobj = Py_None;
14359 {
14360 if (temp2)
14361 delete arg2;
14362 }
14363 return resultobj;
14364 fail:
14365 {
14366 if (temp2)
14367 delete arg2;
14368 }
14369 return NULL;
14370 }
14371
14372
14373 static PyObject *_wrap_DC_DrawImageLabel(PyObject *, PyObject *args, PyObject *kwargs) {
14374 PyObject *resultobj;
14375 wxDC *arg1 = (wxDC *) 0 ;
14376 wxString *arg2 = 0 ;
14377 wxBitmap *arg3 = 0 ;
14378 wxRect *arg4 = 0 ;
14379 int arg5 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
14380 int arg6 = (int) -1 ;
14381 wxRect result;
14382 bool temp2 = false ;
14383 wxRect temp4 ;
14384 PyObject * obj0 = 0 ;
14385 PyObject * obj1 = 0 ;
14386 PyObject * obj2 = 0 ;
14387 PyObject * obj3 = 0 ;
14388 PyObject * obj4 = 0 ;
14389 PyObject * obj5 = 0 ;
14390 char *kwnames[] = {
14391 (char *) "self",(char *) "text",(char *) "image",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
14392 };
14393
14394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:DC_DrawImageLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
14395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14396 if (SWIG_arg_fail(1)) SWIG_fail;
14397 {
14398 arg2 = wxString_in_helper(obj1);
14399 if (arg2 == NULL) SWIG_fail;
14400 temp2 = true;
14401 }
14402 {
14403 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
14404 if (SWIG_arg_fail(3)) SWIG_fail;
14405 if (arg3 == NULL) {
14406 SWIG_null_ref("wxBitmap");
14407 }
14408 if (SWIG_arg_fail(3)) SWIG_fail;
14409 }
14410 {
14411 arg4 = &temp4;
14412 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
14413 }
14414 if (obj4) {
14415 {
14416 arg5 = (int)(SWIG_As_int(obj4));
14417 if (SWIG_arg_fail(5)) SWIG_fail;
14418 }
14419 }
14420 if (obj5) {
14421 {
14422 arg6 = (int)(SWIG_As_int(obj5));
14423 if (SWIG_arg_fail(6)) SWIG_fail;
14424 }
14425 }
14426 {
14427 PyThreadState* __tstate = wxPyBeginAllowThreads();
14428 result = wxDC_DrawImageLabel(arg1,(wxString const &)*arg2,(wxBitmap const &)*arg3,(wxRect const &)*arg4,arg5,arg6);
14429
14430 wxPyEndAllowThreads(__tstate);
14431 if (PyErr_Occurred()) SWIG_fail;
14432 }
14433 {
14434 wxRect * resultptr;
14435 resultptr = new wxRect((wxRect &)(result));
14436 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
14437 }
14438 {
14439 if (temp2)
14440 delete arg2;
14441 }
14442 return resultobj;
14443 fail:
14444 {
14445 if (temp2)
14446 delete arg2;
14447 }
14448 return NULL;
14449 }
14450
14451
14452 static PyObject *_wrap_DC_DrawSpline(PyObject *, PyObject *args, PyObject *kwargs) {
14453 PyObject *resultobj;
14454 wxDC *arg1 = (wxDC *) 0 ;
14455 int arg2 ;
14456 wxPoint *arg3 = (wxPoint *) 0 ;
14457 PyObject * obj0 = 0 ;
14458 PyObject * obj1 = 0 ;
14459 char *kwnames[] = {
14460 (char *) "self",(char *) "points", NULL
14461 };
14462
14463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawSpline",kwnames,&obj0,&obj1)) goto fail;
14464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14465 if (SWIG_arg_fail(1)) SWIG_fail;
14466 {
14467 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14468 if (arg3 == NULL) SWIG_fail;
14469 }
14470 {
14471 PyThreadState* __tstate = wxPyBeginAllowThreads();
14472 (arg1)->DrawSpline(arg2,arg3);
14473
14474 wxPyEndAllowThreads(__tstate);
14475 if (PyErr_Occurred()) SWIG_fail;
14476 }
14477 Py_INCREF(Py_None); resultobj = Py_None;
14478 {
14479 if (arg3) delete [] arg3;
14480 }
14481 return resultobj;
14482 fail:
14483 {
14484 if (arg3) delete [] arg3;
14485 }
14486 return NULL;
14487 }
14488
14489
14490 static PyObject *_wrap_DC_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
14491 PyObject *resultobj;
14492 wxDC *arg1 = (wxDC *) 0 ;
14493 PyObject * obj0 = 0 ;
14494 char *kwnames[] = {
14495 (char *) "self", NULL
14496 };
14497
14498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Clear",kwnames,&obj0)) goto fail;
14499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14500 if (SWIG_arg_fail(1)) SWIG_fail;
14501 {
14502 PyThreadState* __tstate = wxPyBeginAllowThreads();
14503 (arg1)->Clear();
14504
14505 wxPyEndAllowThreads(__tstate);
14506 if (PyErr_Occurred()) SWIG_fail;
14507 }
14508 Py_INCREF(Py_None); resultobj = Py_None;
14509 return resultobj;
14510 fail:
14511 return NULL;
14512 }
14513
14514
14515 static PyObject *_wrap_DC_StartDoc(PyObject *, PyObject *args, PyObject *kwargs) {
14516 PyObject *resultobj;
14517 wxDC *arg1 = (wxDC *) 0 ;
14518 wxString *arg2 = 0 ;
14519 bool result;
14520 bool temp2 = false ;
14521 PyObject * obj0 = 0 ;
14522 PyObject * obj1 = 0 ;
14523 char *kwnames[] = {
14524 (char *) "self",(char *) "message", NULL
14525 };
14526
14527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_StartDoc",kwnames,&obj0,&obj1)) goto fail;
14528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14529 if (SWIG_arg_fail(1)) SWIG_fail;
14530 {
14531 arg2 = wxString_in_helper(obj1);
14532 if (arg2 == NULL) SWIG_fail;
14533 temp2 = true;
14534 }
14535 {
14536 PyThreadState* __tstate = wxPyBeginAllowThreads();
14537 result = (bool)(arg1)->StartDoc((wxString const &)*arg2);
14538
14539 wxPyEndAllowThreads(__tstate);
14540 if (PyErr_Occurred()) SWIG_fail;
14541 }
14542 {
14543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14544 }
14545 {
14546 if (temp2)
14547 delete arg2;
14548 }
14549 return resultobj;
14550 fail:
14551 {
14552 if (temp2)
14553 delete arg2;
14554 }
14555 return NULL;
14556 }
14557
14558
14559 static PyObject *_wrap_DC_EndDoc(PyObject *, PyObject *args, PyObject *kwargs) {
14560 PyObject *resultobj;
14561 wxDC *arg1 = (wxDC *) 0 ;
14562 PyObject * obj0 = 0 ;
14563 char *kwnames[] = {
14564 (char *) "self", NULL
14565 };
14566
14567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDoc",kwnames,&obj0)) goto fail;
14568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14569 if (SWIG_arg_fail(1)) SWIG_fail;
14570 {
14571 PyThreadState* __tstate = wxPyBeginAllowThreads();
14572 (arg1)->EndDoc();
14573
14574 wxPyEndAllowThreads(__tstate);
14575 if (PyErr_Occurred()) SWIG_fail;
14576 }
14577 Py_INCREF(Py_None); resultobj = Py_None;
14578 return resultobj;
14579 fail:
14580 return NULL;
14581 }
14582
14583
14584 static PyObject *_wrap_DC_StartPage(PyObject *, PyObject *args, PyObject *kwargs) {
14585 PyObject *resultobj;
14586 wxDC *arg1 = (wxDC *) 0 ;
14587 PyObject * obj0 = 0 ;
14588 char *kwnames[] = {
14589 (char *) "self", NULL
14590 };
14591
14592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_StartPage",kwnames,&obj0)) goto fail;
14593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14594 if (SWIG_arg_fail(1)) SWIG_fail;
14595 {
14596 PyThreadState* __tstate = wxPyBeginAllowThreads();
14597 (arg1)->StartPage();
14598
14599 wxPyEndAllowThreads(__tstate);
14600 if (PyErr_Occurred()) SWIG_fail;
14601 }
14602 Py_INCREF(Py_None); resultobj = Py_None;
14603 return resultobj;
14604 fail:
14605 return NULL;
14606 }
14607
14608
14609 static PyObject *_wrap_DC_EndPage(PyObject *, PyObject *args, PyObject *kwargs) {
14610 PyObject *resultobj;
14611 wxDC *arg1 = (wxDC *) 0 ;
14612 PyObject * obj0 = 0 ;
14613 char *kwnames[] = {
14614 (char *) "self", NULL
14615 };
14616
14617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndPage",kwnames,&obj0)) goto fail;
14618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14619 if (SWIG_arg_fail(1)) SWIG_fail;
14620 {
14621 PyThreadState* __tstate = wxPyBeginAllowThreads();
14622 (arg1)->EndPage();
14623
14624 wxPyEndAllowThreads(__tstate);
14625 if (PyErr_Occurred()) SWIG_fail;
14626 }
14627 Py_INCREF(Py_None); resultobj = Py_None;
14628 return resultobj;
14629 fail:
14630 return NULL;
14631 }
14632
14633
14634 static PyObject *_wrap_DC_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
14635 PyObject *resultobj;
14636 wxDC *arg1 = (wxDC *) 0 ;
14637 wxFont *arg2 = 0 ;
14638 PyObject * obj0 = 0 ;
14639 PyObject * obj1 = 0 ;
14640 char *kwnames[] = {
14641 (char *) "self",(char *) "font", NULL
14642 };
14643
14644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetFont",kwnames,&obj0,&obj1)) goto fail;
14645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14646 if (SWIG_arg_fail(1)) SWIG_fail;
14647 {
14648 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
14649 if (SWIG_arg_fail(2)) SWIG_fail;
14650 if (arg2 == NULL) {
14651 SWIG_null_ref("wxFont");
14652 }
14653 if (SWIG_arg_fail(2)) SWIG_fail;
14654 }
14655 {
14656 PyThreadState* __tstate = wxPyBeginAllowThreads();
14657 (arg1)->SetFont((wxFont const &)*arg2);
14658
14659 wxPyEndAllowThreads(__tstate);
14660 if (PyErr_Occurred()) SWIG_fail;
14661 }
14662 Py_INCREF(Py_None); resultobj = Py_None;
14663 return resultobj;
14664 fail:
14665 return NULL;
14666 }
14667
14668
14669 static PyObject *_wrap_DC_SetPen(PyObject *, PyObject *args, PyObject *kwargs) {
14670 PyObject *resultobj;
14671 wxDC *arg1 = (wxDC *) 0 ;
14672 wxPen *arg2 = 0 ;
14673 PyObject * obj0 = 0 ;
14674 PyObject * obj1 = 0 ;
14675 char *kwnames[] = {
14676 (char *) "self",(char *) "pen", NULL
14677 };
14678
14679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPen",kwnames,&obj0,&obj1)) goto fail;
14680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14681 if (SWIG_arg_fail(1)) SWIG_fail;
14682 {
14683 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
14684 if (SWIG_arg_fail(2)) SWIG_fail;
14685 if (arg2 == NULL) {
14686 SWIG_null_ref("wxPen");
14687 }
14688 if (SWIG_arg_fail(2)) SWIG_fail;
14689 }
14690 {
14691 PyThreadState* __tstate = wxPyBeginAllowThreads();
14692 (arg1)->SetPen((wxPen const &)*arg2);
14693
14694 wxPyEndAllowThreads(__tstate);
14695 if (PyErr_Occurred()) SWIG_fail;
14696 }
14697 Py_INCREF(Py_None); resultobj = Py_None;
14698 return resultobj;
14699 fail:
14700 return NULL;
14701 }
14702
14703
14704 static PyObject *_wrap_DC_SetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
14705 PyObject *resultobj;
14706 wxDC *arg1 = (wxDC *) 0 ;
14707 wxBrush *arg2 = 0 ;
14708 PyObject * obj0 = 0 ;
14709 PyObject * obj1 = 0 ;
14710 char *kwnames[] = {
14711 (char *) "self",(char *) "brush", NULL
14712 };
14713
14714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBrush",kwnames,&obj0,&obj1)) goto fail;
14715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14716 if (SWIG_arg_fail(1)) SWIG_fail;
14717 {
14718 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
14719 if (SWIG_arg_fail(2)) SWIG_fail;
14720 if (arg2 == NULL) {
14721 SWIG_null_ref("wxBrush");
14722 }
14723 if (SWIG_arg_fail(2)) SWIG_fail;
14724 }
14725 {
14726 PyThreadState* __tstate = wxPyBeginAllowThreads();
14727 (arg1)->SetBrush((wxBrush const &)*arg2);
14728
14729 wxPyEndAllowThreads(__tstate);
14730 if (PyErr_Occurred()) SWIG_fail;
14731 }
14732 Py_INCREF(Py_None); resultobj = Py_None;
14733 return resultobj;
14734 fail:
14735 return NULL;
14736 }
14737
14738
14739 static PyObject *_wrap_DC_SetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
14740 PyObject *resultobj;
14741 wxDC *arg1 = (wxDC *) 0 ;
14742 wxBrush *arg2 = 0 ;
14743 PyObject * obj0 = 0 ;
14744 PyObject * obj1 = 0 ;
14745 char *kwnames[] = {
14746 (char *) "self",(char *) "brush", NULL
14747 };
14748
14749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackground",kwnames,&obj0,&obj1)) goto fail;
14750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14751 if (SWIG_arg_fail(1)) SWIG_fail;
14752 {
14753 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
14754 if (SWIG_arg_fail(2)) SWIG_fail;
14755 if (arg2 == NULL) {
14756 SWIG_null_ref("wxBrush");
14757 }
14758 if (SWIG_arg_fail(2)) SWIG_fail;
14759 }
14760 {
14761 PyThreadState* __tstate = wxPyBeginAllowThreads();
14762 (arg1)->SetBackground((wxBrush const &)*arg2);
14763
14764 wxPyEndAllowThreads(__tstate);
14765 if (PyErr_Occurred()) SWIG_fail;
14766 }
14767 Py_INCREF(Py_None); resultobj = Py_None;
14768 return resultobj;
14769 fail:
14770 return NULL;
14771 }
14772
14773
14774 static PyObject *_wrap_DC_SetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
14775 PyObject *resultobj;
14776 wxDC *arg1 = (wxDC *) 0 ;
14777 int arg2 ;
14778 PyObject * obj0 = 0 ;
14779 PyObject * obj1 = 0 ;
14780 char *kwnames[] = {
14781 (char *) "self",(char *) "mode", NULL
14782 };
14783
14784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackgroundMode",kwnames,&obj0,&obj1)) goto fail;
14785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14786 if (SWIG_arg_fail(1)) SWIG_fail;
14787 {
14788 arg2 = (int)(SWIG_As_int(obj1));
14789 if (SWIG_arg_fail(2)) SWIG_fail;
14790 }
14791 {
14792 PyThreadState* __tstate = wxPyBeginAllowThreads();
14793 (arg1)->SetBackgroundMode(arg2);
14794
14795 wxPyEndAllowThreads(__tstate);
14796 if (PyErr_Occurred()) SWIG_fail;
14797 }
14798 Py_INCREF(Py_None); resultobj = Py_None;
14799 return resultobj;
14800 fail:
14801 return NULL;
14802 }
14803
14804
14805 static PyObject *_wrap_DC_SetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
14806 PyObject *resultobj;
14807 wxDC *arg1 = (wxDC *) 0 ;
14808 wxPalette *arg2 = 0 ;
14809 PyObject * obj0 = 0 ;
14810 PyObject * obj1 = 0 ;
14811 char *kwnames[] = {
14812 (char *) "self",(char *) "palette", NULL
14813 };
14814
14815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPalette",kwnames,&obj0,&obj1)) goto fail;
14816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14817 if (SWIG_arg_fail(1)) SWIG_fail;
14818 {
14819 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
14820 if (SWIG_arg_fail(2)) SWIG_fail;
14821 if (arg2 == NULL) {
14822 SWIG_null_ref("wxPalette");
14823 }
14824 if (SWIG_arg_fail(2)) SWIG_fail;
14825 }
14826 {
14827 PyThreadState* __tstate = wxPyBeginAllowThreads();
14828 (arg1)->SetPalette((wxPalette const &)*arg2);
14829
14830 wxPyEndAllowThreads(__tstate);
14831 if (PyErr_Occurred()) SWIG_fail;
14832 }
14833 Py_INCREF(Py_None); resultobj = Py_None;
14834 return resultobj;
14835 fail:
14836 return NULL;
14837 }
14838
14839
14840 static PyObject *_wrap_DC_DestroyClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14841 PyObject *resultobj;
14842 wxDC *arg1 = (wxDC *) 0 ;
14843 PyObject * obj0 = 0 ;
14844 char *kwnames[] = {
14845 (char *) "self", NULL
14846 };
14847
14848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_DestroyClippingRegion",kwnames,&obj0)) goto fail;
14849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14850 if (SWIG_arg_fail(1)) SWIG_fail;
14851 {
14852 PyThreadState* __tstate = wxPyBeginAllowThreads();
14853 (arg1)->DestroyClippingRegion();
14854
14855 wxPyEndAllowThreads(__tstate);
14856 if (PyErr_Occurred()) SWIG_fail;
14857 }
14858 Py_INCREF(Py_None); resultobj = Py_None;
14859 return resultobj;
14860 fail:
14861 return NULL;
14862 }
14863
14864
14865 static PyObject *_wrap_DC_GetClippingBox(PyObject *, PyObject *args, PyObject *kwargs) {
14866 PyObject *resultobj;
14867 wxDC *arg1 = (wxDC *) 0 ;
14868 int *arg2 = (int *) 0 ;
14869 int *arg3 = (int *) 0 ;
14870 int *arg4 = (int *) 0 ;
14871 int *arg5 = (int *) 0 ;
14872 int temp2 ;
14873 int res2 = 0 ;
14874 int temp3 ;
14875 int res3 = 0 ;
14876 int temp4 ;
14877 int res4 = 0 ;
14878 int temp5 ;
14879 int res5 = 0 ;
14880 PyObject * obj0 = 0 ;
14881 char *kwnames[] = {
14882 (char *) "self", NULL
14883 };
14884
14885 arg2 = &temp2; res2 = SWIG_NEWOBJ;
14886 arg3 = &temp3; res3 = SWIG_NEWOBJ;
14887 arg4 = &temp4; res4 = SWIG_NEWOBJ;
14888 arg5 = &temp5; res5 = SWIG_NEWOBJ;
14889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingBox",kwnames,&obj0)) goto fail;
14890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14891 if (SWIG_arg_fail(1)) SWIG_fail;
14892 {
14893 PyThreadState* __tstate = wxPyBeginAllowThreads();
14894 ((wxDC const *)arg1)->GetClippingBox(arg2,arg3,arg4,arg5);
14895
14896 wxPyEndAllowThreads(__tstate);
14897 if (PyErr_Occurred()) SWIG_fail;
14898 }
14899 Py_INCREF(Py_None); resultobj = Py_None;
14900 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
14901 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
14902 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
14903 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
14904 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
14905 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
14906 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
14907 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
14908 return resultobj;
14909 fail:
14910 return NULL;
14911 }
14912
14913
14914 static PyObject *_wrap_DC_GetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
14915 PyObject *resultobj;
14916 wxDC *arg1 = (wxDC *) 0 ;
14917 wxRect result;
14918 PyObject * obj0 = 0 ;
14919 char *kwnames[] = {
14920 (char *) "self", NULL
14921 };
14922
14923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingRect",kwnames,&obj0)) goto fail;
14924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14925 if (SWIG_arg_fail(1)) SWIG_fail;
14926 {
14927 PyThreadState* __tstate = wxPyBeginAllowThreads();
14928 result = wxDC_GetClippingRect(arg1);
14929
14930 wxPyEndAllowThreads(__tstate);
14931 if (PyErr_Occurred()) SWIG_fail;
14932 }
14933 {
14934 wxRect * resultptr;
14935 resultptr = new wxRect((wxRect &)(result));
14936 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
14937 }
14938 return resultobj;
14939 fail:
14940 return NULL;
14941 }
14942
14943
14944 static PyObject *_wrap_DC_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
14945 PyObject *resultobj;
14946 wxDC *arg1 = (wxDC *) 0 ;
14947 int result;
14948 PyObject * obj0 = 0 ;
14949 char *kwnames[] = {
14950 (char *) "self", NULL
14951 };
14952
14953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharHeight",kwnames,&obj0)) goto fail;
14954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14955 if (SWIG_arg_fail(1)) SWIG_fail;
14956 {
14957 PyThreadState* __tstate = wxPyBeginAllowThreads();
14958 result = (int)((wxDC const *)arg1)->GetCharHeight();
14959
14960 wxPyEndAllowThreads(__tstate);
14961 if (PyErr_Occurred()) SWIG_fail;
14962 }
14963 {
14964 resultobj = SWIG_From_int((int)(result));
14965 }
14966 return resultobj;
14967 fail:
14968 return NULL;
14969 }
14970
14971
14972 static PyObject *_wrap_DC_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
14973 PyObject *resultobj;
14974 wxDC *arg1 = (wxDC *) 0 ;
14975 int result;
14976 PyObject * obj0 = 0 ;
14977 char *kwnames[] = {
14978 (char *) "self", NULL
14979 };
14980
14981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharWidth",kwnames,&obj0)) goto fail;
14982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14983 if (SWIG_arg_fail(1)) SWIG_fail;
14984 {
14985 PyThreadState* __tstate = wxPyBeginAllowThreads();
14986 result = (int)((wxDC const *)arg1)->GetCharWidth();
14987
14988 wxPyEndAllowThreads(__tstate);
14989 if (PyErr_Occurred()) SWIG_fail;
14990 }
14991 {
14992 resultobj = SWIG_From_int((int)(result));
14993 }
14994 return resultobj;
14995 fail:
14996 return NULL;
14997 }
14998
14999
15000 static PyObject *_wrap_DC_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15001 PyObject *resultobj;
15002 wxDC *arg1 = (wxDC *) 0 ;
15003 wxString *arg2 = 0 ;
15004 int *arg3 = (int *) 0 ;
15005 int *arg4 = (int *) 0 ;
15006 bool temp2 = false ;
15007 int temp3 ;
15008 int res3 = 0 ;
15009 int temp4 ;
15010 int res4 = 0 ;
15011 PyObject * obj0 = 0 ;
15012 PyObject * obj1 = 0 ;
15013 char *kwnames[] = {
15014 (char *) "self",(char *) "string", NULL
15015 };
15016
15017 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15018 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
15020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15021 if (SWIG_arg_fail(1)) SWIG_fail;
15022 {
15023 arg2 = wxString_in_helper(obj1);
15024 if (arg2 == NULL) SWIG_fail;
15025 temp2 = true;
15026 }
15027 {
15028 PyThreadState* __tstate = wxPyBeginAllowThreads();
15029 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
15030
15031 wxPyEndAllowThreads(__tstate);
15032 if (PyErr_Occurred()) SWIG_fail;
15033 }
15034 Py_INCREF(Py_None); resultobj = Py_None;
15035 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15036 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15037 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15038 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15039 {
15040 if (temp2)
15041 delete arg2;
15042 }
15043 return resultobj;
15044 fail:
15045 {
15046 if (temp2)
15047 delete arg2;
15048 }
15049 return NULL;
15050 }
15051
15052
15053 static PyObject *_wrap_DC_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15054 PyObject *resultobj;
15055 wxDC *arg1 = (wxDC *) 0 ;
15056 wxString *arg2 = 0 ;
15057 int *arg3 = (int *) 0 ;
15058 int *arg4 = (int *) 0 ;
15059 int *arg5 = (int *) 0 ;
15060 int *arg6 = (int *) 0 ;
15061 wxFont *arg7 = (wxFont *) NULL ;
15062 bool temp2 = false ;
15063 int temp3 ;
15064 int res3 = 0 ;
15065 int temp4 ;
15066 int res4 = 0 ;
15067 int temp5 ;
15068 int res5 = 0 ;
15069 int temp6 ;
15070 int res6 = 0 ;
15071 PyObject * obj0 = 0 ;
15072 PyObject * obj1 = 0 ;
15073 PyObject * obj2 = 0 ;
15074 char *kwnames[] = {
15075 (char *) "self",(char *) "string",(char *) "font", NULL
15076 };
15077
15078 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15079 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15080 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15081 arg6 = &temp6; res6 = SWIG_NEWOBJ;
15082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15084 if (SWIG_arg_fail(1)) SWIG_fail;
15085 {
15086 arg2 = wxString_in_helper(obj1);
15087 if (arg2 == NULL) SWIG_fail;
15088 temp2 = true;
15089 }
15090 if (obj2) {
15091 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15092 if (SWIG_arg_fail(7)) SWIG_fail;
15093 }
15094 {
15095 PyThreadState* __tstate = wxPyBeginAllowThreads();
15096 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7);
15097
15098 wxPyEndAllowThreads(__tstate);
15099 if (PyErr_Occurred()) SWIG_fail;
15100 }
15101 Py_INCREF(Py_None); resultobj = Py_None;
15102 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15103 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15104 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15105 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15106 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15107 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15108 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
15109 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
15110 {
15111 if (temp2)
15112 delete arg2;
15113 }
15114 return resultobj;
15115 fail:
15116 {
15117 if (temp2)
15118 delete arg2;
15119 }
15120 return NULL;
15121 }
15122
15123
15124 static PyObject *_wrap_DC_GetMultiLineTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15125 PyObject *resultobj;
15126 wxDC *arg1 = (wxDC *) 0 ;
15127 wxString *arg2 = 0 ;
15128 int *arg3 = (int *) 0 ;
15129 int *arg4 = (int *) 0 ;
15130 int *arg5 = (int *) 0 ;
15131 wxFont *arg6 = (wxFont *) NULL ;
15132 bool temp2 = false ;
15133 int temp3 ;
15134 int res3 = 0 ;
15135 int temp4 ;
15136 int res4 = 0 ;
15137 int temp5 ;
15138 int res5 = 0 ;
15139 PyObject * obj0 = 0 ;
15140 PyObject * obj1 = 0 ;
15141 PyObject * obj2 = 0 ;
15142 char *kwnames[] = {
15143 (char *) "self",(char *) "text",(char *) "font", NULL
15144 };
15145
15146 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15147 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15148 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetMultiLineTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15151 if (SWIG_arg_fail(1)) SWIG_fail;
15152 {
15153 arg2 = wxString_in_helper(obj1);
15154 if (arg2 == NULL) SWIG_fail;
15155 temp2 = true;
15156 }
15157 if (obj2) {
15158 SWIG_Python_ConvertPtr(obj2, (void **)&arg6, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15159 if (SWIG_arg_fail(6)) SWIG_fail;
15160 }
15161 {
15162 PyThreadState* __tstate = wxPyBeginAllowThreads();
15163 (arg1)->GetMultiLineTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6);
15164
15165 wxPyEndAllowThreads(__tstate);
15166 if (PyErr_Occurred()) SWIG_fail;
15167 }
15168 Py_INCREF(Py_None); resultobj = Py_None;
15169 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15170 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15171 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15172 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15173 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15174 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15175 {
15176 if (temp2)
15177 delete arg2;
15178 }
15179 return resultobj;
15180 fail:
15181 {
15182 if (temp2)
15183 delete arg2;
15184 }
15185 return NULL;
15186 }
15187
15188
15189 static PyObject *_wrap_DC_GetPartialTextExtents(PyObject *, PyObject *args, PyObject *kwargs) {
15190 PyObject *resultobj;
15191 wxDC *arg1 = (wxDC *) 0 ;
15192 wxString *arg2 = 0 ;
15193 wxArrayInt result;
15194 bool temp2 = false ;
15195 PyObject * obj0 = 0 ;
15196 PyObject * obj1 = 0 ;
15197 char *kwnames[] = {
15198 (char *) "self",(char *) "text", NULL
15199 };
15200
15201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPartialTextExtents",kwnames,&obj0,&obj1)) goto fail;
15202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15203 if (SWIG_arg_fail(1)) SWIG_fail;
15204 {
15205 arg2 = wxString_in_helper(obj1);
15206 if (arg2 == NULL) SWIG_fail;
15207 temp2 = true;
15208 }
15209 {
15210 PyThreadState* __tstate = wxPyBeginAllowThreads();
15211 result = wxDC_GetPartialTextExtents(arg1,(wxString const &)*arg2);
15212
15213 wxPyEndAllowThreads(__tstate);
15214 if (PyErr_Occurred()) SWIG_fail;
15215 }
15216 {
15217 resultobj = PyList_New(0);
15218 size_t idx;
15219 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
15220 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
15221 PyList_Append(resultobj, val);
15222 Py_DECREF(val);
15223 }
15224 }
15225 {
15226 if (temp2)
15227 delete arg2;
15228 }
15229 return resultobj;
15230 fail:
15231 {
15232 if (temp2)
15233 delete arg2;
15234 }
15235 return NULL;
15236 }
15237
15238
15239 static PyObject *_wrap_DC_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
15240 PyObject *resultobj;
15241 wxDC *arg1 = (wxDC *) 0 ;
15242 wxSize result;
15243 PyObject * obj0 = 0 ;
15244 char *kwnames[] = {
15245 (char *) "self", NULL
15246 };
15247
15248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSize",kwnames,&obj0)) goto fail;
15249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15250 if (SWIG_arg_fail(1)) SWIG_fail;
15251 {
15252 PyThreadState* __tstate = wxPyBeginAllowThreads();
15253 result = (arg1)->GetSize();
15254
15255 wxPyEndAllowThreads(__tstate);
15256 if (PyErr_Occurred()) SWIG_fail;
15257 }
15258 {
15259 wxSize * resultptr;
15260 resultptr = new wxSize((wxSize &)(result));
15261 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15262 }
15263 return resultobj;
15264 fail:
15265 return NULL;
15266 }
15267
15268
15269 static PyObject *_wrap_DC_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
15270 PyObject *resultobj;
15271 wxDC *arg1 = (wxDC *) 0 ;
15272 int *arg2 = (int *) 0 ;
15273 int *arg3 = (int *) 0 ;
15274 int temp2 ;
15275 int res2 = 0 ;
15276 int temp3 ;
15277 int res3 = 0 ;
15278 PyObject * obj0 = 0 ;
15279 char *kwnames[] = {
15280 (char *) "self", NULL
15281 };
15282
15283 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15284 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeTuple",kwnames,&obj0)) goto fail;
15286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15287 if (SWIG_arg_fail(1)) SWIG_fail;
15288 {
15289 PyThreadState* __tstate = wxPyBeginAllowThreads();
15290 (arg1)->GetSize(arg2,arg3);
15291
15292 wxPyEndAllowThreads(__tstate);
15293 if (PyErr_Occurred()) SWIG_fail;
15294 }
15295 Py_INCREF(Py_None); resultobj = Py_None;
15296 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15297 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15298 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15299 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15300 return resultobj;
15301 fail:
15302 return NULL;
15303 }
15304
15305
15306 static PyObject *_wrap_DC_GetSizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
15307 PyObject *resultobj;
15308 wxDC *arg1 = (wxDC *) 0 ;
15309 wxSize result;
15310 PyObject * obj0 = 0 ;
15311 char *kwnames[] = {
15312 (char *) "self", NULL
15313 };
15314
15315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMM",kwnames,&obj0)) goto fail;
15316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15317 if (SWIG_arg_fail(1)) SWIG_fail;
15318 {
15319 PyThreadState* __tstate = wxPyBeginAllowThreads();
15320 result = ((wxDC const *)arg1)->GetSizeMM();
15321
15322 wxPyEndAllowThreads(__tstate);
15323 if (PyErr_Occurred()) SWIG_fail;
15324 }
15325 {
15326 wxSize * resultptr;
15327 resultptr = new wxSize((wxSize &)(result));
15328 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15329 }
15330 return resultobj;
15331 fail:
15332 return NULL;
15333 }
15334
15335
15336 static PyObject *_wrap_DC_GetSizeMMTuple(PyObject *, PyObject *args, PyObject *kwargs) {
15337 PyObject *resultobj;
15338 wxDC *arg1 = (wxDC *) 0 ;
15339 int *arg2 = (int *) 0 ;
15340 int *arg3 = (int *) 0 ;
15341 int temp2 ;
15342 int res2 = 0 ;
15343 int temp3 ;
15344 int res3 = 0 ;
15345 PyObject * obj0 = 0 ;
15346 char *kwnames[] = {
15347 (char *) "self", NULL
15348 };
15349
15350 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15351 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMMTuple",kwnames,&obj0)) goto fail;
15353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15354 if (SWIG_arg_fail(1)) SWIG_fail;
15355 {
15356 PyThreadState* __tstate = wxPyBeginAllowThreads();
15357 ((wxDC const *)arg1)->GetSizeMM(arg2,arg3);
15358
15359 wxPyEndAllowThreads(__tstate);
15360 if (PyErr_Occurred()) SWIG_fail;
15361 }
15362 Py_INCREF(Py_None); resultobj = Py_None;
15363 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15364 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15365 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15366 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15367 return resultobj;
15368 fail:
15369 return NULL;
15370 }
15371
15372
15373 static PyObject *_wrap_DC_DeviceToLogicalX(PyObject *, PyObject *args, PyObject *kwargs) {
15374 PyObject *resultobj;
15375 wxDC *arg1 = (wxDC *) 0 ;
15376 int arg2 ;
15377 int result;
15378 PyObject * obj0 = 0 ;
15379 PyObject * obj1 = 0 ;
15380 char *kwnames[] = {
15381 (char *) "self",(char *) "x", NULL
15382 };
15383
15384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalX",kwnames,&obj0,&obj1)) goto fail;
15385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15386 if (SWIG_arg_fail(1)) SWIG_fail;
15387 {
15388 arg2 = (int)(SWIG_As_int(obj1));
15389 if (SWIG_arg_fail(2)) SWIG_fail;
15390 }
15391 {
15392 PyThreadState* __tstate = wxPyBeginAllowThreads();
15393 result = (int)((wxDC const *)arg1)->DeviceToLogicalX(arg2);
15394
15395 wxPyEndAllowThreads(__tstate);
15396 if (PyErr_Occurred()) SWIG_fail;
15397 }
15398 {
15399 resultobj = SWIG_From_int((int)(result));
15400 }
15401 return resultobj;
15402 fail:
15403 return NULL;
15404 }
15405
15406
15407 static PyObject *_wrap_DC_DeviceToLogicalY(PyObject *, PyObject *args, PyObject *kwargs) {
15408 PyObject *resultobj;
15409 wxDC *arg1 = (wxDC *) 0 ;
15410 int arg2 ;
15411 int result;
15412 PyObject * obj0 = 0 ;
15413 PyObject * obj1 = 0 ;
15414 char *kwnames[] = {
15415 (char *) "self",(char *) "y", NULL
15416 };
15417
15418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalY",kwnames,&obj0,&obj1)) goto fail;
15419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15420 if (SWIG_arg_fail(1)) SWIG_fail;
15421 {
15422 arg2 = (int)(SWIG_As_int(obj1));
15423 if (SWIG_arg_fail(2)) SWIG_fail;
15424 }
15425 {
15426 PyThreadState* __tstate = wxPyBeginAllowThreads();
15427 result = (int)((wxDC const *)arg1)->DeviceToLogicalY(arg2);
15428
15429 wxPyEndAllowThreads(__tstate);
15430 if (PyErr_Occurred()) SWIG_fail;
15431 }
15432 {
15433 resultobj = SWIG_From_int((int)(result));
15434 }
15435 return resultobj;
15436 fail:
15437 return NULL;
15438 }
15439
15440
15441 static PyObject *_wrap_DC_DeviceToLogicalXRel(PyObject *, PyObject *args, PyObject *kwargs) {
15442 PyObject *resultobj;
15443 wxDC *arg1 = (wxDC *) 0 ;
15444 int arg2 ;
15445 int result;
15446 PyObject * obj0 = 0 ;
15447 PyObject * obj1 = 0 ;
15448 char *kwnames[] = {
15449 (char *) "self",(char *) "x", NULL
15450 };
15451
15452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalXRel",kwnames,&obj0,&obj1)) goto fail;
15453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15454 if (SWIG_arg_fail(1)) SWIG_fail;
15455 {
15456 arg2 = (int)(SWIG_As_int(obj1));
15457 if (SWIG_arg_fail(2)) SWIG_fail;
15458 }
15459 {
15460 PyThreadState* __tstate = wxPyBeginAllowThreads();
15461 result = (int)((wxDC const *)arg1)->DeviceToLogicalXRel(arg2);
15462
15463 wxPyEndAllowThreads(__tstate);
15464 if (PyErr_Occurred()) SWIG_fail;
15465 }
15466 {
15467 resultobj = SWIG_From_int((int)(result));
15468 }
15469 return resultobj;
15470 fail:
15471 return NULL;
15472 }
15473
15474
15475 static PyObject *_wrap_DC_DeviceToLogicalYRel(PyObject *, PyObject *args, PyObject *kwargs) {
15476 PyObject *resultobj;
15477 wxDC *arg1 = (wxDC *) 0 ;
15478 int arg2 ;
15479 int result;
15480 PyObject * obj0 = 0 ;
15481 PyObject * obj1 = 0 ;
15482 char *kwnames[] = {
15483 (char *) "self",(char *) "y", NULL
15484 };
15485
15486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalYRel",kwnames,&obj0,&obj1)) goto fail;
15487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15488 if (SWIG_arg_fail(1)) SWIG_fail;
15489 {
15490 arg2 = (int)(SWIG_As_int(obj1));
15491 if (SWIG_arg_fail(2)) SWIG_fail;
15492 }
15493 {
15494 PyThreadState* __tstate = wxPyBeginAllowThreads();
15495 result = (int)((wxDC const *)arg1)->DeviceToLogicalYRel(arg2);
15496
15497 wxPyEndAllowThreads(__tstate);
15498 if (PyErr_Occurred()) SWIG_fail;
15499 }
15500 {
15501 resultobj = SWIG_From_int((int)(result));
15502 }
15503 return resultobj;
15504 fail:
15505 return NULL;
15506 }
15507
15508
15509 static PyObject *_wrap_DC_LogicalToDeviceX(PyObject *, PyObject *args, PyObject *kwargs) {
15510 PyObject *resultobj;
15511 wxDC *arg1 = (wxDC *) 0 ;
15512 int arg2 ;
15513 int result;
15514 PyObject * obj0 = 0 ;
15515 PyObject * obj1 = 0 ;
15516 char *kwnames[] = {
15517 (char *) "self",(char *) "x", NULL
15518 };
15519
15520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceX",kwnames,&obj0,&obj1)) goto fail;
15521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15522 if (SWIG_arg_fail(1)) SWIG_fail;
15523 {
15524 arg2 = (int)(SWIG_As_int(obj1));
15525 if (SWIG_arg_fail(2)) SWIG_fail;
15526 }
15527 {
15528 PyThreadState* __tstate = wxPyBeginAllowThreads();
15529 result = (int)((wxDC const *)arg1)->LogicalToDeviceX(arg2);
15530
15531 wxPyEndAllowThreads(__tstate);
15532 if (PyErr_Occurred()) SWIG_fail;
15533 }
15534 {
15535 resultobj = SWIG_From_int((int)(result));
15536 }
15537 return resultobj;
15538 fail:
15539 return NULL;
15540 }
15541
15542
15543 static PyObject *_wrap_DC_LogicalToDeviceY(PyObject *, PyObject *args, PyObject *kwargs) {
15544 PyObject *resultobj;
15545 wxDC *arg1 = (wxDC *) 0 ;
15546 int arg2 ;
15547 int result;
15548 PyObject * obj0 = 0 ;
15549 PyObject * obj1 = 0 ;
15550 char *kwnames[] = {
15551 (char *) "self",(char *) "y", NULL
15552 };
15553
15554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceY",kwnames,&obj0,&obj1)) goto fail;
15555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15556 if (SWIG_arg_fail(1)) SWIG_fail;
15557 {
15558 arg2 = (int)(SWIG_As_int(obj1));
15559 if (SWIG_arg_fail(2)) SWIG_fail;
15560 }
15561 {
15562 PyThreadState* __tstate = wxPyBeginAllowThreads();
15563 result = (int)((wxDC const *)arg1)->LogicalToDeviceY(arg2);
15564
15565 wxPyEndAllowThreads(__tstate);
15566 if (PyErr_Occurred()) SWIG_fail;
15567 }
15568 {
15569 resultobj = SWIG_From_int((int)(result));
15570 }
15571 return resultobj;
15572 fail:
15573 return NULL;
15574 }
15575
15576
15577 static PyObject *_wrap_DC_LogicalToDeviceXRel(PyObject *, PyObject *args, PyObject *kwargs) {
15578 PyObject *resultobj;
15579 wxDC *arg1 = (wxDC *) 0 ;
15580 int arg2 ;
15581 int result;
15582 PyObject * obj0 = 0 ;
15583 PyObject * obj1 = 0 ;
15584 char *kwnames[] = {
15585 (char *) "self",(char *) "x", NULL
15586 };
15587
15588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceXRel",kwnames,&obj0,&obj1)) goto fail;
15589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15590 if (SWIG_arg_fail(1)) SWIG_fail;
15591 {
15592 arg2 = (int)(SWIG_As_int(obj1));
15593 if (SWIG_arg_fail(2)) SWIG_fail;
15594 }
15595 {
15596 PyThreadState* __tstate = wxPyBeginAllowThreads();
15597 result = (int)((wxDC const *)arg1)->LogicalToDeviceXRel(arg2);
15598
15599 wxPyEndAllowThreads(__tstate);
15600 if (PyErr_Occurred()) SWIG_fail;
15601 }
15602 {
15603 resultobj = SWIG_From_int((int)(result));
15604 }
15605 return resultobj;
15606 fail:
15607 return NULL;
15608 }
15609
15610
15611 static PyObject *_wrap_DC_LogicalToDeviceYRel(PyObject *, PyObject *args, PyObject *kwargs) {
15612 PyObject *resultobj;
15613 wxDC *arg1 = (wxDC *) 0 ;
15614 int arg2 ;
15615 int result;
15616 PyObject * obj0 = 0 ;
15617 PyObject * obj1 = 0 ;
15618 char *kwnames[] = {
15619 (char *) "self",(char *) "y", NULL
15620 };
15621
15622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceYRel",kwnames,&obj0,&obj1)) goto fail;
15623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15624 if (SWIG_arg_fail(1)) SWIG_fail;
15625 {
15626 arg2 = (int)(SWIG_As_int(obj1));
15627 if (SWIG_arg_fail(2)) SWIG_fail;
15628 }
15629 {
15630 PyThreadState* __tstate = wxPyBeginAllowThreads();
15631 result = (int)((wxDC const *)arg1)->LogicalToDeviceYRel(arg2);
15632
15633 wxPyEndAllowThreads(__tstate);
15634 if (PyErr_Occurred()) SWIG_fail;
15635 }
15636 {
15637 resultobj = SWIG_From_int((int)(result));
15638 }
15639 return resultobj;
15640 fail:
15641 return NULL;
15642 }
15643
15644
15645 static PyObject *_wrap_DC_CanDrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
15646 PyObject *resultobj;
15647 wxDC *arg1 = (wxDC *) 0 ;
15648 bool result;
15649 PyObject * obj0 = 0 ;
15650 char *kwnames[] = {
15651 (char *) "self", NULL
15652 };
15653
15654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanDrawBitmap",kwnames,&obj0)) goto fail;
15655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15656 if (SWIG_arg_fail(1)) SWIG_fail;
15657 {
15658 PyThreadState* __tstate = wxPyBeginAllowThreads();
15659 result = (bool)((wxDC const *)arg1)->CanDrawBitmap();
15660
15661 wxPyEndAllowThreads(__tstate);
15662 if (PyErr_Occurred()) SWIG_fail;
15663 }
15664 {
15665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15666 }
15667 return resultobj;
15668 fail:
15669 return NULL;
15670 }
15671
15672
15673 static PyObject *_wrap_DC_CanGetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15674 PyObject *resultobj;
15675 wxDC *arg1 = (wxDC *) 0 ;
15676 bool result;
15677 PyObject * obj0 = 0 ;
15678 char *kwnames[] = {
15679 (char *) "self", NULL
15680 };
15681
15682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanGetTextExtent",kwnames,&obj0)) goto fail;
15683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15684 if (SWIG_arg_fail(1)) SWIG_fail;
15685 {
15686 PyThreadState* __tstate = wxPyBeginAllowThreads();
15687 result = (bool)((wxDC const *)arg1)->CanGetTextExtent();
15688
15689 wxPyEndAllowThreads(__tstate);
15690 if (PyErr_Occurred()) SWIG_fail;
15691 }
15692 {
15693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15694 }
15695 return resultobj;
15696 fail:
15697 return NULL;
15698 }
15699
15700
15701 static PyObject *_wrap_DC_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
15702 PyObject *resultobj;
15703 wxDC *arg1 = (wxDC *) 0 ;
15704 int result;
15705 PyObject * obj0 = 0 ;
15706 char *kwnames[] = {
15707 (char *) "self", NULL
15708 };
15709
15710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDepth",kwnames,&obj0)) goto fail;
15711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15712 if (SWIG_arg_fail(1)) SWIG_fail;
15713 {
15714 PyThreadState* __tstate = wxPyBeginAllowThreads();
15715 result = (int)((wxDC const *)arg1)->GetDepth();
15716
15717 wxPyEndAllowThreads(__tstate);
15718 if (PyErr_Occurred()) SWIG_fail;
15719 }
15720 {
15721 resultobj = SWIG_From_int((int)(result));
15722 }
15723 return resultobj;
15724 fail:
15725 return NULL;
15726 }
15727
15728
15729 static PyObject *_wrap_DC_GetPPI(PyObject *, PyObject *args, PyObject *kwargs) {
15730 PyObject *resultobj;
15731 wxDC *arg1 = (wxDC *) 0 ;
15732 wxSize result;
15733 PyObject * obj0 = 0 ;
15734 char *kwnames[] = {
15735 (char *) "self", NULL
15736 };
15737
15738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPPI",kwnames,&obj0)) goto fail;
15739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15740 if (SWIG_arg_fail(1)) SWIG_fail;
15741 {
15742 PyThreadState* __tstate = wxPyBeginAllowThreads();
15743 result = ((wxDC const *)arg1)->GetPPI();
15744
15745 wxPyEndAllowThreads(__tstate);
15746 if (PyErr_Occurred()) SWIG_fail;
15747 }
15748 {
15749 wxSize * resultptr;
15750 resultptr = new wxSize((wxSize &)(result));
15751 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15752 }
15753 return resultobj;
15754 fail:
15755 return NULL;
15756 }
15757
15758
15759 static PyObject *_wrap_DC_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
15760 PyObject *resultobj;
15761 wxDC *arg1 = (wxDC *) 0 ;
15762 bool result;
15763 PyObject * obj0 = 0 ;
15764 char *kwnames[] = {
15765 (char *) "self", NULL
15766 };
15767
15768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Ok",kwnames,&obj0)) goto fail;
15769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15770 if (SWIG_arg_fail(1)) SWIG_fail;
15771 {
15772 PyThreadState* __tstate = wxPyBeginAllowThreads();
15773 result = (bool)((wxDC const *)arg1)->Ok();
15774
15775 wxPyEndAllowThreads(__tstate);
15776 if (PyErr_Occurred()) SWIG_fail;
15777 }
15778 {
15779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15780 }
15781 return resultobj;
15782 fail:
15783 return NULL;
15784 }
15785
15786
15787 static PyObject *_wrap_DC_GetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
15788 PyObject *resultobj;
15789 wxDC *arg1 = (wxDC *) 0 ;
15790 int result;
15791 PyObject * obj0 = 0 ;
15792 char *kwnames[] = {
15793 (char *) "self", NULL
15794 };
15795
15796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackgroundMode",kwnames,&obj0)) goto fail;
15797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15798 if (SWIG_arg_fail(1)) SWIG_fail;
15799 {
15800 PyThreadState* __tstate = wxPyBeginAllowThreads();
15801 result = (int)((wxDC const *)arg1)->GetBackgroundMode();
15802
15803 wxPyEndAllowThreads(__tstate);
15804 if (PyErr_Occurred()) SWIG_fail;
15805 }
15806 {
15807 resultobj = SWIG_From_int((int)(result));
15808 }
15809 return resultobj;
15810 fail:
15811 return NULL;
15812 }
15813
15814
15815 static PyObject *_wrap_DC_GetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
15816 PyObject *resultobj;
15817 wxDC *arg1 = (wxDC *) 0 ;
15818 wxBrush *result;
15819 PyObject * obj0 = 0 ;
15820 char *kwnames[] = {
15821 (char *) "self", NULL
15822 };
15823
15824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackground",kwnames,&obj0)) goto fail;
15825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15826 if (SWIG_arg_fail(1)) SWIG_fail;
15827 {
15828 PyThreadState* __tstate = wxPyBeginAllowThreads();
15829 {
15830 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBackground();
15831 result = (wxBrush *) &_result_ref;
15832 }
15833
15834 wxPyEndAllowThreads(__tstate);
15835 if (PyErr_Occurred()) SWIG_fail;
15836 }
15837 {
15838 wxBrush* resultptr = new wxBrush(*result);
15839 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
15840 }
15841 return resultobj;
15842 fail:
15843 return NULL;
15844 }
15845
15846
15847 static PyObject *_wrap_DC_GetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
15848 PyObject *resultobj;
15849 wxDC *arg1 = (wxDC *) 0 ;
15850 wxBrush *result;
15851 PyObject * obj0 = 0 ;
15852 char *kwnames[] = {
15853 (char *) "self", NULL
15854 };
15855
15856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBrush",kwnames,&obj0)) goto fail;
15857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15858 if (SWIG_arg_fail(1)) SWIG_fail;
15859 {
15860 PyThreadState* __tstate = wxPyBeginAllowThreads();
15861 {
15862 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBrush();
15863 result = (wxBrush *) &_result_ref;
15864 }
15865
15866 wxPyEndAllowThreads(__tstate);
15867 if (PyErr_Occurred()) SWIG_fail;
15868 }
15869 {
15870 wxBrush* resultptr = new wxBrush(*result);
15871 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
15872 }
15873 return resultobj;
15874 fail:
15875 return NULL;
15876 }
15877
15878
15879 static PyObject *_wrap_DC_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
15880 PyObject *resultobj;
15881 wxDC *arg1 = (wxDC *) 0 ;
15882 wxFont *result;
15883 PyObject * obj0 = 0 ;
15884 char *kwnames[] = {
15885 (char *) "self", NULL
15886 };
15887
15888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetFont",kwnames,&obj0)) goto fail;
15889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15890 if (SWIG_arg_fail(1)) SWIG_fail;
15891 {
15892 PyThreadState* __tstate = wxPyBeginAllowThreads();
15893 {
15894 wxFont const &_result_ref = ((wxDC const *)arg1)->GetFont();
15895 result = (wxFont *) &_result_ref;
15896 }
15897
15898 wxPyEndAllowThreads(__tstate);
15899 if (PyErr_Occurred()) SWIG_fail;
15900 }
15901 {
15902 wxFont* resultptr = new wxFont(*result);
15903 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxFont, 1);
15904 }
15905 return resultobj;
15906 fail:
15907 return NULL;
15908 }
15909
15910
15911 static PyObject *_wrap_DC_GetPen(PyObject *, PyObject *args, PyObject *kwargs) {
15912 PyObject *resultobj;
15913 wxDC *arg1 = (wxDC *) 0 ;
15914 wxPen *result;
15915 PyObject * obj0 = 0 ;
15916 char *kwnames[] = {
15917 (char *) "self", NULL
15918 };
15919
15920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPen",kwnames,&obj0)) goto fail;
15921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15922 if (SWIG_arg_fail(1)) SWIG_fail;
15923 {
15924 PyThreadState* __tstate = wxPyBeginAllowThreads();
15925 {
15926 wxPen const &_result_ref = ((wxDC const *)arg1)->GetPen();
15927 result = (wxPen *) &_result_ref;
15928 }
15929
15930 wxPyEndAllowThreads(__tstate);
15931 if (PyErr_Occurred()) SWIG_fail;
15932 }
15933 {
15934 wxPen* resultptr = new wxPen(*result);
15935 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxPen, 1);
15936 }
15937 return resultobj;
15938 fail:
15939 return NULL;
15940 }
15941
15942
15943 static PyObject *_wrap_DC_GetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
15944 PyObject *resultobj;
15945 wxDC *arg1 = (wxDC *) 0 ;
15946 wxColour *result;
15947 PyObject * obj0 = 0 ;
15948 char *kwnames[] = {
15949 (char *) "self", NULL
15950 };
15951
15952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextBackground",kwnames,&obj0)) goto fail;
15953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15954 if (SWIG_arg_fail(1)) SWIG_fail;
15955 {
15956 PyThreadState* __tstate = wxPyBeginAllowThreads();
15957 {
15958 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextBackground();
15959 result = (wxColour *) &_result_ref;
15960 }
15961
15962 wxPyEndAllowThreads(__tstate);
15963 if (PyErr_Occurred()) SWIG_fail;
15964 }
15965 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
15966 return resultobj;
15967 fail:
15968 return NULL;
15969 }
15970
15971
15972 static PyObject *_wrap_DC_GetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
15973 PyObject *resultobj;
15974 wxDC *arg1 = (wxDC *) 0 ;
15975 wxColour *result;
15976 PyObject * obj0 = 0 ;
15977 char *kwnames[] = {
15978 (char *) "self", NULL
15979 };
15980
15981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextForeground",kwnames,&obj0)) goto fail;
15982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15983 if (SWIG_arg_fail(1)) SWIG_fail;
15984 {
15985 PyThreadState* __tstate = wxPyBeginAllowThreads();
15986 {
15987 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextForeground();
15988 result = (wxColour *) &_result_ref;
15989 }
15990
15991 wxPyEndAllowThreads(__tstate);
15992 if (PyErr_Occurred()) SWIG_fail;
15993 }
15994 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
15995 return resultobj;
15996 fail:
15997 return NULL;
15998 }
15999
16000
16001 static PyObject *_wrap_DC_SetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
16002 PyObject *resultobj;
16003 wxDC *arg1 = (wxDC *) 0 ;
16004 wxColour *arg2 = 0 ;
16005 wxColour temp2 ;
16006 PyObject * obj0 = 0 ;
16007 PyObject * obj1 = 0 ;
16008 char *kwnames[] = {
16009 (char *) "self",(char *) "colour", NULL
16010 };
16011
16012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextForeground",kwnames,&obj0,&obj1)) goto fail;
16013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16014 if (SWIG_arg_fail(1)) SWIG_fail;
16015 {
16016 arg2 = &temp2;
16017 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16018 }
16019 {
16020 PyThreadState* __tstate = wxPyBeginAllowThreads();
16021 (arg1)->SetTextForeground((wxColour const &)*arg2);
16022
16023 wxPyEndAllowThreads(__tstate);
16024 if (PyErr_Occurred()) SWIG_fail;
16025 }
16026 Py_INCREF(Py_None); resultobj = Py_None;
16027 return resultobj;
16028 fail:
16029 return NULL;
16030 }
16031
16032
16033 static PyObject *_wrap_DC_SetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16034 PyObject *resultobj;
16035 wxDC *arg1 = (wxDC *) 0 ;
16036 wxColour *arg2 = 0 ;
16037 wxColour temp2 ;
16038 PyObject * obj0 = 0 ;
16039 PyObject * obj1 = 0 ;
16040 char *kwnames[] = {
16041 (char *) "self",(char *) "colour", NULL
16042 };
16043
16044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextBackground",kwnames,&obj0,&obj1)) goto fail;
16045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16046 if (SWIG_arg_fail(1)) SWIG_fail;
16047 {
16048 arg2 = &temp2;
16049 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16050 }
16051 {
16052 PyThreadState* __tstate = wxPyBeginAllowThreads();
16053 (arg1)->SetTextBackground((wxColour const &)*arg2);
16054
16055 wxPyEndAllowThreads(__tstate);
16056 if (PyErr_Occurred()) SWIG_fail;
16057 }
16058 Py_INCREF(Py_None); resultobj = Py_None;
16059 return resultobj;
16060 fail:
16061 return NULL;
16062 }
16063
16064
16065 static PyObject *_wrap_DC_GetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16066 PyObject *resultobj;
16067 wxDC *arg1 = (wxDC *) 0 ;
16068 int result;
16069 PyObject * obj0 = 0 ;
16070 char *kwnames[] = {
16071 (char *) "self", NULL
16072 };
16073
16074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetMapMode",kwnames,&obj0)) goto fail;
16075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16076 if (SWIG_arg_fail(1)) SWIG_fail;
16077 {
16078 PyThreadState* __tstate = wxPyBeginAllowThreads();
16079 result = (int)((wxDC const *)arg1)->GetMapMode();
16080
16081 wxPyEndAllowThreads(__tstate);
16082 if (PyErr_Occurred()) SWIG_fail;
16083 }
16084 {
16085 resultobj = SWIG_From_int((int)(result));
16086 }
16087 return resultobj;
16088 fail:
16089 return NULL;
16090 }
16091
16092
16093 static PyObject *_wrap_DC_SetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16094 PyObject *resultobj;
16095 wxDC *arg1 = (wxDC *) 0 ;
16096 int arg2 ;
16097 PyObject * obj0 = 0 ;
16098 PyObject * obj1 = 0 ;
16099 char *kwnames[] = {
16100 (char *) "self",(char *) "mode", NULL
16101 };
16102
16103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetMapMode",kwnames,&obj0,&obj1)) goto fail;
16104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16105 if (SWIG_arg_fail(1)) SWIG_fail;
16106 {
16107 arg2 = (int)(SWIG_As_int(obj1));
16108 if (SWIG_arg_fail(2)) SWIG_fail;
16109 }
16110 {
16111 PyThreadState* __tstate = wxPyBeginAllowThreads();
16112 (arg1)->SetMapMode(arg2);
16113
16114 wxPyEndAllowThreads(__tstate);
16115 if (PyErr_Occurred()) SWIG_fail;
16116 }
16117 Py_INCREF(Py_None); resultobj = Py_None;
16118 return resultobj;
16119 fail:
16120 return NULL;
16121 }
16122
16123
16124 static PyObject *_wrap_DC_GetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16125 PyObject *resultobj;
16126 wxDC *arg1 = (wxDC *) 0 ;
16127 double *arg2 = (double *) 0 ;
16128 double *arg3 = (double *) 0 ;
16129 double temp2 ;
16130 int res2 = 0 ;
16131 double temp3 ;
16132 int res3 = 0 ;
16133 PyObject * obj0 = 0 ;
16134 char *kwnames[] = {
16135 (char *) "self", NULL
16136 };
16137
16138 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16139 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetUserScale",kwnames,&obj0)) goto fail;
16141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16142 if (SWIG_arg_fail(1)) SWIG_fail;
16143 {
16144 PyThreadState* __tstate = wxPyBeginAllowThreads();
16145 ((wxDC const *)arg1)->GetUserScale(arg2,arg3);
16146
16147 wxPyEndAllowThreads(__tstate);
16148 if (PyErr_Occurred()) SWIG_fail;
16149 }
16150 Py_INCREF(Py_None); resultobj = Py_None;
16151 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16152 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16153 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16154 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16155 return resultobj;
16156 fail:
16157 return NULL;
16158 }
16159
16160
16161 static PyObject *_wrap_DC_SetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16162 PyObject *resultobj;
16163 wxDC *arg1 = (wxDC *) 0 ;
16164 double arg2 ;
16165 double arg3 ;
16166 PyObject * obj0 = 0 ;
16167 PyObject * obj1 = 0 ;
16168 PyObject * obj2 = 0 ;
16169 char *kwnames[] = {
16170 (char *) "self",(char *) "x",(char *) "y", NULL
16171 };
16172
16173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetUserScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16175 if (SWIG_arg_fail(1)) SWIG_fail;
16176 {
16177 arg2 = (double)(SWIG_As_double(obj1));
16178 if (SWIG_arg_fail(2)) SWIG_fail;
16179 }
16180 {
16181 arg3 = (double)(SWIG_As_double(obj2));
16182 if (SWIG_arg_fail(3)) SWIG_fail;
16183 }
16184 {
16185 PyThreadState* __tstate = wxPyBeginAllowThreads();
16186 (arg1)->SetUserScale(arg2,arg3);
16187
16188 wxPyEndAllowThreads(__tstate);
16189 if (PyErr_Occurred()) SWIG_fail;
16190 }
16191 Py_INCREF(Py_None); resultobj = Py_None;
16192 return resultobj;
16193 fail:
16194 return NULL;
16195 }
16196
16197
16198 static PyObject *_wrap_DC_GetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16199 PyObject *resultobj;
16200 wxDC *arg1 = (wxDC *) 0 ;
16201 double *arg2 = (double *) 0 ;
16202 double *arg3 = (double *) 0 ;
16203 double temp2 ;
16204 int res2 = 0 ;
16205 double temp3 ;
16206 int res3 = 0 ;
16207 PyObject * obj0 = 0 ;
16208 char *kwnames[] = {
16209 (char *) "self", NULL
16210 };
16211
16212 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16213 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalScale",kwnames,&obj0)) goto fail;
16215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16216 if (SWIG_arg_fail(1)) SWIG_fail;
16217 {
16218 PyThreadState* __tstate = wxPyBeginAllowThreads();
16219 (arg1)->GetLogicalScale(arg2,arg3);
16220
16221 wxPyEndAllowThreads(__tstate);
16222 if (PyErr_Occurred()) SWIG_fail;
16223 }
16224 Py_INCREF(Py_None); resultobj = Py_None;
16225 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16226 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16227 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16228 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16229 return resultobj;
16230 fail:
16231 return NULL;
16232 }
16233
16234
16235 static PyObject *_wrap_DC_SetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16236 PyObject *resultobj;
16237 wxDC *arg1 = (wxDC *) 0 ;
16238 double arg2 ;
16239 double arg3 ;
16240 PyObject * obj0 = 0 ;
16241 PyObject * obj1 = 0 ;
16242 PyObject * obj2 = 0 ;
16243 char *kwnames[] = {
16244 (char *) "self",(char *) "x",(char *) "y", NULL
16245 };
16246
16247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16249 if (SWIG_arg_fail(1)) SWIG_fail;
16250 {
16251 arg2 = (double)(SWIG_As_double(obj1));
16252 if (SWIG_arg_fail(2)) SWIG_fail;
16253 }
16254 {
16255 arg3 = (double)(SWIG_As_double(obj2));
16256 if (SWIG_arg_fail(3)) SWIG_fail;
16257 }
16258 {
16259 PyThreadState* __tstate = wxPyBeginAllowThreads();
16260 (arg1)->SetLogicalScale(arg2,arg3);
16261
16262 wxPyEndAllowThreads(__tstate);
16263 if (PyErr_Occurred()) SWIG_fail;
16264 }
16265 Py_INCREF(Py_None); resultobj = Py_None;
16266 return resultobj;
16267 fail:
16268 return NULL;
16269 }
16270
16271
16272 static PyObject *_wrap_DC_GetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16273 PyObject *resultobj;
16274 wxDC *arg1 = (wxDC *) 0 ;
16275 wxPoint result;
16276 PyObject * obj0 = 0 ;
16277 char *kwnames[] = {
16278 (char *) "self", NULL
16279 };
16280
16281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOrigin",kwnames,&obj0)) goto fail;
16282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16283 if (SWIG_arg_fail(1)) SWIG_fail;
16284 {
16285 PyThreadState* __tstate = wxPyBeginAllowThreads();
16286 result = ((wxDC const *)arg1)->GetLogicalOrigin();
16287
16288 wxPyEndAllowThreads(__tstate);
16289 if (PyErr_Occurred()) SWIG_fail;
16290 }
16291 {
16292 wxPoint * resultptr;
16293 resultptr = new wxPoint((wxPoint &)(result));
16294 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16295 }
16296 return resultobj;
16297 fail:
16298 return NULL;
16299 }
16300
16301
16302 static PyObject *_wrap_DC_GetLogicalOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16303 PyObject *resultobj;
16304 wxDC *arg1 = (wxDC *) 0 ;
16305 int *arg2 = (int *) 0 ;
16306 int *arg3 = (int *) 0 ;
16307 int temp2 ;
16308 int res2 = 0 ;
16309 int temp3 ;
16310 int res3 = 0 ;
16311 PyObject * obj0 = 0 ;
16312 char *kwnames[] = {
16313 (char *) "self", NULL
16314 };
16315
16316 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16317 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOriginTuple",kwnames,&obj0)) goto fail;
16319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16320 if (SWIG_arg_fail(1)) SWIG_fail;
16321 {
16322 PyThreadState* __tstate = wxPyBeginAllowThreads();
16323 ((wxDC const *)arg1)->GetLogicalOrigin(arg2,arg3);
16324
16325 wxPyEndAllowThreads(__tstate);
16326 if (PyErr_Occurred()) SWIG_fail;
16327 }
16328 Py_INCREF(Py_None); resultobj = Py_None;
16329 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16330 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16331 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16332 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16333 return resultobj;
16334 fail:
16335 return NULL;
16336 }
16337
16338
16339 static PyObject *_wrap_DC_SetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16340 PyObject *resultobj;
16341 wxDC *arg1 = (wxDC *) 0 ;
16342 int arg2 ;
16343 int arg3 ;
16344 PyObject * obj0 = 0 ;
16345 PyObject * obj1 = 0 ;
16346 PyObject * obj2 = 0 ;
16347 char *kwnames[] = {
16348 (char *) "self",(char *) "x",(char *) "y", NULL
16349 };
16350
16351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
16352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16353 if (SWIG_arg_fail(1)) SWIG_fail;
16354 {
16355 arg2 = (int)(SWIG_As_int(obj1));
16356 if (SWIG_arg_fail(2)) SWIG_fail;
16357 }
16358 {
16359 arg3 = (int)(SWIG_As_int(obj2));
16360 if (SWIG_arg_fail(3)) SWIG_fail;
16361 }
16362 {
16363 PyThreadState* __tstate = wxPyBeginAllowThreads();
16364 (arg1)->SetLogicalOrigin(arg2,arg3);
16365
16366 wxPyEndAllowThreads(__tstate);
16367 if (PyErr_Occurred()) SWIG_fail;
16368 }
16369 Py_INCREF(Py_None); resultobj = Py_None;
16370 return resultobj;
16371 fail:
16372 return NULL;
16373 }
16374
16375
16376 static PyObject *_wrap_DC_SetLogicalOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16377 PyObject *resultobj;
16378 wxDC *arg1 = (wxDC *) 0 ;
16379 wxPoint *arg2 = 0 ;
16380 wxPoint temp2 ;
16381 PyObject * obj0 = 0 ;
16382 PyObject * obj1 = 0 ;
16383 char *kwnames[] = {
16384 (char *) "self",(char *) "point", NULL
16385 };
16386
16387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalOriginPoint",kwnames,&obj0,&obj1)) goto fail;
16388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16389 if (SWIG_arg_fail(1)) SWIG_fail;
16390 {
16391 arg2 = &temp2;
16392 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16393 }
16394 {
16395 PyThreadState* __tstate = wxPyBeginAllowThreads();
16396 wxDC_SetLogicalOriginPoint(arg1,(wxPoint const &)*arg2);
16397
16398 wxPyEndAllowThreads(__tstate);
16399 if (PyErr_Occurred()) SWIG_fail;
16400 }
16401 Py_INCREF(Py_None); resultobj = Py_None;
16402 return resultobj;
16403 fail:
16404 return NULL;
16405 }
16406
16407
16408 static PyObject *_wrap_DC_GetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16409 PyObject *resultobj;
16410 wxDC *arg1 = (wxDC *) 0 ;
16411 wxPoint result;
16412 PyObject * obj0 = 0 ;
16413 char *kwnames[] = {
16414 (char *) "self", NULL
16415 };
16416
16417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOrigin",kwnames,&obj0)) goto fail;
16418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16419 if (SWIG_arg_fail(1)) SWIG_fail;
16420 {
16421 PyThreadState* __tstate = wxPyBeginAllowThreads();
16422 result = ((wxDC const *)arg1)->GetDeviceOrigin();
16423
16424 wxPyEndAllowThreads(__tstate);
16425 if (PyErr_Occurred()) SWIG_fail;
16426 }
16427 {
16428 wxPoint * resultptr;
16429 resultptr = new wxPoint((wxPoint &)(result));
16430 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16431 }
16432 return resultobj;
16433 fail:
16434 return NULL;
16435 }
16436
16437
16438 static PyObject *_wrap_DC_GetDeviceOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16439 PyObject *resultobj;
16440 wxDC *arg1 = (wxDC *) 0 ;
16441 int *arg2 = (int *) 0 ;
16442 int *arg3 = (int *) 0 ;
16443 int temp2 ;
16444 int res2 = 0 ;
16445 int temp3 ;
16446 int res3 = 0 ;
16447 PyObject * obj0 = 0 ;
16448 char *kwnames[] = {
16449 (char *) "self", NULL
16450 };
16451
16452 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16453 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOriginTuple",kwnames,&obj0)) goto fail;
16455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16456 if (SWIG_arg_fail(1)) SWIG_fail;
16457 {
16458 PyThreadState* __tstate = wxPyBeginAllowThreads();
16459 ((wxDC const *)arg1)->GetDeviceOrigin(arg2,arg3);
16460
16461 wxPyEndAllowThreads(__tstate);
16462 if (PyErr_Occurred()) SWIG_fail;
16463 }
16464 Py_INCREF(Py_None); resultobj = Py_None;
16465 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16466 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16467 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16468 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16469 return resultobj;
16470 fail:
16471 return NULL;
16472 }
16473
16474
16475 static PyObject *_wrap_DC_SetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16476 PyObject *resultobj;
16477 wxDC *arg1 = (wxDC *) 0 ;
16478 int arg2 ;
16479 int arg3 ;
16480 PyObject * obj0 = 0 ;
16481 PyObject * obj1 = 0 ;
16482 PyObject * obj2 = 0 ;
16483 char *kwnames[] = {
16484 (char *) "self",(char *) "x",(char *) "y", NULL
16485 };
16486
16487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetDeviceOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
16488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16489 if (SWIG_arg_fail(1)) SWIG_fail;
16490 {
16491 arg2 = (int)(SWIG_As_int(obj1));
16492 if (SWIG_arg_fail(2)) SWIG_fail;
16493 }
16494 {
16495 arg3 = (int)(SWIG_As_int(obj2));
16496 if (SWIG_arg_fail(3)) SWIG_fail;
16497 }
16498 {
16499 PyThreadState* __tstate = wxPyBeginAllowThreads();
16500 (arg1)->SetDeviceOrigin(arg2,arg3);
16501
16502 wxPyEndAllowThreads(__tstate);
16503 if (PyErr_Occurred()) SWIG_fail;
16504 }
16505 Py_INCREF(Py_None); resultobj = Py_None;
16506 return resultobj;
16507 fail:
16508 return NULL;
16509 }
16510
16511
16512 static PyObject *_wrap_DC_SetDeviceOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16513 PyObject *resultobj;
16514 wxDC *arg1 = (wxDC *) 0 ;
16515 wxPoint *arg2 = 0 ;
16516 wxPoint temp2 ;
16517 PyObject * obj0 = 0 ;
16518 PyObject * obj1 = 0 ;
16519 char *kwnames[] = {
16520 (char *) "self",(char *) "point", NULL
16521 };
16522
16523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetDeviceOriginPoint",kwnames,&obj0,&obj1)) goto fail;
16524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16525 if (SWIG_arg_fail(1)) SWIG_fail;
16526 {
16527 arg2 = &temp2;
16528 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16529 }
16530 {
16531 PyThreadState* __tstate = wxPyBeginAllowThreads();
16532 wxDC_SetDeviceOriginPoint(arg1,(wxPoint const &)*arg2);
16533
16534 wxPyEndAllowThreads(__tstate);
16535 if (PyErr_Occurred()) SWIG_fail;
16536 }
16537 Py_INCREF(Py_None); resultobj = Py_None;
16538 return resultobj;
16539 fail:
16540 return NULL;
16541 }
16542
16543
16544 static PyObject *_wrap_DC_SetAxisOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16545 PyObject *resultobj;
16546 wxDC *arg1 = (wxDC *) 0 ;
16547 bool arg2 ;
16548 bool arg3 ;
16549 PyObject * obj0 = 0 ;
16550 PyObject * obj1 = 0 ;
16551 PyObject * obj2 = 0 ;
16552 char *kwnames[] = {
16553 (char *) "self",(char *) "xLeftRight",(char *) "yBottomUp", NULL
16554 };
16555
16556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetAxisOrientation",kwnames,&obj0,&obj1,&obj2)) goto fail;
16557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16558 if (SWIG_arg_fail(1)) SWIG_fail;
16559 {
16560 arg2 = (bool)(SWIG_As_bool(obj1));
16561 if (SWIG_arg_fail(2)) SWIG_fail;
16562 }
16563 {
16564 arg3 = (bool)(SWIG_As_bool(obj2));
16565 if (SWIG_arg_fail(3)) SWIG_fail;
16566 }
16567 {
16568 PyThreadState* __tstate = wxPyBeginAllowThreads();
16569 (arg1)->SetAxisOrientation(arg2,arg3);
16570
16571 wxPyEndAllowThreads(__tstate);
16572 if (PyErr_Occurred()) SWIG_fail;
16573 }
16574 Py_INCREF(Py_None); resultobj = Py_None;
16575 return resultobj;
16576 fail:
16577 return NULL;
16578 }
16579
16580
16581 static PyObject *_wrap_DC_GetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
16582 PyObject *resultobj;
16583 wxDC *arg1 = (wxDC *) 0 ;
16584 int result;
16585 PyObject * obj0 = 0 ;
16586 char *kwnames[] = {
16587 (char *) "self", NULL
16588 };
16589
16590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalFunction",kwnames,&obj0)) goto fail;
16591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16592 if (SWIG_arg_fail(1)) SWIG_fail;
16593 {
16594 PyThreadState* __tstate = wxPyBeginAllowThreads();
16595 result = (int)((wxDC const *)arg1)->GetLogicalFunction();
16596
16597 wxPyEndAllowThreads(__tstate);
16598 if (PyErr_Occurred()) SWIG_fail;
16599 }
16600 {
16601 resultobj = SWIG_From_int((int)(result));
16602 }
16603 return resultobj;
16604 fail:
16605 return NULL;
16606 }
16607
16608
16609 static PyObject *_wrap_DC_SetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
16610 PyObject *resultobj;
16611 wxDC *arg1 = (wxDC *) 0 ;
16612 int arg2 ;
16613 PyObject * obj0 = 0 ;
16614 PyObject * obj1 = 0 ;
16615 char *kwnames[] = {
16616 (char *) "self",(char *) "function", NULL
16617 };
16618
16619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalFunction",kwnames,&obj0,&obj1)) goto fail;
16620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16621 if (SWIG_arg_fail(1)) SWIG_fail;
16622 {
16623 arg2 = (int)(SWIG_As_int(obj1));
16624 if (SWIG_arg_fail(2)) SWIG_fail;
16625 }
16626 {
16627 PyThreadState* __tstate = wxPyBeginAllowThreads();
16628 (arg1)->SetLogicalFunction(arg2);
16629
16630 wxPyEndAllowThreads(__tstate);
16631 if (PyErr_Occurred()) SWIG_fail;
16632 }
16633 Py_INCREF(Py_None); resultobj = Py_None;
16634 return resultobj;
16635 fail:
16636 return NULL;
16637 }
16638
16639
16640 static PyObject *_wrap_DC_ComputeScaleAndOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16641 PyObject *resultobj;
16642 wxDC *arg1 = (wxDC *) 0 ;
16643 PyObject * obj0 = 0 ;
16644 char *kwnames[] = {
16645 (char *) "self", NULL
16646 };
16647
16648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ComputeScaleAndOrigin",kwnames,&obj0)) goto fail;
16649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16650 if (SWIG_arg_fail(1)) SWIG_fail;
16651 {
16652 PyThreadState* __tstate = wxPyBeginAllowThreads();
16653 (arg1)->ComputeScaleAndOrigin();
16654
16655 wxPyEndAllowThreads(__tstate);
16656 if (PyErr_Occurred()) SWIG_fail;
16657 }
16658 Py_INCREF(Py_None); resultobj = Py_None;
16659 return resultobj;
16660 fail:
16661 return NULL;
16662 }
16663
16664
16665 static PyObject *_wrap_DC_CalcBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16666 PyObject *resultobj;
16667 wxDC *arg1 = (wxDC *) 0 ;
16668 int arg2 ;
16669 int arg3 ;
16670 PyObject * obj0 = 0 ;
16671 PyObject * obj1 = 0 ;
16672 PyObject * obj2 = 0 ;
16673 char *kwnames[] = {
16674 (char *) "self",(char *) "x",(char *) "y", NULL
16675 };
16676
16677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CalcBoundingBox",kwnames,&obj0,&obj1,&obj2)) goto fail;
16678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16679 if (SWIG_arg_fail(1)) SWIG_fail;
16680 {
16681 arg2 = (int)(SWIG_As_int(obj1));
16682 if (SWIG_arg_fail(2)) SWIG_fail;
16683 }
16684 {
16685 arg3 = (int)(SWIG_As_int(obj2));
16686 if (SWIG_arg_fail(3)) SWIG_fail;
16687 }
16688 {
16689 PyThreadState* __tstate = wxPyBeginAllowThreads();
16690 (arg1)->CalcBoundingBox(arg2,arg3);
16691
16692 wxPyEndAllowThreads(__tstate);
16693 if (PyErr_Occurred()) SWIG_fail;
16694 }
16695 Py_INCREF(Py_None); resultobj = Py_None;
16696 return resultobj;
16697 fail:
16698 return NULL;
16699 }
16700
16701
16702 static PyObject *_wrap_DC_CalcBoundingBoxPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16703 PyObject *resultobj;
16704 wxDC *arg1 = (wxDC *) 0 ;
16705 wxPoint *arg2 = 0 ;
16706 wxPoint temp2 ;
16707 PyObject * obj0 = 0 ;
16708 PyObject * obj1 = 0 ;
16709 char *kwnames[] = {
16710 (char *) "self",(char *) "point", NULL
16711 };
16712
16713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CalcBoundingBoxPoint",kwnames,&obj0,&obj1)) goto fail;
16714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16715 if (SWIG_arg_fail(1)) SWIG_fail;
16716 {
16717 arg2 = &temp2;
16718 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16719 }
16720 {
16721 PyThreadState* __tstate = wxPyBeginAllowThreads();
16722 wxDC_CalcBoundingBoxPoint(arg1,(wxPoint const &)*arg2);
16723
16724 wxPyEndAllowThreads(__tstate);
16725 if (PyErr_Occurred()) SWIG_fail;
16726 }
16727 Py_INCREF(Py_None); resultobj = Py_None;
16728 return resultobj;
16729 fail:
16730 return NULL;
16731 }
16732
16733
16734 static PyObject *_wrap_DC_ResetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16735 PyObject *resultobj;
16736 wxDC *arg1 = (wxDC *) 0 ;
16737 PyObject * obj0 = 0 ;
16738 char *kwnames[] = {
16739 (char *) "self", NULL
16740 };
16741
16742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ResetBoundingBox",kwnames,&obj0)) goto fail;
16743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16744 if (SWIG_arg_fail(1)) SWIG_fail;
16745 {
16746 PyThreadState* __tstate = wxPyBeginAllowThreads();
16747 (arg1)->ResetBoundingBox();
16748
16749 wxPyEndAllowThreads(__tstate);
16750 if (PyErr_Occurred()) SWIG_fail;
16751 }
16752 Py_INCREF(Py_None); resultobj = Py_None;
16753 return resultobj;
16754 fail:
16755 return NULL;
16756 }
16757
16758
16759 static PyObject *_wrap_DC_MinX(PyObject *, PyObject *args, PyObject *kwargs) {
16760 PyObject *resultobj;
16761 wxDC *arg1 = (wxDC *) 0 ;
16762 int result;
16763 PyObject * obj0 = 0 ;
16764 char *kwnames[] = {
16765 (char *) "self", NULL
16766 };
16767
16768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinX",kwnames,&obj0)) goto fail;
16769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16770 if (SWIG_arg_fail(1)) SWIG_fail;
16771 {
16772 PyThreadState* __tstate = wxPyBeginAllowThreads();
16773 result = (int)((wxDC const *)arg1)->MinX();
16774
16775 wxPyEndAllowThreads(__tstate);
16776 if (PyErr_Occurred()) SWIG_fail;
16777 }
16778 {
16779 resultobj = SWIG_From_int((int)(result));
16780 }
16781 return resultobj;
16782 fail:
16783 return NULL;
16784 }
16785
16786
16787 static PyObject *_wrap_DC_MaxX(PyObject *, PyObject *args, PyObject *kwargs) {
16788 PyObject *resultobj;
16789 wxDC *arg1 = (wxDC *) 0 ;
16790 int result;
16791 PyObject * obj0 = 0 ;
16792 char *kwnames[] = {
16793 (char *) "self", NULL
16794 };
16795
16796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxX",kwnames,&obj0)) goto fail;
16797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16798 if (SWIG_arg_fail(1)) SWIG_fail;
16799 {
16800 PyThreadState* __tstate = wxPyBeginAllowThreads();
16801 result = (int)((wxDC const *)arg1)->MaxX();
16802
16803 wxPyEndAllowThreads(__tstate);
16804 if (PyErr_Occurred()) SWIG_fail;
16805 }
16806 {
16807 resultobj = SWIG_From_int((int)(result));
16808 }
16809 return resultobj;
16810 fail:
16811 return NULL;
16812 }
16813
16814
16815 static PyObject *_wrap_DC_MinY(PyObject *, PyObject *args, PyObject *kwargs) {
16816 PyObject *resultobj;
16817 wxDC *arg1 = (wxDC *) 0 ;
16818 int result;
16819 PyObject * obj0 = 0 ;
16820 char *kwnames[] = {
16821 (char *) "self", NULL
16822 };
16823
16824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinY",kwnames,&obj0)) goto fail;
16825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16826 if (SWIG_arg_fail(1)) SWIG_fail;
16827 {
16828 PyThreadState* __tstate = wxPyBeginAllowThreads();
16829 result = (int)((wxDC const *)arg1)->MinY();
16830
16831 wxPyEndAllowThreads(__tstate);
16832 if (PyErr_Occurred()) SWIG_fail;
16833 }
16834 {
16835 resultobj = SWIG_From_int((int)(result));
16836 }
16837 return resultobj;
16838 fail:
16839 return NULL;
16840 }
16841
16842
16843 static PyObject *_wrap_DC_MaxY(PyObject *, PyObject *args, PyObject *kwargs) {
16844 PyObject *resultobj;
16845 wxDC *arg1 = (wxDC *) 0 ;
16846 int result;
16847 PyObject * obj0 = 0 ;
16848 char *kwnames[] = {
16849 (char *) "self", NULL
16850 };
16851
16852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxY",kwnames,&obj0)) goto fail;
16853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16854 if (SWIG_arg_fail(1)) SWIG_fail;
16855 {
16856 PyThreadState* __tstate = wxPyBeginAllowThreads();
16857 result = (int)((wxDC const *)arg1)->MaxY();
16858
16859 wxPyEndAllowThreads(__tstate);
16860 if (PyErr_Occurred()) SWIG_fail;
16861 }
16862 {
16863 resultobj = SWIG_From_int((int)(result));
16864 }
16865 return resultobj;
16866 fail:
16867 return NULL;
16868 }
16869
16870
16871 static PyObject *_wrap_DC_GetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16872 PyObject *resultobj;
16873 wxDC *arg1 = (wxDC *) 0 ;
16874 int *arg2 = (int *) 0 ;
16875 int *arg3 = (int *) 0 ;
16876 int *arg4 = (int *) 0 ;
16877 int *arg5 = (int *) 0 ;
16878 int temp2 ;
16879 int res2 = 0 ;
16880 int temp3 ;
16881 int res3 = 0 ;
16882 int temp4 ;
16883 int res4 = 0 ;
16884 int temp5 ;
16885 int res5 = 0 ;
16886 PyObject * obj0 = 0 ;
16887 char *kwnames[] = {
16888 (char *) "self", NULL
16889 };
16890
16891 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16892 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16893 arg4 = &temp4; res4 = SWIG_NEWOBJ;
16894 arg5 = &temp5; res5 = SWIG_NEWOBJ;
16895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBoundingBox",kwnames,&obj0)) goto fail;
16896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16897 if (SWIG_arg_fail(1)) SWIG_fail;
16898 {
16899 PyThreadState* __tstate = wxPyBeginAllowThreads();
16900 wxDC_GetBoundingBox(arg1,arg2,arg3,arg4,arg5);
16901
16902 wxPyEndAllowThreads(__tstate);
16903 if (PyErr_Occurred()) SWIG_fail;
16904 }
16905 Py_INCREF(Py_None); resultobj = Py_None;
16906 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16907 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16908 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16909 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16910 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
16911 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
16912 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
16913 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
16914 return resultobj;
16915 fail:
16916 return NULL;
16917 }
16918
16919
16920 static PyObject *_wrap_DC__DrawPointList(PyObject *, PyObject *args, PyObject *kwargs) {
16921 PyObject *resultobj;
16922 wxDC *arg1 = (wxDC *) 0 ;
16923 PyObject *arg2 = (PyObject *) 0 ;
16924 PyObject *arg3 = (PyObject *) 0 ;
16925 PyObject *arg4 = (PyObject *) 0 ;
16926 PyObject *result;
16927 PyObject * obj0 = 0 ;
16928 PyObject * obj1 = 0 ;
16929 PyObject * obj2 = 0 ;
16930 PyObject * obj3 = 0 ;
16931 char *kwnames[] = {
16932 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
16933 };
16934
16935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPointList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16937 if (SWIG_arg_fail(1)) SWIG_fail;
16938 arg2 = obj1;
16939 arg3 = obj2;
16940 arg4 = obj3;
16941 {
16942 PyThreadState* __tstate = wxPyBeginAllowThreads();
16943 result = (PyObject *)wxDC__DrawPointList(arg1,arg2,arg3,arg4);
16944
16945 wxPyEndAllowThreads(__tstate);
16946 if (PyErr_Occurred()) SWIG_fail;
16947 }
16948 resultobj = result;
16949 return resultobj;
16950 fail:
16951 return NULL;
16952 }
16953
16954
16955 static PyObject *_wrap_DC__DrawLineList(PyObject *, PyObject *args, PyObject *kwargs) {
16956 PyObject *resultobj;
16957 wxDC *arg1 = (wxDC *) 0 ;
16958 PyObject *arg2 = (PyObject *) 0 ;
16959 PyObject *arg3 = (PyObject *) 0 ;
16960 PyObject *arg4 = (PyObject *) 0 ;
16961 PyObject *result;
16962 PyObject * obj0 = 0 ;
16963 PyObject * obj1 = 0 ;
16964 PyObject * obj2 = 0 ;
16965 PyObject * obj3 = 0 ;
16966 char *kwnames[] = {
16967 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
16968 };
16969
16970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawLineList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16972 if (SWIG_arg_fail(1)) SWIG_fail;
16973 arg2 = obj1;
16974 arg3 = obj2;
16975 arg4 = obj3;
16976 {
16977 PyThreadState* __tstate = wxPyBeginAllowThreads();
16978 result = (PyObject *)wxDC__DrawLineList(arg1,arg2,arg3,arg4);
16979
16980 wxPyEndAllowThreads(__tstate);
16981 if (PyErr_Occurred()) SWIG_fail;
16982 }
16983 resultobj = result;
16984 return resultobj;
16985 fail:
16986 return NULL;
16987 }
16988
16989
16990 static PyObject *_wrap_DC__DrawRectangleList(PyObject *, PyObject *args, PyObject *kwargs) {
16991 PyObject *resultobj;
16992 wxDC *arg1 = (wxDC *) 0 ;
16993 PyObject *arg2 = (PyObject *) 0 ;
16994 PyObject *arg3 = (PyObject *) 0 ;
16995 PyObject *arg4 = (PyObject *) 0 ;
16996 PyObject *result;
16997 PyObject * obj0 = 0 ;
16998 PyObject * obj1 = 0 ;
16999 PyObject * obj2 = 0 ;
17000 PyObject * obj3 = 0 ;
17001 char *kwnames[] = {
17002 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17003 };
17004
17005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawRectangleList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17007 if (SWIG_arg_fail(1)) SWIG_fail;
17008 arg2 = obj1;
17009 arg3 = obj2;
17010 arg4 = obj3;
17011 {
17012 PyThreadState* __tstate = wxPyBeginAllowThreads();
17013 result = (PyObject *)wxDC__DrawRectangleList(arg1,arg2,arg3,arg4);
17014
17015 wxPyEndAllowThreads(__tstate);
17016 if (PyErr_Occurred()) SWIG_fail;
17017 }
17018 resultobj = result;
17019 return resultobj;
17020 fail:
17021 return NULL;
17022 }
17023
17024
17025 static PyObject *_wrap_DC__DrawEllipseList(PyObject *, PyObject *args, PyObject *kwargs) {
17026 PyObject *resultobj;
17027 wxDC *arg1 = (wxDC *) 0 ;
17028 PyObject *arg2 = (PyObject *) 0 ;
17029 PyObject *arg3 = (PyObject *) 0 ;
17030 PyObject *arg4 = (PyObject *) 0 ;
17031 PyObject *result;
17032 PyObject * obj0 = 0 ;
17033 PyObject * obj1 = 0 ;
17034 PyObject * obj2 = 0 ;
17035 PyObject * obj3 = 0 ;
17036 char *kwnames[] = {
17037 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17038 };
17039
17040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawEllipseList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17042 if (SWIG_arg_fail(1)) SWIG_fail;
17043 arg2 = obj1;
17044 arg3 = obj2;
17045 arg4 = obj3;
17046 {
17047 PyThreadState* __tstate = wxPyBeginAllowThreads();
17048 result = (PyObject *)wxDC__DrawEllipseList(arg1,arg2,arg3,arg4);
17049
17050 wxPyEndAllowThreads(__tstate);
17051 if (PyErr_Occurred()) SWIG_fail;
17052 }
17053 resultobj = result;
17054 return resultobj;
17055 fail:
17056 return NULL;
17057 }
17058
17059
17060 static PyObject *_wrap_DC__DrawPolygonList(PyObject *, PyObject *args, PyObject *kwargs) {
17061 PyObject *resultobj;
17062 wxDC *arg1 = (wxDC *) 0 ;
17063 PyObject *arg2 = (PyObject *) 0 ;
17064 PyObject *arg3 = (PyObject *) 0 ;
17065 PyObject *arg4 = (PyObject *) 0 ;
17066 PyObject *result;
17067 PyObject * obj0 = 0 ;
17068 PyObject * obj1 = 0 ;
17069 PyObject * obj2 = 0 ;
17070 PyObject * obj3 = 0 ;
17071 char *kwnames[] = {
17072 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17073 };
17074
17075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPolygonList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17077 if (SWIG_arg_fail(1)) SWIG_fail;
17078 arg2 = obj1;
17079 arg3 = obj2;
17080 arg4 = obj3;
17081 {
17082 PyThreadState* __tstate = wxPyBeginAllowThreads();
17083 result = (PyObject *)wxDC__DrawPolygonList(arg1,arg2,arg3,arg4);
17084
17085 wxPyEndAllowThreads(__tstate);
17086 if (PyErr_Occurred()) SWIG_fail;
17087 }
17088 resultobj = result;
17089 return resultobj;
17090 fail:
17091 return NULL;
17092 }
17093
17094
17095 static PyObject *_wrap_DC__DrawTextList(PyObject *, PyObject *args, PyObject *kwargs) {
17096 PyObject *resultobj;
17097 wxDC *arg1 = (wxDC *) 0 ;
17098 PyObject *arg2 = (PyObject *) 0 ;
17099 PyObject *arg3 = (PyObject *) 0 ;
17100 PyObject *arg4 = (PyObject *) 0 ;
17101 PyObject *arg5 = (PyObject *) 0 ;
17102 PyObject *result;
17103 PyObject * obj0 = 0 ;
17104 PyObject * obj1 = 0 ;
17105 PyObject * obj2 = 0 ;
17106 PyObject * obj3 = 0 ;
17107 PyObject * obj4 = 0 ;
17108 char *kwnames[] = {
17109 (char *) "self",(char *) "textList",(char *) "pyPoints",(char *) "foregroundList",(char *) "backgroundList", NULL
17110 };
17111
17112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC__DrawTextList",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
17113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17114 if (SWIG_arg_fail(1)) SWIG_fail;
17115 arg2 = obj1;
17116 arg3 = obj2;
17117 arg4 = obj3;
17118 arg5 = obj4;
17119 {
17120 PyThreadState* __tstate = wxPyBeginAllowThreads();
17121 result = (PyObject *)wxDC__DrawTextList(arg1,arg2,arg3,arg4,arg5);
17122
17123 wxPyEndAllowThreads(__tstate);
17124 if (PyErr_Occurred()) SWIG_fail;
17125 }
17126 resultobj = result;
17127 return resultobj;
17128 fail:
17129 return NULL;
17130 }
17131
17132
17133 static PyObject * DC_swigregister(PyObject *, PyObject *args) {
17134 PyObject *obj;
17135 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17136 SWIG_TypeClientData(SWIGTYPE_p_wxDC, obj);
17137 Py_INCREF(obj);
17138 return Py_BuildValue((char *)"");
17139 }
17140 static PyObject *_wrap_new_MemoryDC(PyObject *, PyObject *args, PyObject *kwargs) {
17141 PyObject *resultobj;
17142 wxMemoryDC *result;
17143 char *kwnames[] = {
17144 NULL
17145 };
17146
17147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryDC",kwnames)) goto fail;
17148 {
17149 if (!wxPyCheckForApp()) SWIG_fail;
17150 PyThreadState* __tstate = wxPyBeginAllowThreads();
17151 result = (wxMemoryDC *)new wxMemoryDC();
17152
17153 wxPyEndAllowThreads(__tstate);
17154 if (PyErr_Occurred()) SWIG_fail;
17155 }
17156 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17157 return resultobj;
17158 fail:
17159 return NULL;
17160 }
17161
17162
17163 static PyObject *_wrap_new_MemoryDCFromDC(PyObject *, PyObject *args, PyObject *kwargs) {
17164 PyObject *resultobj;
17165 wxDC *arg1 = (wxDC *) 0 ;
17166 wxMemoryDC *result;
17167 PyObject * obj0 = 0 ;
17168 char *kwnames[] = {
17169 (char *) "oldDC", NULL
17170 };
17171
17172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_MemoryDCFromDC",kwnames,&obj0)) goto fail;
17173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17174 if (SWIG_arg_fail(1)) SWIG_fail;
17175 {
17176 if (!wxPyCheckForApp()) SWIG_fail;
17177 PyThreadState* __tstate = wxPyBeginAllowThreads();
17178 result = (wxMemoryDC *)new wxMemoryDC(arg1);
17179
17180 wxPyEndAllowThreads(__tstate);
17181 if (PyErr_Occurred()) SWIG_fail;
17182 }
17183 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17184 return resultobj;
17185 fail:
17186 return NULL;
17187 }
17188
17189
17190 static PyObject *_wrap_MemoryDC_SelectObject(PyObject *, PyObject *args, PyObject *kwargs) {
17191 PyObject *resultobj;
17192 wxMemoryDC *arg1 = (wxMemoryDC *) 0 ;
17193 wxBitmap *arg2 = 0 ;
17194 PyObject * obj0 = 0 ;
17195 PyObject * obj1 = 0 ;
17196 char *kwnames[] = {
17197 (char *) "self",(char *) "bitmap", NULL
17198 };
17199
17200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryDC_SelectObject",kwnames,&obj0,&obj1)) goto fail;
17201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryDC, SWIG_POINTER_EXCEPTION | 0);
17202 if (SWIG_arg_fail(1)) SWIG_fail;
17203 {
17204 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17205 if (SWIG_arg_fail(2)) SWIG_fail;
17206 if (arg2 == NULL) {
17207 SWIG_null_ref("wxBitmap");
17208 }
17209 if (SWIG_arg_fail(2)) SWIG_fail;
17210 }
17211 {
17212 PyThreadState* __tstate = wxPyBeginAllowThreads();
17213 (arg1)->SelectObject((wxBitmap const &)*arg2);
17214
17215 wxPyEndAllowThreads(__tstate);
17216 if (PyErr_Occurred()) SWIG_fail;
17217 }
17218 Py_INCREF(Py_None); resultobj = Py_None;
17219 return resultobj;
17220 fail:
17221 return NULL;
17222 }
17223
17224
17225 static PyObject * MemoryDC_swigregister(PyObject *, PyObject *args) {
17226 PyObject *obj;
17227 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17228 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryDC, obj);
17229 Py_INCREF(obj);
17230 return Py_BuildValue((char *)"");
17231 }
17232 static PyObject *_wrap_new_BufferedDC__SWIG_0(PyObject *, PyObject *args) {
17233 PyObject *resultobj;
17234 wxDC *arg1 = (wxDC *) 0 ;
17235 wxBitmap const &arg2_defvalue = wxNullBitmap ;
17236 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
17237 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
17238 wxBufferedDC *result;
17239 PyObject * obj0 = 0 ;
17240 PyObject * obj1 = 0 ;
17241 PyObject * obj2 = 0 ;
17242
17243 if(!PyArg_ParseTuple(args,(char *)"O|OO:new_BufferedDC",&obj0,&obj1,&obj2)) goto fail;
17244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17245 if (SWIG_arg_fail(1)) SWIG_fail;
17246 if (obj1) {
17247 {
17248 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17249 if (SWIG_arg_fail(2)) SWIG_fail;
17250 if (arg2 == NULL) {
17251 SWIG_null_ref("wxBitmap");
17252 }
17253 if (SWIG_arg_fail(2)) SWIG_fail;
17254 }
17255 }
17256 if (obj2) {
17257 {
17258 arg3 = (int)(SWIG_As_int(obj2));
17259 if (SWIG_arg_fail(3)) SWIG_fail;
17260 }
17261 }
17262 {
17263 if (!wxPyCheckForApp()) SWIG_fail;
17264 PyThreadState* __tstate = wxPyBeginAllowThreads();
17265 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxBitmap const &)*arg2,arg3);
17266
17267 wxPyEndAllowThreads(__tstate);
17268 if (PyErr_Occurred()) SWIG_fail;
17269 }
17270 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
17271 return resultobj;
17272 fail:
17273 return NULL;
17274 }
17275
17276
17277 static PyObject *_wrap_new_BufferedDC__SWIG_1(PyObject *, PyObject *args) {
17278 PyObject *resultobj;
17279 wxDC *arg1 = (wxDC *) 0 ;
17280 wxSize *arg2 = 0 ;
17281 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
17282 wxBufferedDC *result;
17283 wxSize temp2 ;
17284 PyObject * obj0 = 0 ;
17285 PyObject * obj1 = 0 ;
17286 PyObject * obj2 = 0 ;
17287
17288 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_BufferedDC",&obj0,&obj1,&obj2)) goto fail;
17289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17290 if (SWIG_arg_fail(1)) SWIG_fail;
17291 {
17292 arg2 = &temp2;
17293 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
17294 }
17295 if (obj2) {
17296 {
17297 arg3 = (int)(SWIG_As_int(obj2));
17298 if (SWIG_arg_fail(3)) SWIG_fail;
17299 }
17300 }
17301 {
17302 if (!wxPyCheckForApp()) SWIG_fail;
17303 PyThreadState* __tstate = wxPyBeginAllowThreads();
17304 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxSize const &)*arg2,arg3);
17305
17306 wxPyEndAllowThreads(__tstate);
17307 if (PyErr_Occurred()) SWIG_fail;
17308 }
17309 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
17310 return resultobj;
17311 fail:
17312 return NULL;
17313 }
17314
17315
17316 static PyObject *_wrap_new_BufferedDC(PyObject *self, PyObject *args) {
17317 int argc;
17318 PyObject *argv[4];
17319 int ii;
17320
17321 argc = PyObject_Length(args);
17322 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
17323 argv[ii] = PyTuple_GetItem(args,ii);
17324 }
17325 if ((argc >= 1) && (argc <= 3)) {
17326 int _v;
17327 {
17328 void *ptr;
17329 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
17330 _v = 0;
17331 PyErr_Clear();
17332 } else {
17333 _v = 1;
17334 }
17335 }
17336 if (_v) {
17337 if (argc <= 1) {
17338 return _wrap_new_BufferedDC__SWIG_0(self,args);
17339 }
17340 {
17341 void *ptr = 0;
17342 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxBitmap, 0) == -1) {
17343 _v = 0;
17344 PyErr_Clear();
17345 } else {
17346 _v = (ptr != 0);
17347 }
17348 }
17349 if (_v) {
17350 if (argc <= 2) {
17351 return _wrap_new_BufferedDC__SWIG_0(self,args);
17352 }
17353 _v = SWIG_Check_int(argv[2]);
17354 if (_v) {
17355 return _wrap_new_BufferedDC__SWIG_0(self,args);
17356 }
17357 }
17358 }
17359 }
17360 if ((argc >= 2) && (argc <= 3)) {
17361 int _v;
17362 {
17363 void *ptr;
17364 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
17365 _v = 0;
17366 PyErr_Clear();
17367 } else {
17368 _v = 1;
17369 }
17370 }
17371 if (_v) {
17372 {
17373 _v = wxPySimple_typecheck(argv[1], wxT("wxSize"), 2);
17374 }
17375 if (_v) {
17376 if (argc <= 2) {
17377 return _wrap_new_BufferedDC__SWIG_1(self,args);
17378 }
17379 _v = SWIG_Check_int(argv[2]);
17380 if (_v) {
17381 return _wrap_new_BufferedDC__SWIG_1(self,args);
17382 }
17383 }
17384 }
17385 }
17386
17387 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_BufferedDC'");
17388 return NULL;
17389 }
17390
17391
17392 static PyObject *_wrap_delete_BufferedDC(PyObject *, PyObject *args, PyObject *kwargs) {
17393 PyObject *resultobj;
17394 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
17395 PyObject * obj0 = 0 ;
17396 char *kwnames[] = {
17397 (char *) "self", NULL
17398 };
17399
17400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BufferedDC",kwnames,&obj0)) goto fail;
17401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
17402 if (SWIG_arg_fail(1)) SWIG_fail;
17403 {
17404 PyThreadState* __tstate = wxPyBeginAllowThreads();
17405 delete arg1;
17406
17407 wxPyEndAllowThreads(__tstate);
17408 if (PyErr_Occurred()) SWIG_fail;
17409 }
17410 Py_INCREF(Py_None); resultobj = Py_None;
17411 return resultobj;
17412 fail:
17413 return NULL;
17414 }
17415
17416
17417 static PyObject *_wrap_BufferedDC_UnMask(PyObject *, PyObject *args, PyObject *kwargs) {
17418 PyObject *resultobj;
17419 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
17420 PyObject * obj0 = 0 ;
17421 char *kwnames[] = {
17422 (char *) "self", NULL
17423 };
17424
17425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BufferedDC_UnMask",kwnames,&obj0)) goto fail;
17426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
17427 if (SWIG_arg_fail(1)) SWIG_fail;
17428 {
17429 PyThreadState* __tstate = wxPyBeginAllowThreads();
17430 (arg1)->UnMask();
17431
17432 wxPyEndAllowThreads(__tstate);
17433 if (PyErr_Occurred()) SWIG_fail;
17434 }
17435 Py_INCREF(Py_None); resultobj = Py_None;
17436 return resultobj;
17437 fail:
17438 return NULL;
17439 }
17440
17441
17442 static PyObject * BufferedDC_swigregister(PyObject *, PyObject *args) {
17443 PyObject *obj;
17444 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17445 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedDC, obj);
17446 Py_INCREF(obj);
17447 return Py_BuildValue((char *)"");
17448 }
17449 static PyObject *_wrap_new_BufferedPaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
17450 PyObject *resultobj;
17451 wxWindow *arg1 = (wxWindow *) 0 ;
17452 wxBitmap const &arg2_defvalue = wxNullBitmap ;
17453 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
17454 int arg3 = (int) wxBUFFER_CLIENT_AREA ;
17455 wxBufferedPaintDC *result;
17456 PyObject * obj0 = 0 ;
17457 PyObject * obj1 = 0 ;
17458 PyObject * obj2 = 0 ;
17459 char *kwnames[] = {
17460 (char *) "window",(char *) "buffer",(char *) "style", NULL
17461 };
17462
17463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_BufferedPaintDC",kwnames,&obj0,&obj1,&obj2)) goto fail;
17464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17465 if (SWIG_arg_fail(1)) SWIG_fail;
17466 if (obj1) {
17467 {
17468 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17469 if (SWIG_arg_fail(2)) SWIG_fail;
17470 if (arg2 == NULL) {
17471 SWIG_null_ref("wxBitmap");
17472 }
17473 if (SWIG_arg_fail(2)) SWIG_fail;
17474 }
17475 }
17476 if (obj2) {
17477 {
17478 arg3 = (int)(SWIG_As_int(obj2));
17479 if (SWIG_arg_fail(3)) SWIG_fail;
17480 }
17481 }
17482 {
17483 if (!wxPyCheckForApp()) SWIG_fail;
17484 PyThreadState* __tstate = wxPyBeginAllowThreads();
17485 result = (wxBufferedPaintDC *)new wxBufferedPaintDC(arg1,(wxBitmap const &)*arg2,arg3);
17486
17487 wxPyEndAllowThreads(__tstate);
17488 if (PyErr_Occurred()) SWIG_fail;
17489 }
17490 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedPaintDC, 1);
17491 return resultobj;
17492 fail:
17493 return NULL;
17494 }
17495
17496
17497 static PyObject * BufferedPaintDC_swigregister(PyObject *, PyObject *args) {
17498 PyObject *obj;
17499 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17500 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedPaintDC, obj);
17501 Py_INCREF(obj);
17502 return Py_BuildValue((char *)"");
17503 }
17504 static PyObject *_wrap_new_ScreenDC(PyObject *, PyObject *args, PyObject *kwargs) {
17505 PyObject *resultobj;
17506 wxScreenDC *result;
17507 char *kwnames[] = {
17508 NULL
17509 };
17510
17511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ScreenDC",kwnames)) goto fail;
17512 {
17513 if (!wxPyCheckForApp()) SWIG_fail;
17514 PyThreadState* __tstate = wxPyBeginAllowThreads();
17515 result = (wxScreenDC *)new wxScreenDC();
17516
17517 wxPyEndAllowThreads(__tstate);
17518 if (PyErr_Occurred()) SWIG_fail;
17519 }
17520 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScreenDC, 1);
17521 return resultobj;
17522 fail:
17523 return NULL;
17524 }
17525
17526
17527 static PyObject *_wrap_ScreenDC_StartDrawingOnTopWin(PyObject *, PyObject *args, PyObject *kwargs) {
17528 PyObject *resultobj;
17529 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17530 wxWindow *arg2 = (wxWindow *) 0 ;
17531 bool result;
17532 PyObject * obj0 = 0 ;
17533 PyObject * obj1 = 0 ;
17534 char *kwnames[] = {
17535 (char *) "self",(char *) "window", NULL
17536 };
17537
17538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScreenDC_StartDrawingOnTopWin",kwnames,&obj0,&obj1)) goto fail;
17539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17540 if (SWIG_arg_fail(1)) SWIG_fail;
17541 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17542 if (SWIG_arg_fail(2)) SWIG_fail;
17543 {
17544 PyThreadState* __tstate = wxPyBeginAllowThreads();
17545 result = (bool)(arg1)->StartDrawingOnTop(arg2);
17546
17547 wxPyEndAllowThreads(__tstate);
17548 if (PyErr_Occurred()) SWIG_fail;
17549 }
17550 {
17551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17552 }
17553 return resultobj;
17554 fail:
17555 return NULL;
17556 }
17557
17558
17559 static PyObject *_wrap_ScreenDC_StartDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
17560 PyObject *resultobj;
17561 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17562 wxRect *arg2 = (wxRect *) NULL ;
17563 bool result;
17564 PyObject * obj0 = 0 ;
17565 PyObject * obj1 = 0 ;
17566 char *kwnames[] = {
17567 (char *) "self",(char *) "rect", NULL
17568 };
17569
17570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ScreenDC_StartDrawingOnTop",kwnames,&obj0,&obj1)) goto fail;
17571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17572 if (SWIG_arg_fail(1)) SWIG_fail;
17573 if (obj1) {
17574 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
17575 if (SWIG_arg_fail(2)) SWIG_fail;
17576 }
17577 {
17578 PyThreadState* __tstate = wxPyBeginAllowThreads();
17579 result = (bool)(arg1)->StartDrawingOnTop(arg2);
17580
17581 wxPyEndAllowThreads(__tstate);
17582 if (PyErr_Occurred()) SWIG_fail;
17583 }
17584 {
17585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17586 }
17587 return resultobj;
17588 fail:
17589 return NULL;
17590 }
17591
17592
17593 static PyObject *_wrap_ScreenDC_EndDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
17594 PyObject *resultobj;
17595 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17596 bool result;
17597 PyObject * obj0 = 0 ;
17598 char *kwnames[] = {
17599 (char *) "self", NULL
17600 };
17601
17602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScreenDC_EndDrawingOnTop",kwnames,&obj0)) goto fail;
17603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17604 if (SWIG_arg_fail(1)) SWIG_fail;
17605 {
17606 PyThreadState* __tstate = wxPyBeginAllowThreads();
17607 result = (bool)(arg1)->EndDrawingOnTop();
17608
17609 wxPyEndAllowThreads(__tstate);
17610 if (PyErr_Occurred()) SWIG_fail;
17611 }
17612 {
17613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17614 }
17615 return resultobj;
17616 fail:
17617 return NULL;
17618 }
17619
17620
17621 static PyObject * ScreenDC_swigregister(PyObject *, PyObject *args) {
17622 PyObject *obj;
17623 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17624 SWIG_TypeClientData(SWIGTYPE_p_wxScreenDC, obj);
17625 Py_INCREF(obj);
17626 return Py_BuildValue((char *)"");
17627 }
17628 static PyObject *_wrap_new_ClientDC(PyObject *, PyObject *args, PyObject *kwargs) {
17629 PyObject *resultobj;
17630 wxWindow *arg1 = (wxWindow *) 0 ;
17631 wxClientDC *result;
17632 PyObject * obj0 = 0 ;
17633 char *kwnames[] = {
17634 (char *) "win", NULL
17635 };
17636
17637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ClientDC",kwnames,&obj0)) goto fail;
17638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17639 if (SWIG_arg_fail(1)) SWIG_fail;
17640 {
17641 if (!wxPyCheckForApp()) SWIG_fail;
17642 PyThreadState* __tstate = wxPyBeginAllowThreads();
17643 result = (wxClientDC *)new wxClientDC(arg1);
17644
17645 wxPyEndAllowThreads(__tstate);
17646 if (PyErr_Occurred()) SWIG_fail;
17647 }
17648 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClientDC, 1);
17649 return resultobj;
17650 fail:
17651 return NULL;
17652 }
17653
17654
17655 static PyObject * ClientDC_swigregister(PyObject *, PyObject *args) {
17656 PyObject *obj;
17657 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17658 SWIG_TypeClientData(SWIGTYPE_p_wxClientDC, obj);
17659 Py_INCREF(obj);
17660 return Py_BuildValue((char *)"");
17661 }
17662 static PyObject *_wrap_new_PaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
17663 PyObject *resultobj;
17664 wxWindow *arg1 = (wxWindow *) 0 ;
17665 wxPaintDC *result;
17666 PyObject * obj0 = 0 ;
17667 char *kwnames[] = {
17668 (char *) "win", NULL
17669 };
17670
17671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PaintDC",kwnames,&obj0)) goto fail;
17672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17673 if (SWIG_arg_fail(1)) SWIG_fail;
17674 {
17675 if (!wxPyCheckForApp()) SWIG_fail;
17676 PyThreadState* __tstate = wxPyBeginAllowThreads();
17677 result = (wxPaintDC *)new wxPaintDC(arg1);
17678
17679 wxPyEndAllowThreads(__tstate);
17680 if (PyErr_Occurred()) SWIG_fail;
17681 }
17682 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintDC, 1);
17683 return resultobj;
17684 fail:
17685 return NULL;
17686 }
17687
17688
17689 static PyObject * PaintDC_swigregister(PyObject *, PyObject *args) {
17690 PyObject *obj;
17691 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17692 SWIG_TypeClientData(SWIGTYPE_p_wxPaintDC, obj);
17693 Py_INCREF(obj);
17694 return Py_BuildValue((char *)"");
17695 }
17696 static PyObject *_wrap_new_WindowDC(PyObject *, PyObject *args, PyObject *kwargs) {
17697 PyObject *resultobj;
17698 wxWindow *arg1 = (wxWindow *) 0 ;
17699 wxWindowDC *result;
17700 PyObject * obj0 = 0 ;
17701 char *kwnames[] = {
17702 (char *) "win", NULL
17703 };
17704
17705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_WindowDC",kwnames,&obj0)) goto fail;
17706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17707 if (SWIG_arg_fail(1)) SWIG_fail;
17708 {
17709 if (!wxPyCheckForApp()) SWIG_fail;
17710 PyThreadState* __tstate = wxPyBeginAllowThreads();
17711 result = (wxWindowDC *)new wxWindowDC(arg1);
17712
17713 wxPyEndAllowThreads(__tstate);
17714 if (PyErr_Occurred()) SWIG_fail;
17715 }
17716 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDC, 1);
17717 return resultobj;
17718 fail:
17719 return NULL;
17720 }
17721
17722
17723 static PyObject * WindowDC_swigregister(PyObject *, PyObject *args) {
17724 PyObject *obj;
17725 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17726 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDC, obj);
17727 Py_INCREF(obj);
17728 return Py_BuildValue((char *)"");
17729 }
17730 static PyObject *_wrap_new_MirrorDC(PyObject *, PyObject *args, PyObject *kwargs) {
17731 PyObject *resultobj;
17732 wxDC *arg1 = 0 ;
17733 bool arg2 ;
17734 wxMirrorDC *result;
17735 PyObject * obj0 = 0 ;
17736 PyObject * obj1 = 0 ;
17737 char *kwnames[] = {
17738 (char *) "dc",(char *) "mirror", NULL
17739 };
17740
17741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_MirrorDC",kwnames,&obj0,&obj1)) goto fail;
17742 {
17743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17744 if (SWIG_arg_fail(1)) SWIG_fail;
17745 if (arg1 == NULL) {
17746 SWIG_null_ref("wxDC");
17747 }
17748 if (SWIG_arg_fail(1)) SWIG_fail;
17749 }
17750 {
17751 arg2 = (bool)(SWIG_As_bool(obj1));
17752 if (SWIG_arg_fail(2)) SWIG_fail;
17753 }
17754 {
17755 if (!wxPyCheckForApp()) SWIG_fail;
17756 PyThreadState* __tstate = wxPyBeginAllowThreads();
17757 result = (wxMirrorDC *)new wxMirrorDC(*arg1,arg2);
17758
17759 wxPyEndAllowThreads(__tstate);
17760 if (PyErr_Occurred()) SWIG_fail;
17761 }
17762 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMirrorDC, 1);
17763 return resultobj;
17764 fail:
17765 return NULL;
17766 }
17767
17768
17769 static PyObject * MirrorDC_swigregister(PyObject *, PyObject *args) {
17770 PyObject *obj;
17771 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17772 SWIG_TypeClientData(SWIGTYPE_p_wxMirrorDC, obj);
17773 Py_INCREF(obj);
17774 return Py_BuildValue((char *)"");
17775 }
17776 static PyObject *_wrap_new_PostScriptDC(PyObject *, PyObject *args, PyObject *kwargs) {
17777 PyObject *resultobj;
17778 wxPrintData *arg1 = 0 ;
17779 wxPostScriptDC *result;
17780 PyObject * obj0 = 0 ;
17781 char *kwnames[] = {
17782 (char *) "printData", NULL
17783 };
17784
17785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PostScriptDC",kwnames,&obj0)) goto fail;
17786 {
17787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
17788 if (SWIG_arg_fail(1)) SWIG_fail;
17789 if (arg1 == NULL) {
17790 SWIG_null_ref("wxPrintData");
17791 }
17792 if (SWIG_arg_fail(1)) SWIG_fail;
17793 }
17794 {
17795 if (!wxPyCheckForApp()) SWIG_fail;
17796 PyThreadState* __tstate = wxPyBeginAllowThreads();
17797 result = (wxPostScriptDC *)new wxPostScriptDC((wxPrintData const &)*arg1);
17798
17799 wxPyEndAllowThreads(__tstate);
17800 if (PyErr_Occurred()) SWIG_fail;
17801 }
17802 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPostScriptDC, 1);
17803 return resultobj;
17804 fail:
17805 return NULL;
17806 }
17807
17808
17809 static PyObject *_wrap_PostScriptDC_GetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
17810 PyObject *resultobj;
17811 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
17812 wxPrintData *result;
17813 PyObject * obj0 = 0 ;
17814 char *kwnames[] = {
17815 (char *) "self", NULL
17816 };
17817
17818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_GetPrintData",kwnames,&obj0)) goto fail;
17819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
17820 if (SWIG_arg_fail(1)) SWIG_fail;
17821 {
17822 PyThreadState* __tstate = wxPyBeginAllowThreads();
17823 {
17824 wxPrintData &_result_ref = (arg1)->GetPrintData();
17825 result = (wxPrintData *) &_result_ref;
17826 }
17827
17828 wxPyEndAllowThreads(__tstate);
17829 if (PyErr_Occurred()) SWIG_fail;
17830 }
17831 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 0);
17832 return resultobj;
17833 fail:
17834 return NULL;
17835 }
17836
17837
17838 static PyObject *_wrap_PostScriptDC_SetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
17839 PyObject *resultobj;
17840 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
17841 wxPrintData *arg2 = 0 ;
17842 PyObject * obj0 = 0 ;
17843 PyObject * obj1 = 0 ;
17844 char *kwnames[] = {
17845 (char *) "self",(char *) "data", NULL
17846 };
17847
17848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostScriptDC_SetPrintData",kwnames,&obj0,&obj1)) goto fail;
17849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
17850 if (SWIG_arg_fail(1)) SWIG_fail;
17851 {
17852 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
17853 if (SWIG_arg_fail(2)) SWIG_fail;
17854 if (arg2 == NULL) {
17855 SWIG_null_ref("wxPrintData");
17856 }
17857 if (SWIG_arg_fail(2)) SWIG_fail;
17858 }
17859 {
17860 PyThreadState* __tstate = wxPyBeginAllowThreads();
17861 (arg1)->SetPrintData((wxPrintData const &)*arg2);
17862
17863 wxPyEndAllowThreads(__tstate);
17864 if (PyErr_Occurred()) SWIG_fail;
17865 }
17866 Py_INCREF(Py_None); resultobj = Py_None;
17867 return resultobj;
17868 fail:
17869 return NULL;
17870 }
17871
17872
17873 static PyObject *_wrap_PostScriptDC_SetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
17874 PyObject *resultobj;
17875 int arg1 ;
17876 PyObject * obj0 = 0 ;
17877 char *kwnames[] = {
17878 (char *) "ppi", NULL
17879 };
17880
17881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_SetResolution",kwnames,&obj0)) goto fail;
17882 {
17883 arg1 = (int)(SWIG_As_int(obj0));
17884 if (SWIG_arg_fail(1)) SWIG_fail;
17885 }
17886 {
17887 PyThreadState* __tstate = wxPyBeginAllowThreads();
17888 wxPostScriptDC::SetResolution(arg1);
17889
17890 wxPyEndAllowThreads(__tstate);
17891 if (PyErr_Occurred()) SWIG_fail;
17892 }
17893 Py_INCREF(Py_None); resultobj = Py_None;
17894 return resultobj;
17895 fail:
17896 return NULL;
17897 }
17898
17899
17900 static PyObject *_wrap_PostScriptDC_GetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
17901 PyObject *resultobj;
17902 int result;
17903 char *kwnames[] = {
17904 NULL
17905 };
17906
17907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PostScriptDC_GetResolution",kwnames)) goto fail;
17908 {
17909 PyThreadState* __tstate = wxPyBeginAllowThreads();
17910 result = (int)wxPostScriptDC::GetResolution();
17911
17912 wxPyEndAllowThreads(__tstate);
17913 if (PyErr_Occurred()) SWIG_fail;
17914 }
17915 {
17916 resultobj = SWIG_From_int((int)(result));
17917 }
17918 return resultobj;
17919 fail:
17920 return NULL;
17921 }
17922
17923
17924 static PyObject * PostScriptDC_swigregister(PyObject *, PyObject *args) {
17925 PyObject *obj;
17926 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17927 SWIG_TypeClientData(SWIGTYPE_p_wxPostScriptDC, obj);
17928 Py_INCREF(obj);
17929 return Py_BuildValue((char *)"");
17930 }
17931 static PyObject *_wrap_new_MetaFile(PyObject *, PyObject *args, PyObject *kwargs) {
17932 PyObject *resultobj;
17933 wxString const &arg1_defvalue = wxPyEmptyString ;
17934 wxString *arg1 = (wxString *) &arg1_defvalue ;
17935 wxMetaFile *result;
17936 bool temp1 = false ;
17937 PyObject * obj0 = 0 ;
17938 char *kwnames[] = {
17939 (char *) "filename", NULL
17940 };
17941
17942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MetaFile",kwnames,&obj0)) goto fail;
17943 if (obj0) {
17944 {
17945 arg1 = wxString_in_helper(obj0);
17946 if (arg1 == NULL) SWIG_fail;
17947 temp1 = true;
17948 }
17949 }
17950 {
17951 if (!wxPyCheckForApp()) SWIG_fail;
17952 PyThreadState* __tstate = wxPyBeginAllowThreads();
17953 result = (wxMetaFile *)new wxMetaFile((wxString const &)*arg1);
17954
17955 wxPyEndAllowThreads(__tstate);
17956 if (PyErr_Occurred()) SWIG_fail;
17957 }
17958 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFile, 1);
17959 {
17960 if (temp1)
17961 delete arg1;
17962 }
17963 return resultobj;
17964 fail:
17965 {
17966 if (temp1)
17967 delete arg1;
17968 }
17969 return NULL;
17970 }
17971
17972
17973 static PyObject *_wrap_delete_MetaFile(PyObject *, PyObject *args, PyObject *kwargs) {
17974 PyObject *resultobj;
17975 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
17976 PyObject * obj0 = 0 ;
17977 char *kwnames[] = {
17978 (char *) "self", NULL
17979 };
17980
17981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MetaFile",kwnames,&obj0)) goto fail;
17982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
17983 if (SWIG_arg_fail(1)) SWIG_fail;
17984 {
17985 PyThreadState* __tstate = wxPyBeginAllowThreads();
17986 delete arg1;
17987
17988 wxPyEndAllowThreads(__tstate);
17989 if (PyErr_Occurred()) SWIG_fail;
17990 }
17991 Py_INCREF(Py_None); resultobj = Py_None;
17992 return resultobj;
17993 fail:
17994 return NULL;
17995 }
17996
17997
17998 static PyObject *_wrap_MetaFile_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
17999 PyObject *resultobj;
18000 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18001 bool result;
18002 PyObject * obj0 = 0 ;
18003 char *kwnames[] = {
18004 (char *) "self", NULL
18005 };
18006
18007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_Ok",kwnames,&obj0)) goto fail;
18008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18009 if (SWIG_arg_fail(1)) SWIG_fail;
18010 {
18011 PyThreadState* __tstate = wxPyBeginAllowThreads();
18012 result = (bool)(arg1)->Ok();
18013
18014 wxPyEndAllowThreads(__tstate);
18015 if (PyErr_Occurred()) SWIG_fail;
18016 }
18017 {
18018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18019 }
18020 return resultobj;
18021 fail:
18022 return NULL;
18023 }
18024
18025
18026 static PyObject *_wrap_MetaFile_SetClipboard(PyObject *, PyObject *args, PyObject *kwargs) {
18027 PyObject *resultobj;
18028 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18029 int arg2 = (int) 0 ;
18030 int arg3 = (int) 0 ;
18031 bool result;
18032 PyObject * obj0 = 0 ;
18033 PyObject * obj1 = 0 ;
18034 PyObject * obj2 = 0 ;
18035 char *kwnames[] = {
18036 (char *) "self",(char *) "width",(char *) "height", NULL
18037 };
18038
18039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MetaFile_SetClipboard",kwnames,&obj0,&obj1,&obj2)) goto fail;
18040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18041 if (SWIG_arg_fail(1)) SWIG_fail;
18042 if (obj1) {
18043 {
18044 arg2 = (int)(SWIG_As_int(obj1));
18045 if (SWIG_arg_fail(2)) SWIG_fail;
18046 }
18047 }
18048 if (obj2) {
18049 {
18050 arg3 = (int)(SWIG_As_int(obj2));
18051 if (SWIG_arg_fail(3)) SWIG_fail;
18052 }
18053 }
18054 {
18055 PyThreadState* __tstate = wxPyBeginAllowThreads();
18056 result = (bool)(arg1)->SetClipboard(arg2,arg3);
18057
18058 wxPyEndAllowThreads(__tstate);
18059 if (PyErr_Occurred()) SWIG_fail;
18060 }
18061 {
18062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18063 }
18064 return resultobj;
18065 fail:
18066 return NULL;
18067 }
18068
18069
18070 static PyObject *_wrap_MetaFile_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18071 PyObject *resultobj;
18072 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18073 wxSize result;
18074 PyObject * obj0 = 0 ;
18075 char *kwnames[] = {
18076 (char *) "self", NULL
18077 };
18078
18079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetSize",kwnames,&obj0)) goto fail;
18080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18081 if (SWIG_arg_fail(1)) SWIG_fail;
18082 {
18083 PyThreadState* __tstate = wxPyBeginAllowThreads();
18084 result = (arg1)->GetSize();
18085
18086 wxPyEndAllowThreads(__tstate);
18087 if (PyErr_Occurred()) SWIG_fail;
18088 }
18089 {
18090 wxSize * resultptr;
18091 resultptr = new wxSize((wxSize &)(result));
18092 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18093 }
18094 return resultobj;
18095 fail:
18096 return NULL;
18097 }
18098
18099
18100 static PyObject *_wrap_MetaFile_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
18101 PyObject *resultobj;
18102 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18103 int result;
18104 PyObject * obj0 = 0 ;
18105 char *kwnames[] = {
18106 (char *) "self", NULL
18107 };
18108
18109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetWidth",kwnames,&obj0)) goto fail;
18110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18111 if (SWIG_arg_fail(1)) SWIG_fail;
18112 {
18113 PyThreadState* __tstate = wxPyBeginAllowThreads();
18114 result = (int)(arg1)->GetWidth();
18115
18116 wxPyEndAllowThreads(__tstate);
18117 if (PyErr_Occurred()) SWIG_fail;
18118 }
18119 {
18120 resultobj = SWIG_From_int((int)(result));
18121 }
18122 return resultobj;
18123 fail:
18124 return NULL;
18125 }
18126
18127
18128 static PyObject *_wrap_MetaFile_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
18129 PyObject *resultobj;
18130 wxMetaFile *arg1 = (wxMetaFile *) 0 ;
18131 int result;
18132 PyObject * obj0 = 0 ;
18133 char *kwnames[] = {
18134 (char *) "self", NULL
18135 };
18136
18137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFile_GetHeight",kwnames,&obj0)) goto fail;
18138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFile, SWIG_POINTER_EXCEPTION | 0);
18139 if (SWIG_arg_fail(1)) SWIG_fail;
18140 {
18141 PyThreadState* __tstate = wxPyBeginAllowThreads();
18142 result = (int)(arg1)->GetHeight();
18143
18144 wxPyEndAllowThreads(__tstate);
18145 if (PyErr_Occurred()) SWIG_fail;
18146 }
18147 {
18148 resultobj = SWIG_From_int((int)(result));
18149 }
18150 return resultobj;
18151 fail:
18152 return NULL;
18153 }
18154
18155
18156 static PyObject * MetaFile_swigregister(PyObject *, PyObject *args) {
18157 PyObject *obj;
18158 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18159 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFile, obj);
18160 Py_INCREF(obj);
18161 return Py_BuildValue((char *)"");
18162 }
18163 static PyObject *_wrap_new_MetaFileDC(PyObject *, PyObject *args, PyObject *kwargs) {
18164 PyObject *resultobj;
18165 wxString const &arg1_defvalue = wxPyEmptyString ;
18166 wxString *arg1 = (wxString *) &arg1_defvalue ;
18167 int arg2 = (int) 0 ;
18168 int arg3 = (int) 0 ;
18169 wxString const &arg4_defvalue = wxPyEmptyString ;
18170 wxString *arg4 = (wxString *) &arg4_defvalue ;
18171 wxMetaFileDC *result;
18172 bool temp1 = false ;
18173 bool temp4 = false ;
18174 PyObject * obj0 = 0 ;
18175 PyObject * obj1 = 0 ;
18176 PyObject * obj2 = 0 ;
18177 PyObject * obj3 = 0 ;
18178 char *kwnames[] = {
18179 (char *) "filename",(char *) "width",(char *) "height",(char *) "description", NULL
18180 };
18181
18182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_MetaFileDC",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
18183 if (obj0) {
18184 {
18185 arg1 = wxString_in_helper(obj0);
18186 if (arg1 == NULL) SWIG_fail;
18187 temp1 = true;
18188 }
18189 }
18190 if (obj1) {
18191 {
18192 arg2 = (int)(SWIG_As_int(obj1));
18193 if (SWIG_arg_fail(2)) SWIG_fail;
18194 }
18195 }
18196 if (obj2) {
18197 {
18198 arg3 = (int)(SWIG_As_int(obj2));
18199 if (SWIG_arg_fail(3)) SWIG_fail;
18200 }
18201 }
18202 if (obj3) {
18203 {
18204 arg4 = wxString_in_helper(obj3);
18205 if (arg4 == NULL) SWIG_fail;
18206 temp4 = true;
18207 }
18208 }
18209 {
18210 if (!wxPyCheckForApp()) SWIG_fail;
18211 PyThreadState* __tstate = wxPyBeginAllowThreads();
18212 result = (wxMetaFileDC *)new wxMetaFileDC((wxString const &)*arg1,arg2,arg3,(wxString const &)*arg4);
18213
18214 wxPyEndAllowThreads(__tstate);
18215 if (PyErr_Occurred()) SWIG_fail;
18216 }
18217 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFileDC, 1);
18218 {
18219 if (temp1)
18220 delete arg1;
18221 }
18222 {
18223 if (temp4)
18224 delete arg4;
18225 }
18226 return resultobj;
18227 fail:
18228 {
18229 if (temp1)
18230 delete arg1;
18231 }
18232 {
18233 if (temp4)
18234 delete arg4;
18235 }
18236 return NULL;
18237 }
18238
18239
18240 static PyObject *_wrap_MetaFileDC_Close(PyObject *, PyObject *args, PyObject *kwargs) {
18241 PyObject *resultobj;
18242 wxMetaFileDC *arg1 = (wxMetaFileDC *) 0 ;
18243 wxMetaFile *result;
18244 PyObject * obj0 = 0 ;
18245 char *kwnames[] = {
18246 (char *) "self", NULL
18247 };
18248
18249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetaFileDC_Close",kwnames,&obj0)) goto fail;
18250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetaFileDC, SWIG_POINTER_EXCEPTION | 0);
18251 if (SWIG_arg_fail(1)) SWIG_fail;
18252 {
18253 PyThreadState* __tstate = wxPyBeginAllowThreads();
18254 result = (wxMetaFile *)(arg1)->Close();
18255
18256 wxPyEndAllowThreads(__tstate);
18257 if (PyErr_Occurred()) SWIG_fail;
18258 }
18259 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFile, 0);
18260 return resultobj;
18261 fail:
18262 return NULL;
18263 }
18264
18265
18266 static PyObject * MetaFileDC_swigregister(PyObject *, PyObject *args) {
18267 PyObject *obj;
18268 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18269 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFileDC, obj);
18270 Py_INCREF(obj);
18271 return Py_BuildValue((char *)"");
18272 }
18273 static PyObject *_wrap_new_PrinterDC(PyObject *, PyObject *args, PyObject *kwargs) {
18274 PyObject *resultobj;
18275 wxPrintData *arg1 = 0 ;
18276 wxPrinterDC *result;
18277 PyObject * obj0 = 0 ;
18278 char *kwnames[] = {
18279 (char *) "printData", NULL
18280 };
18281
18282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PrinterDC",kwnames,&obj0)) goto fail;
18283 {
18284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
18285 if (SWIG_arg_fail(1)) SWIG_fail;
18286 if (arg1 == NULL) {
18287 SWIG_null_ref("wxPrintData");
18288 }
18289 if (SWIG_arg_fail(1)) SWIG_fail;
18290 }
18291 {
18292 if (!wxPyCheckForApp()) SWIG_fail;
18293 PyThreadState* __tstate = wxPyBeginAllowThreads();
18294 result = (wxPrinterDC *)new wxPrinterDC((wxPrintData const &)*arg1);
18295
18296 wxPyEndAllowThreads(__tstate);
18297 if (PyErr_Occurred()) SWIG_fail;
18298 }
18299 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrinterDC, 1);
18300 return resultobj;
18301 fail:
18302 return NULL;
18303 }
18304
18305
18306 static PyObject * PrinterDC_swigregister(PyObject *, PyObject *args) {
18307 PyObject *obj;
18308 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18309 SWIG_TypeClientData(SWIGTYPE_p_wxPrinterDC, obj);
18310 Py_INCREF(obj);
18311 return Py_BuildValue((char *)"");
18312 }
18313 static PyObject *_wrap_new_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
18314 PyObject *resultobj;
18315 int arg1 ;
18316 int arg2 ;
18317 int arg3 = (int) true ;
18318 int arg4 = (int) 1 ;
18319 wxImageList *result;
18320 PyObject * obj0 = 0 ;
18321 PyObject * obj1 = 0 ;
18322 PyObject * obj2 = 0 ;
18323 PyObject * obj3 = 0 ;
18324 char *kwnames[] = {
18325 (char *) "width",(char *) "height",(char *) "mask",(char *) "initialCount", NULL
18326 };
18327
18328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_ImageList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
18329 {
18330 arg1 = (int)(SWIG_As_int(obj0));
18331 if (SWIG_arg_fail(1)) SWIG_fail;
18332 }
18333 {
18334 arg2 = (int)(SWIG_As_int(obj1));
18335 if (SWIG_arg_fail(2)) SWIG_fail;
18336 }
18337 if (obj2) {
18338 {
18339 arg3 = (int)(SWIG_As_int(obj2));
18340 if (SWIG_arg_fail(3)) SWIG_fail;
18341 }
18342 }
18343 if (obj3) {
18344 {
18345 arg4 = (int)(SWIG_As_int(obj3));
18346 if (SWIG_arg_fail(4)) SWIG_fail;
18347 }
18348 }
18349 {
18350 if (!wxPyCheckForApp()) SWIG_fail;
18351 PyThreadState* __tstate = wxPyBeginAllowThreads();
18352 result = (wxImageList *)new wxImageList(arg1,arg2,arg3,arg4);
18353
18354 wxPyEndAllowThreads(__tstate);
18355 if (PyErr_Occurred()) SWIG_fail;
18356 }
18357 {
18358 resultobj = wxPyMake_wxObject(result, 1);
18359 }
18360 return resultobj;
18361 fail:
18362 return NULL;
18363 }
18364
18365
18366 static PyObject *_wrap_delete_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
18367 PyObject *resultobj;
18368 wxImageList *arg1 = (wxImageList *) 0 ;
18369 PyObject * obj0 = 0 ;
18370 char *kwnames[] = {
18371 (char *) "self", NULL
18372 };
18373
18374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ImageList",kwnames,&obj0)) goto fail;
18375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18376 if (SWIG_arg_fail(1)) SWIG_fail;
18377 {
18378 PyThreadState* __tstate = wxPyBeginAllowThreads();
18379 delete arg1;
18380
18381 wxPyEndAllowThreads(__tstate);
18382 if (PyErr_Occurred()) SWIG_fail;
18383 }
18384 Py_INCREF(Py_None); resultobj = Py_None;
18385 return resultobj;
18386 fail:
18387 return NULL;
18388 }
18389
18390
18391 static PyObject *_wrap_ImageList_Add(PyObject *, PyObject *args, PyObject *kwargs) {
18392 PyObject *resultobj;
18393 wxImageList *arg1 = (wxImageList *) 0 ;
18394 wxBitmap *arg2 = 0 ;
18395 wxBitmap const &arg3_defvalue = wxNullBitmap ;
18396 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
18397 int result;
18398 PyObject * obj0 = 0 ;
18399 PyObject * obj1 = 0 ;
18400 PyObject * obj2 = 0 ;
18401 char *kwnames[] = {
18402 (char *) "self",(char *) "bitmap",(char *) "mask", NULL
18403 };
18404
18405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ImageList_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
18406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18407 if (SWIG_arg_fail(1)) SWIG_fail;
18408 {
18409 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18410 if (SWIG_arg_fail(2)) SWIG_fail;
18411 if (arg2 == NULL) {
18412 SWIG_null_ref("wxBitmap");
18413 }
18414 if (SWIG_arg_fail(2)) SWIG_fail;
18415 }
18416 if (obj2) {
18417 {
18418 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18419 if (SWIG_arg_fail(3)) SWIG_fail;
18420 if (arg3 == NULL) {
18421 SWIG_null_ref("wxBitmap");
18422 }
18423 if (SWIG_arg_fail(3)) SWIG_fail;
18424 }
18425 }
18426 {
18427 PyThreadState* __tstate = wxPyBeginAllowThreads();
18428 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
18429
18430 wxPyEndAllowThreads(__tstate);
18431 if (PyErr_Occurred()) SWIG_fail;
18432 }
18433 {
18434 resultobj = SWIG_From_int((int)(result));
18435 }
18436 return resultobj;
18437 fail:
18438 return NULL;
18439 }
18440
18441
18442 static PyObject *_wrap_ImageList_AddWithColourMask(PyObject *, PyObject *args, PyObject *kwargs) {
18443 PyObject *resultobj;
18444 wxImageList *arg1 = (wxImageList *) 0 ;
18445 wxBitmap *arg2 = 0 ;
18446 wxColour *arg3 = 0 ;
18447 int result;
18448 wxColour temp3 ;
18449 PyObject * obj0 = 0 ;
18450 PyObject * obj1 = 0 ;
18451 PyObject * obj2 = 0 ;
18452 char *kwnames[] = {
18453 (char *) "self",(char *) "bitmap",(char *) "maskColour", NULL
18454 };
18455
18456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_AddWithColourMask",kwnames,&obj0,&obj1,&obj2)) goto fail;
18457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18458 if (SWIG_arg_fail(1)) SWIG_fail;
18459 {
18460 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18461 if (SWIG_arg_fail(2)) SWIG_fail;
18462 if (arg2 == NULL) {
18463 SWIG_null_ref("wxBitmap");
18464 }
18465 if (SWIG_arg_fail(2)) SWIG_fail;
18466 }
18467 {
18468 arg3 = &temp3;
18469 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
18470 }
18471 {
18472 PyThreadState* __tstate = wxPyBeginAllowThreads();
18473 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxColour const &)*arg3);
18474
18475 wxPyEndAllowThreads(__tstate);
18476 if (PyErr_Occurred()) SWIG_fail;
18477 }
18478 {
18479 resultobj = SWIG_From_int((int)(result));
18480 }
18481 return resultobj;
18482 fail:
18483 return NULL;
18484 }
18485
18486
18487 static PyObject *_wrap_ImageList_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
18488 PyObject *resultobj;
18489 wxImageList *arg1 = (wxImageList *) 0 ;
18490 wxIcon *arg2 = 0 ;
18491 int result;
18492 PyObject * obj0 = 0 ;
18493 PyObject * obj1 = 0 ;
18494 char *kwnames[] = {
18495 (char *) "self",(char *) "icon", NULL
18496 };
18497
18498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_AddIcon",kwnames,&obj0,&obj1)) goto fail;
18499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18500 if (SWIG_arg_fail(1)) SWIG_fail;
18501 {
18502 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
18503 if (SWIG_arg_fail(2)) SWIG_fail;
18504 if (arg2 == NULL) {
18505 SWIG_null_ref("wxIcon");
18506 }
18507 if (SWIG_arg_fail(2)) SWIG_fail;
18508 }
18509 {
18510 PyThreadState* __tstate = wxPyBeginAllowThreads();
18511 result = (int)(arg1)->Add((wxIcon const &)*arg2);
18512
18513 wxPyEndAllowThreads(__tstate);
18514 if (PyErr_Occurred()) SWIG_fail;
18515 }
18516 {
18517 resultobj = SWIG_From_int((int)(result));
18518 }
18519 return resultobj;
18520 fail:
18521 return NULL;
18522 }
18523
18524
18525 static PyObject *_wrap_ImageList_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
18526 PyObject *resultobj;
18527 wxImageList *arg1 = (wxImageList *) 0 ;
18528 int arg2 ;
18529 SwigValueWrapper<wxBitmap > result;
18530 PyObject * obj0 = 0 ;
18531 PyObject * obj1 = 0 ;
18532 char *kwnames[] = {
18533 (char *) "self",(char *) "index", NULL
18534 };
18535
18536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetBitmap",kwnames,&obj0,&obj1)) goto fail;
18537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18538 if (SWIG_arg_fail(1)) SWIG_fail;
18539 {
18540 arg2 = (int)(SWIG_As_int(obj1));
18541 if (SWIG_arg_fail(2)) SWIG_fail;
18542 }
18543 {
18544 PyThreadState* __tstate = wxPyBeginAllowThreads();
18545 result = ((wxImageList const *)arg1)->GetBitmap(arg2);
18546
18547 wxPyEndAllowThreads(__tstate);
18548 if (PyErr_Occurred()) SWIG_fail;
18549 }
18550 {
18551 wxBitmap * resultptr;
18552 resultptr = new wxBitmap((wxBitmap &)(result));
18553 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
18554 }
18555 return resultobj;
18556 fail:
18557 return NULL;
18558 }
18559
18560
18561 static PyObject *_wrap_ImageList_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
18562 PyObject *resultobj;
18563 wxImageList *arg1 = (wxImageList *) 0 ;
18564 int arg2 ;
18565 wxIcon result;
18566 PyObject * obj0 = 0 ;
18567 PyObject * obj1 = 0 ;
18568 char *kwnames[] = {
18569 (char *) "self",(char *) "index", NULL
18570 };
18571
18572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetIcon",kwnames,&obj0,&obj1)) goto fail;
18573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18574 if (SWIG_arg_fail(1)) SWIG_fail;
18575 {
18576 arg2 = (int)(SWIG_As_int(obj1));
18577 if (SWIG_arg_fail(2)) SWIG_fail;
18578 }
18579 {
18580 PyThreadState* __tstate = wxPyBeginAllowThreads();
18581 result = ((wxImageList const *)arg1)->GetIcon(arg2);
18582
18583 wxPyEndAllowThreads(__tstate);
18584 if (PyErr_Occurred()) SWIG_fail;
18585 }
18586 {
18587 wxIcon * resultptr;
18588 resultptr = new wxIcon((wxIcon &)(result));
18589 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
18590 }
18591 return resultobj;
18592 fail:
18593 return NULL;
18594 }
18595
18596
18597 static PyObject *_wrap_ImageList_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
18598 PyObject *resultobj;
18599 wxImageList *arg1 = (wxImageList *) 0 ;
18600 int arg2 ;
18601 wxBitmap *arg3 = 0 ;
18602 bool result;
18603 PyObject * obj0 = 0 ;
18604 PyObject * obj1 = 0 ;
18605 PyObject * obj2 = 0 ;
18606 char *kwnames[] = {
18607 (char *) "self",(char *) "index",(char *) "bitmap", NULL
18608 };
18609
18610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_Replace",kwnames,&obj0,&obj1,&obj2)) goto fail;
18611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18612 if (SWIG_arg_fail(1)) SWIG_fail;
18613 {
18614 arg2 = (int)(SWIG_As_int(obj1));
18615 if (SWIG_arg_fail(2)) SWIG_fail;
18616 }
18617 {
18618 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18619 if (SWIG_arg_fail(3)) SWIG_fail;
18620 if (arg3 == NULL) {
18621 SWIG_null_ref("wxBitmap");
18622 }
18623 if (SWIG_arg_fail(3)) SWIG_fail;
18624 }
18625 {
18626 PyThreadState* __tstate = wxPyBeginAllowThreads();
18627 result = (bool)(arg1)->Replace(arg2,(wxBitmap const &)*arg3);
18628
18629 wxPyEndAllowThreads(__tstate);
18630 if (PyErr_Occurred()) SWIG_fail;
18631 }
18632 {
18633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18634 }
18635 return resultobj;
18636 fail:
18637 return NULL;
18638 }
18639
18640
18641 static PyObject *_wrap_ImageList_Draw(PyObject *, PyObject *args, PyObject *kwargs) {
18642 PyObject *resultobj;
18643 wxImageList *arg1 = (wxImageList *) 0 ;
18644 int arg2 ;
18645 wxDC *arg3 = 0 ;
18646 int arg4 ;
18647 int arg5 ;
18648 int arg6 = (int) wxIMAGELIST_DRAW_NORMAL ;
18649 bool arg7 = (bool) (bool)false ;
18650 bool result;
18651 PyObject * obj0 = 0 ;
18652 PyObject * obj1 = 0 ;
18653 PyObject * obj2 = 0 ;
18654 PyObject * obj3 = 0 ;
18655 PyObject * obj4 = 0 ;
18656 PyObject * obj5 = 0 ;
18657 PyObject * obj6 = 0 ;
18658 char *kwnames[] = {
18659 (char *) "self",(char *) "index",(char *) "dc",(char *) "x",(char *) "x",(char *) "flags",(char *) "solidBackground", NULL
18660 };
18661
18662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OO:ImageList_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
18663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18664 if (SWIG_arg_fail(1)) SWIG_fail;
18665 {
18666 arg2 = (int)(SWIG_As_int(obj1));
18667 if (SWIG_arg_fail(2)) SWIG_fail;
18668 }
18669 {
18670 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
18671 if (SWIG_arg_fail(3)) SWIG_fail;
18672 if (arg3 == NULL) {
18673 SWIG_null_ref("wxDC");
18674 }
18675 if (SWIG_arg_fail(3)) SWIG_fail;
18676 }
18677 {
18678 arg4 = (int)(SWIG_As_int(obj3));
18679 if (SWIG_arg_fail(4)) SWIG_fail;
18680 }
18681 {
18682 arg5 = (int)(SWIG_As_int(obj4));
18683 if (SWIG_arg_fail(5)) SWIG_fail;
18684 }
18685 if (obj5) {
18686 {
18687 arg6 = (int)(SWIG_As_int(obj5));
18688 if (SWIG_arg_fail(6)) SWIG_fail;
18689 }
18690 }
18691 if (obj6) {
18692 {
18693 arg7 = (bool const)(SWIG_As_bool(obj6));
18694 if (SWIG_arg_fail(7)) SWIG_fail;
18695 }
18696 }
18697 {
18698 PyThreadState* __tstate = wxPyBeginAllowThreads();
18699 result = (bool)(arg1)->Draw(arg2,*arg3,arg4,arg5,arg6,arg7);
18700
18701 wxPyEndAllowThreads(__tstate);
18702 if (PyErr_Occurred()) SWIG_fail;
18703 }
18704 {
18705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18706 }
18707 return resultobj;
18708 fail:
18709 return NULL;
18710 }
18711
18712
18713 static PyObject *_wrap_ImageList_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
18714 PyObject *resultobj;
18715 wxImageList *arg1 = (wxImageList *) 0 ;
18716 int result;
18717 PyObject * obj0 = 0 ;
18718 char *kwnames[] = {
18719 (char *) "self", NULL
18720 };
18721
18722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_GetImageCount",kwnames,&obj0)) goto fail;
18723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18724 if (SWIG_arg_fail(1)) SWIG_fail;
18725 {
18726 PyThreadState* __tstate = wxPyBeginAllowThreads();
18727 result = (int)(arg1)->GetImageCount();
18728
18729 wxPyEndAllowThreads(__tstate);
18730 if (PyErr_Occurred()) SWIG_fail;
18731 }
18732 {
18733 resultobj = SWIG_From_int((int)(result));
18734 }
18735 return resultobj;
18736 fail:
18737 return NULL;
18738 }
18739
18740
18741 static PyObject *_wrap_ImageList_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
18742 PyObject *resultobj;
18743 wxImageList *arg1 = (wxImageList *) 0 ;
18744 int arg2 ;
18745 bool result;
18746 PyObject * obj0 = 0 ;
18747 PyObject * obj1 = 0 ;
18748 char *kwnames[] = {
18749 (char *) "self",(char *) "index", NULL
18750 };
18751
18752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_Remove",kwnames,&obj0,&obj1)) goto fail;
18753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18754 if (SWIG_arg_fail(1)) SWIG_fail;
18755 {
18756 arg2 = (int)(SWIG_As_int(obj1));
18757 if (SWIG_arg_fail(2)) SWIG_fail;
18758 }
18759 {
18760 PyThreadState* __tstate = wxPyBeginAllowThreads();
18761 result = (bool)(arg1)->Remove(arg2);
18762
18763 wxPyEndAllowThreads(__tstate);
18764 if (PyErr_Occurred()) SWIG_fail;
18765 }
18766 {
18767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18768 }
18769 return resultobj;
18770 fail:
18771 return NULL;
18772 }
18773
18774
18775 static PyObject *_wrap_ImageList_RemoveAll(PyObject *, PyObject *args, PyObject *kwargs) {
18776 PyObject *resultobj;
18777 wxImageList *arg1 = (wxImageList *) 0 ;
18778 bool result;
18779 PyObject * obj0 = 0 ;
18780 char *kwnames[] = {
18781 (char *) "self", NULL
18782 };
18783
18784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_RemoveAll",kwnames,&obj0)) goto fail;
18785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18786 if (SWIG_arg_fail(1)) SWIG_fail;
18787 {
18788 PyThreadState* __tstate = wxPyBeginAllowThreads();
18789 result = (bool)(arg1)->RemoveAll();
18790
18791 wxPyEndAllowThreads(__tstate);
18792 if (PyErr_Occurred()) SWIG_fail;
18793 }
18794 {
18795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18796 }
18797 return resultobj;
18798 fail:
18799 return NULL;
18800 }
18801
18802
18803 static PyObject *_wrap_ImageList_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18804 PyObject *resultobj;
18805 wxImageList *arg1 = (wxImageList *) 0 ;
18806 int arg2 ;
18807 int *arg3 = 0 ;
18808 int *arg4 = 0 ;
18809 int temp3 ;
18810 int res3 = 0 ;
18811 int temp4 ;
18812 int res4 = 0 ;
18813 PyObject * obj0 = 0 ;
18814 PyObject * obj1 = 0 ;
18815 char *kwnames[] = {
18816 (char *) "self",(char *) "index", NULL
18817 };
18818
18819 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18820 arg4 = &temp4; res4 = SWIG_NEWOBJ;
18821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetSize",kwnames,&obj0,&obj1)) goto fail;
18822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18823 if (SWIG_arg_fail(1)) SWIG_fail;
18824 {
18825 arg2 = (int)(SWIG_As_int(obj1));
18826 if (SWIG_arg_fail(2)) SWIG_fail;
18827 }
18828 {
18829 PyThreadState* __tstate = wxPyBeginAllowThreads();
18830 (arg1)->GetSize(arg2,*arg3,*arg4);
18831
18832 wxPyEndAllowThreads(__tstate);
18833 if (PyErr_Occurred()) SWIG_fail;
18834 }
18835 Py_INCREF(Py_None); resultobj = Py_None;
18836 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18837 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
18838 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
18839 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
18840 return resultobj;
18841 fail:
18842 return NULL;
18843 }
18844
18845
18846 static PyObject * ImageList_swigregister(PyObject *, PyObject *args) {
18847 PyObject *obj;
18848 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18849 SWIG_TypeClientData(SWIGTYPE_p_wxImageList, obj);
18850 Py_INCREF(obj);
18851 return Py_BuildValue((char *)"");
18852 }
18853 static int _wrap_NORMAL_FONT_set(PyObject *) {
18854 PyErr_SetString(PyExc_TypeError,"Variable NORMAL_FONT is read-only.");
18855 return 1;
18856 }
18857
18858
18859 static PyObject *_wrap_NORMAL_FONT_get(void) {
18860 PyObject *pyobj;
18861
18862 pyobj = SWIG_NewPointerObj((void *)(wxNORMAL_FONT), SWIGTYPE_p_wxFont, 0);
18863 return pyobj;
18864 }
18865
18866
18867 static int _wrap_SMALL_FONT_set(PyObject *) {
18868 PyErr_SetString(PyExc_TypeError,"Variable SMALL_FONT is read-only.");
18869 return 1;
18870 }
18871
18872
18873 static PyObject *_wrap_SMALL_FONT_get(void) {
18874 PyObject *pyobj;
18875
18876 pyobj = SWIG_NewPointerObj((void *)(wxSMALL_FONT), SWIGTYPE_p_wxFont, 0);
18877 return pyobj;
18878 }
18879
18880
18881 static int _wrap_ITALIC_FONT_set(PyObject *) {
18882 PyErr_SetString(PyExc_TypeError,"Variable ITALIC_FONT is read-only.");
18883 return 1;
18884 }
18885
18886
18887 static PyObject *_wrap_ITALIC_FONT_get(void) {
18888 PyObject *pyobj;
18889
18890 pyobj = SWIG_NewPointerObj((void *)(wxITALIC_FONT), SWIGTYPE_p_wxFont, 0);
18891 return pyobj;
18892 }
18893
18894
18895 static int _wrap_SWISS_FONT_set(PyObject *) {
18896 PyErr_SetString(PyExc_TypeError,"Variable SWISS_FONT is read-only.");
18897 return 1;
18898 }
18899
18900
18901 static PyObject *_wrap_SWISS_FONT_get(void) {
18902 PyObject *pyobj;
18903
18904 pyobj = SWIG_NewPointerObj((void *)(wxSWISS_FONT), SWIGTYPE_p_wxFont, 0);
18905 return pyobj;
18906 }
18907
18908
18909 static int _wrap_RED_PEN_set(PyObject *) {
18910 PyErr_SetString(PyExc_TypeError,"Variable RED_PEN is read-only.");
18911 return 1;
18912 }
18913
18914
18915 static PyObject *_wrap_RED_PEN_get(void) {
18916 PyObject *pyobj;
18917
18918 pyobj = SWIG_NewPointerObj((void *)(wxRED_PEN), SWIGTYPE_p_wxPen, 0);
18919 return pyobj;
18920 }
18921
18922
18923 static int _wrap_CYAN_PEN_set(PyObject *) {
18924 PyErr_SetString(PyExc_TypeError,"Variable CYAN_PEN is read-only.");
18925 return 1;
18926 }
18927
18928
18929 static PyObject *_wrap_CYAN_PEN_get(void) {
18930 PyObject *pyobj;
18931
18932 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_PEN), SWIGTYPE_p_wxPen, 0);
18933 return pyobj;
18934 }
18935
18936
18937 static int _wrap_GREEN_PEN_set(PyObject *) {
18938 PyErr_SetString(PyExc_TypeError,"Variable GREEN_PEN is read-only.");
18939 return 1;
18940 }
18941
18942
18943 static PyObject *_wrap_GREEN_PEN_get(void) {
18944 PyObject *pyobj;
18945
18946 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_PEN), SWIGTYPE_p_wxPen, 0);
18947 return pyobj;
18948 }
18949
18950
18951 static int _wrap_BLACK_PEN_set(PyObject *) {
18952 PyErr_SetString(PyExc_TypeError,"Variable BLACK_PEN is read-only.");
18953 return 1;
18954 }
18955
18956
18957 static PyObject *_wrap_BLACK_PEN_get(void) {
18958 PyObject *pyobj;
18959
18960 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_PEN), SWIGTYPE_p_wxPen, 0);
18961 return pyobj;
18962 }
18963
18964
18965 static int _wrap_WHITE_PEN_set(PyObject *) {
18966 PyErr_SetString(PyExc_TypeError,"Variable WHITE_PEN is read-only.");
18967 return 1;
18968 }
18969
18970
18971 static PyObject *_wrap_WHITE_PEN_get(void) {
18972 PyObject *pyobj;
18973
18974 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_PEN), SWIGTYPE_p_wxPen, 0);
18975 return pyobj;
18976 }
18977
18978
18979 static int _wrap_TRANSPARENT_PEN_set(PyObject *) {
18980 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_PEN is read-only.");
18981 return 1;
18982 }
18983
18984
18985 static PyObject *_wrap_TRANSPARENT_PEN_get(void) {
18986 PyObject *pyobj;
18987
18988 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_PEN), SWIGTYPE_p_wxPen, 0);
18989 return pyobj;
18990 }
18991
18992
18993 static int _wrap_BLACK_DASHED_PEN_set(PyObject *) {
18994 PyErr_SetString(PyExc_TypeError,"Variable BLACK_DASHED_PEN is read-only.");
18995 return 1;
18996 }
18997
18998
18999 static PyObject *_wrap_BLACK_DASHED_PEN_get(void) {
19000 PyObject *pyobj;
19001
19002 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_DASHED_PEN), SWIGTYPE_p_wxPen, 0);
19003 return pyobj;
19004 }
19005
19006
19007 static int _wrap_GREY_PEN_set(PyObject *) {
19008 PyErr_SetString(PyExc_TypeError,"Variable GREY_PEN is read-only.");
19009 return 1;
19010 }
19011
19012
19013 static PyObject *_wrap_GREY_PEN_get(void) {
19014 PyObject *pyobj;
19015
19016 pyobj = SWIG_NewPointerObj((void *)(wxGREY_PEN), SWIGTYPE_p_wxPen, 0);
19017 return pyobj;
19018 }
19019
19020
19021 static int _wrap_MEDIUM_GREY_PEN_set(PyObject *) {
19022 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_PEN is read-only.");
19023 return 1;
19024 }
19025
19026
19027 static PyObject *_wrap_MEDIUM_GREY_PEN_get(void) {
19028 PyObject *pyobj;
19029
19030 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_PEN), SWIGTYPE_p_wxPen, 0);
19031 return pyobj;
19032 }
19033
19034
19035 static int _wrap_LIGHT_GREY_PEN_set(PyObject *) {
19036 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_PEN is read-only.");
19037 return 1;
19038 }
19039
19040
19041 static PyObject *_wrap_LIGHT_GREY_PEN_get(void) {
19042 PyObject *pyobj;
19043
19044 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_PEN), SWIGTYPE_p_wxPen, 0);
19045 return pyobj;
19046 }
19047
19048
19049 static int _wrap_BLUE_BRUSH_set(PyObject *) {
19050 PyErr_SetString(PyExc_TypeError,"Variable BLUE_BRUSH is read-only.");
19051 return 1;
19052 }
19053
19054
19055 static PyObject *_wrap_BLUE_BRUSH_get(void) {
19056 PyObject *pyobj;
19057
19058 pyobj = SWIG_NewPointerObj((void *)(wxBLUE_BRUSH), SWIGTYPE_p_wxBrush, 0);
19059 return pyobj;
19060 }
19061
19062
19063 static int _wrap_GREEN_BRUSH_set(PyObject *) {
19064 PyErr_SetString(PyExc_TypeError,"Variable GREEN_BRUSH is read-only.");
19065 return 1;
19066 }
19067
19068
19069 static PyObject *_wrap_GREEN_BRUSH_get(void) {
19070 PyObject *pyobj;
19071
19072 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_BRUSH), SWIGTYPE_p_wxBrush, 0);
19073 return pyobj;
19074 }
19075
19076
19077 static int _wrap_WHITE_BRUSH_set(PyObject *) {
19078 PyErr_SetString(PyExc_TypeError,"Variable WHITE_BRUSH is read-only.");
19079 return 1;
19080 }
19081
19082
19083 static PyObject *_wrap_WHITE_BRUSH_get(void) {
19084 PyObject *pyobj;
19085
19086 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_BRUSH), SWIGTYPE_p_wxBrush, 0);
19087 return pyobj;
19088 }
19089
19090
19091 static int _wrap_BLACK_BRUSH_set(PyObject *) {
19092 PyErr_SetString(PyExc_TypeError,"Variable BLACK_BRUSH is read-only.");
19093 return 1;
19094 }
19095
19096
19097 static PyObject *_wrap_BLACK_BRUSH_get(void) {
19098 PyObject *pyobj;
19099
19100 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_BRUSH), SWIGTYPE_p_wxBrush, 0);
19101 return pyobj;
19102 }
19103
19104
19105 static int _wrap_TRANSPARENT_BRUSH_set(PyObject *) {
19106 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_BRUSH is read-only.");
19107 return 1;
19108 }
19109
19110
19111 static PyObject *_wrap_TRANSPARENT_BRUSH_get(void) {
19112 PyObject *pyobj;
19113
19114 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_BRUSH), SWIGTYPE_p_wxBrush, 0);
19115 return pyobj;
19116 }
19117
19118
19119 static int _wrap_CYAN_BRUSH_set(PyObject *) {
19120 PyErr_SetString(PyExc_TypeError,"Variable CYAN_BRUSH is read-only.");
19121 return 1;
19122 }
19123
19124
19125 static PyObject *_wrap_CYAN_BRUSH_get(void) {
19126 PyObject *pyobj;
19127
19128 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_BRUSH), SWIGTYPE_p_wxBrush, 0);
19129 return pyobj;
19130 }
19131
19132
19133 static int _wrap_RED_BRUSH_set(PyObject *) {
19134 PyErr_SetString(PyExc_TypeError,"Variable RED_BRUSH is read-only.");
19135 return 1;
19136 }
19137
19138
19139 static PyObject *_wrap_RED_BRUSH_get(void) {
19140 PyObject *pyobj;
19141
19142 pyobj = SWIG_NewPointerObj((void *)(wxRED_BRUSH), SWIGTYPE_p_wxBrush, 0);
19143 return pyobj;
19144 }
19145
19146
19147 static int _wrap_GREY_BRUSH_set(PyObject *) {
19148 PyErr_SetString(PyExc_TypeError,"Variable GREY_BRUSH is read-only.");
19149 return 1;
19150 }
19151
19152
19153 static PyObject *_wrap_GREY_BRUSH_get(void) {
19154 PyObject *pyobj;
19155
19156 pyobj = SWIG_NewPointerObj((void *)(wxGREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19157 return pyobj;
19158 }
19159
19160
19161 static int _wrap_MEDIUM_GREY_BRUSH_set(PyObject *) {
19162 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_BRUSH is read-only.");
19163 return 1;
19164 }
19165
19166
19167 static PyObject *_wrap_MEDIUM_GREY_BRUSH_get(void) {
19168 PyObject *pyobj;
19169
19170 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19171 return pyobj;
19172 }
19173
19174
19175 static int _wrap_LIGHT_GREY_BRUSH_set(PyObject *) {
19176 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_BRUSH is read-only.");
19177 return 1;
19178 }
19179
19180
19181 static PyObject *_wrap_LIGHT_GREY_BRUSH_get(void) {
19182 PyObject *pyobj;
19183
19184 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
19185 return pyobj;
19186 }
19187
19188
19189 static int _wrap_BLACK_set(PyObject *) {
19190 PyErr_SetString(PyExc_TypeError,"Variable BLACK is read-only.");
19191 return 1;
19192 }
19193
19194
19195 static PyObject *_wrap_BLACK_get(void) {
19196 PyObject *pyobj;
19197
19198 pyobj = SWIG_NewPointerObj((void *)(wxBLACK), SWIGTYPE_p_wxColour, 0);
19199 return pyobj;
19200 }
19201
19202
19203 static int _wrap_WHITE_set(PyObject *) {
19204 PyErr_SetString(PyExc_TypeError,"Variable WHITE is read-only.");
19205 return 1;
19206 }
19207
19208
19209 static PyObject *_wrap_WHITE_get(void) {
19210 PyObject *pyobj;
19211
19212 pyobj = SWIG_NewPointerObj((void *)(wxWHITE), SWIGTYPE_p_wxColour, 0);
19213 return pyobj;
19214 }
19215
19216
19217 static int _wrap_RED_set(PyObject *) {
19218 PyErr_SetString(PyExc_TypeError,"Variable RED is read-only.");
19219 return 1;
19220 }
19221
19222
19223 static PyObject *_wrap_RED_get(void) {
19224 PyObject *pyobj;
19225
19226 pyobj = SWIG_NewPointerObj((void *)(wxRED), SWIGTYPE_p_wxColour, 0);
19227 return pyobj;
19228 }
19229
19230
19231 static int _wrap_BLUE_set(PyObject *) {
19232 PyErr_SetString(PyExc_TypeError,"Variable BLUE is read-only.");
19233 return 1;
19234 }
19235
19236
19237 static PyObject *_wrap_BLUE_get(void) {
19238 PyObject *pyobj;
19239
19240 pyobj = SWIG_NewPointerObj((void *)(wxBLUE), SWIGTYPE_p_wxColour, 0);
19241 return pyobj;
19242 }
19243
19244
19245 static int _wrap_GREEN_set(PyObject *) {
19246 PyErr_SetString(PyExc_TypeError,"Variable GREEN is read-only.");
19247 return 1;
19248 }
19249
19250
19251 static PyObject *_wrap_GREEN_get(void) {
19252 PyObject *pyobj;
19253
19254 pyobj = SWIG_NewPointerObj((void *)(wxGREEN), SWIGTYPE_p_wxColour, 0);
19255 return pyobj;
19256 }
19257
19258
19259 static int _wrap_CYAN_set(PyObject *) {
19260 PyErr_SetString(PyExc_TypeError,"Variable CYAN is read-only.");
19261 return 1;
19262 }
19263
19264
19265 static PyObject *_wrap_CYAN_get(void) {
19266 PyObject *pyobj;
19267
19268 pyobj = SWIG_NewPointerObj((void *)(wxCYAN), SWIGTYPE_p_wxColour, 0);
19269 return pyobj;
19270 }
19271
19272
19273 static int _wrap_LIGHT_GREY_set(PyObject *) {
19274 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY is read-only.");
19275 return 1;
19276 }
19277
19278
19279 static PyObject *_wrap_LIGHT_GREY_get(void) {
19280 PyObject *pyobj;
19281
19282 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY), SWIGTYPE_p_wxColour, 0);
19283 return pyobj;
19284 }
19285
19286
19287 static int _wrap_STANDARD_CURSOR_set(PyObject *) {
19288 PyErr_SetString(PyExc_TypeError,"Variable STANDARD_CURSOR is read-only.");
19289 return 1;
19290 }
19291
19292
19293 static PyObject *_wrap_STANDARD_CURSOR_get(void) {
19294 PyObject *pyobj;
19295
19296 pyobj = SWIG_NewPointerObj((void *)(wxSTANDARD_CURSOR), SWIGTYPE_p_wxCursor, 0);
19297 return pyobj;
19298 }
19299
19300
19301 static int _wrap_HOURGLASS_CURSOR_set(PyObject *) {
19302 PyErr_SetString(PyExc_TypeError,"Variable HOURGLASS_CURSOR is read-only.");
19303 return 1;
19304 }
19305
19306
19307 static PyObject *_wrap_HOURGLASS_CURSOR_get(void) {
19308 PyObject *pyobj;
19309
19310 pyobj = SWIG_NewPointerObj((void *)(wxHOURGLASS_CURSOR), SWIGTYPE_p_wxCursor, 0);
19311 return pyobj;
19312 }
19313
19314
19315 static int _wrap_CROSS_CURSOR_set(PyObject *) {
19316 PyErr_SetString(PyExc_TypeError,"Variable CROSS_CURSOR is read-only.");
19317 return 1;
19318 }
19319
19320
19321 static PyObject *_wrap_CROSS_CURSOR_get(void) {
19322 PyObject *pyobj;
19323
19324 pyobj = SWIG_NewPointerObj((void *)(wxCROSS_CURSOR), SWIGTYPE_p_wxCursor, 0);
19325 return pyobj;
19326 }
19327
19328
19329 static int _wrap_NullBitmap_set(PyObject *) {
19330 PyErr_SetString(PyExc_TypeError,"Variable NullBitmap is read-only.");
19331 return 1;
19332 }
19333
19334
19335 static PyObject *_wrap_NullBitmap_get(void) {
19336 PyObject *pyobj;
19337
19338 pyobj = SWIG_NewPointerObj((void *)(&wxNullBitmap), SWIGTYPE_p_wxBitmap, 0);
19339 return pyobj;
19340 }
19341
19342
19343 static int _wrap_NullIcon_set(PyObject *) {
19344 PyErr_SetString(PyExc_TypeError,"Variable NullIcon is read-only.");
19345 return 1;
19346 }
19347
19348
19349 static PyObject *_wrap_NullIcon_get(void) {
19350 PyObject *pyobj;
19351
19352 pyobj = SWIG_NewPointerObj((void *)(&wxNullIcon), SWIGTYPE_p_wxIcon, 0);
19353 return pyobj;
19354 }
19355
19356
19357 static int _wrap_NullCursor_set(PyObject *) {
19358 PyErr_SetString(PyExc_TypeError,"Variable NullCursor is read-only.");
19359 return 1;
19360 }
19361
19362
19363 static PyObject *_wrap_NullCursor_get(void) {
19364 PyObject *pyobj;
19365
19366 pyobj = SWIG_NewPointerObj((void *)(&wxNullCursor), SWIGTYPE_p_wxCursor, 0);
19367 return pyobj;
19368 }
19369
19370
19371 static int _wrap_NullPen_set(PyObject *) {
19372 PyErr_SetString(PyExc_TypeError,"Variable NullPen is read-only.");
19373 return 1;
19374 }
19375
19376
19377 static PyObject *_wrap_NullPen_get(void) {
19378 PyObject *pyobj;
19379
19380 pyobj = SWIG_NewPointerObj((void *)(&wxNullPen), SWIGTYPE_p_wxPen, 0);
19381 return pyobj;
19382 }
19383
19384
19385 static int _wrap_NullBrush_set(PyObject *) {
19386 PyErr_SetString(PyExc_TypeError,"Variable NullBrush is read-only.");
19387 return 1;
19388 }
19389
19390
19391 static PyObject *_wrap_NullBrush_get(void) {
19392 PyObject *pyobj;
19393
19394 pyobj = SWIG_NewPointerObj((void *)(&wxNullBrush), SWIGTYPE_p_wxBrush, 0);
19395 return pyobj;
19396 }
19397
19398
19399 static int _wrap_NullPalette_set(PyObject *) {
19400 PyErr_SetString(PyExc_TypeError,"Variable NullPalette is read-only.");
19401 return 1;
19402 }
19403
19404
19405 static PyObject *_wrap_NullPalette_get(void) {
19406 PyObject *pyobj;
19407
19408 pyobj = SWIG_NewPointerObj((void *)(&wxNullPalette), SWIGTYPE_p_wxPalette, 0);
19409 return pyobj;
19410 }
19411
19412
19413 static int _wrap_NullFont_set(PyObject *) {
19414 PyErr_SetString(PyExc_TypeError,"Variable NullFont is read-only.");
19415 return 1;
19416 }
19417
19418
19419 static PyObject *_wrap_NullFont_get(void) {
19420 PyObject *pyobj;
19421
19422 pyobj = SWIG_NewPointerObj((void *)(&wxNullFont), SWIGTYPE_p_wxFont, 0);
19423 return pyobj;
19424 }
19425
19426
19427 static int _wrap_NullColour_set(PyObject *) {
19428 PyErr_SetString(PyExc_TypeError,"Variable NullColour is read-only.");
19429 return 1;
19430 }
19431
19432
19433 static PyObject *_wrap_NullColour_get(void) {
19434 PyObject *pyobj;
19435
19436 pyobj = SWIG_NewPointerObj((void *)(&wxNullColour), SWIGTYPE_p_wxColour, 0);
19437 return pyobj;
19438 }
19439
19440
19441 static PyObject *_wrap_PenList_AddPen(PyObject *, PyObject *args, PyObject *kwargs) {
19442 PyObject *resultobj;
19443 wxPenList *arg1 = (wxPenList *) 0 ;
19444 wxPen *arg2 = (wxPen *) 0 ;
19445 PyObject * obj0 = 0 ;
19446 PyObject * obj1 = 0 ;
19447 char *kwnames[] = {
19448 (char *) "self",(char *) "pen", NULL
19449 };
19450
19451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_AddPen",kwnames,&obj0,&obj1)) goto fail;
19452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19453 if (SWIG_arg_fail(1)) SWIG_fail;
19454 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
19455 if (SWIG_arg_fail(2)) SWIG_fail;
19456 {
19457 PyThreadState* __tstate = wxPyBeginAllowThreads();
19458 (arg1)->AddPen(arg2);
19459
19460 wxPyEndAllowThreads(__tstate);
19461 if (PyErr_Occurred()) SWIG_fail;
19462 }
19463 Py_INCREF(Py_None); resultobj = Py_None;
19464 return resultobj;
19465 fail:
19466 return NULL;
19467 }
19468
19469
19470 static PyObject *_wrap_PenList_FindOrCreatePen(PyObject *, PyObject *args, PyObject *kwargs) {
19471 PyObject *resultobj;
19472 wxPenList *arg1 = (wxPenList *) 0 ;
19473 wxColour *arg2 = 0 ;
19474 int arg3 ;
19475 int arg4 ;
19476 wxPen *result;
19477 wxColour temp2 ;
19478 PyObject * obj0 = 0 ;
19479 PyObject * obj1 = 0 ;
19480 PyObject * obj2 = 0 ;
19481 PyObject * obj3 = 0 ;
19482 char *kwnames[] = {
19483 (char *) "self",(char *) "colour",(char *) "width",(char *) "style", NULL
19484 };
19485
19486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PenList_FindOrCreatePen",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19488 if (SWIG_arg_fail(1)) SWIG_fail;
19489 {
19490 arg2 = &temp2;
19491 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19492 }
19493 {
19494 arg3 = (int)(SWIG_As_int(obj2));
19495 if (SWIG_arg_fail(3)) SWIG_fail;
19496 }
19497 {
19498 arg4 = (int)(SWIG_As_int(obj3));
19499 if (SWIG_arg_fail(4)) SWIG_fail;
19500 }
19501 {
19502 PyThreadState* __tstate = wxPyBeginAllowThreads();
19503 result = (wxPen *)(arg1)->FindOrCreatePen((wxColour const &)*arg2,arg3,arg4);
19504
19505 wxPyEndAllowThreads(__tstate);
19506 if (PyErr_Occurred()) SWIG_fail;
19507 }
19508 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 0);
19509 return resultobj;
19510 fail:
19511 return NULL;
19512 }
19513
19514
19515 static PyObject *_wrap_PenList_RemovePen(PyObject *, PyObject *args, PyObject *kwargs) {
19516 PyObject *resultobj;
19517 wxPenList *arg1 = (wxPenList *) 0 ;
19518 wxPen *arg2 = (wxPen *) 0 ;
19519 PyObject * obj0 = 0 ;
19520 PyObject * obj1 = 0 ;
19521 char *kwnames[] = {
19522 (char *) "self",(char *) "pen", NULL
19523 };
19524
19525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_RemovePen",kwnames,&obj0,&obj1)) goto fail;
19526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19527 if (SWIG_arg_fail(1)) SWIG_fail;
19528 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
19529 if (SWIG_arg_fail(2)) SWIG_fail;
19530 {
19531 PyThreadState* __tstate = wxPyBeginAllowThreads();
19532 (arg1)->RemovePen(arg2);
19533
19534 wxPyEndAllowThreads(__tstate);
19535 if (PyErr_Occurred()) SWIG_fail;
19536 }
19537 Py_INCREF(Py_None); resultobj = Py_None;
19538 return resultobj;
19539 fail:
19540 return NULL;
19541 }
19542
19543
19544 static PyObject *_wrap_PenList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
19545 PyObject *resultobj;
19546 wxPenList *arg1 = (wxPenList *) 0 ;
19547 int result;
19548 PyObject * obj0 = 0 ;
19549 char *kwnames[] = {
19550 (char *) "self", NULL
19551 };
19552
19553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PenList_GetCount",kwnames,&obj0)) goto fail;
19554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19555 if (SWIG_arg_fail(1)) SWIG_fail;
19556 {
19557 PyThreadState* __tstate = wxPyBeginAllowThreads();
19558 result = (int)(arg1)->GetCount();
19559
19560 wxPyEndAllowThreads(__tstate);
19561 if (PyErr_Occurred()) SWIG_fail;
19562 }
19563 {
19564 resultobj = SWIG_From_int((int)(result));
19565 }
19566 return resultobj;
19567 fail:
19568 return NULL;
19569 }
19570
19571
19572 static PyObject * PenList_swigregister(PyObject *, PyObject *args) {
19573 PyObject *obj;
19574 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19575 SWIG_TypeClientData(SWIGTYPE_p_wxPenList, obj);
19576 Py_INCREF(obj);
19577 return Py_BuildValue((char *)"");
19578 }
19579 static PyObject *_wrap_BrushList_AddBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19580 PyObject *resultobj;
19581 wxBrushList *arg1 = (wxBrushList *) 0 ;
19582 wxBrush *arg2 = (wxBrush *) 0 ;
19583 PyObject * obj0 = 0 ;
19584 PyObject * obj1 = 0 ;
19585 char *kwnames[] = {
19586 (char *) "self",(char *) "brush", NULL
19587 };
19588
19589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_AddBrush",kwnames,&obj0,&obj1)) goto fail;
19590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19591 if (SWIG_arg_fail(1)) SWIG_fail;
19592 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
19593 if (SWIG_arg_fail(2)) SWIG_fail;
19594 {
19595 PyThreadState* __tstate = wxPyBeginAllowThreads();
19596 (arg1)->AddBrush(arg2);
19597
19598 wxPyEndAllowThreads(__tstate);
19599 if (PyErr_Occurred()) SWIG_fail;
19600 }
19601 Py_INCREF(Py_None); resultobj = Py_None;
19602 return resultobj;
19603 fail:
19604 return NULL;
19605 }
19606
19607
19608 static PyObject *_wrap_BrushList_FindOrCreateBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19609 PyObject *resultobj;
19610 wxBrushList *arg1 = (wxBrushList *) 0 ;
19611 wxColour *arg2 = 0 ;
19612 int arg3 = (int) wxSOLID ;
19613 wxBrush *result;
19614 wxColour temp2 ;
19615 PyObject * obj0 = 0 ;
19616 PyObject * obj1 = 0 ;
19617 PyObject * obj2 = 0 ;
19618 char *kwnames[] = {
19619 (char *) "self",(char *) "colour",(char *) "style", NULL
19620 };
19621
19622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:BrushList_FindOrCreateBrush",kwnames,&obj0,&obj1,&obj2)) goto fail;
19623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19624 if (SWIG_arg_fail(1)) SWIG_fail;
19625 {
19626 arg2 = &temp2;
19627 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19628 }
19629 if (obj2) {
19630 {
19631 arg3 = (int)(SWIG_As_int(obj2));
19632 if (SWIG_arg_fail(3)) SWIG_fail;
19633 }
19634 }
19635 {
19636 PyThreadState* __tstate = wxPyBeginAllowThreads();
19637 result = (wxBrush *)(arg1)->FindOrCreateBrush((wxColour const &)*arg2,arg3);
19638
19639 wxPyEndAllowThreads(__tstate);
19640 if (PyErr_Occurred()) SWIG_fail;
19641 }
19642 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 0);
19643 return resultobj;
19644 fail:
19645 return NULL;
19646 }
19647
19648
19649 static PyObject *_wrap_BrushList_RemoveBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19650 PyObject *resultobj;
19651 wxBrushList *arg1 = (wxBrushList *) 0 ;
19652 wxBrush *arg2 = (wxBrush *) 0 ;
19653 PyObject * obj0 = 0 ;
19654 PyObject * obj1 = 0 ;
19655 char *kwnames[] = {
19656 (char *) "self",(char *) "brush", NULL
19657 };
19658
19659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_RemoveBrush",kwnames,&obj0,&obj1)) goto fail;
19660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19661 if (SWIG_arg_fail(1)) SWIG_fail;
19662 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
19663 if (SWIG_arg_fail(2)) SWIG_fail;
19664 {
19665 PyThreadState* __tstate = wxPyBeginAllowThreads();
19666 (arg1)->RemoveBrush(arg2);
19667
19668 wxPyEndAllowThreads(__tstate);
19669 if (PyErr_Occurred()) SWIG_fail;
19670 }
19671 Py_INCREF(Py_None); resultobj = Py_None;
19672 return resultobj;
19673 fail:
19674 return NULL;
19675 }
19676
19677
19678 static PyObject *_wrap_BrushList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
19679 PyObject *resultobj;
19680 wxBrushList *arg1 = (wxBrushList *) 0 ;
19681 int result;
19682 PyObject * obj0 = 0 ;
19683 char *kwnames[] = {
19684 (char *) "self", NULL
19685 };
19686
19687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BrushList_GetCount",kwnames,&obj0)) goto fail;
19688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19689 if (SWIG_arg_fail(1)) SWIG_fail;
19690 {
19691 PyThreadState* __tstate = wxPyBeginAllowThreads();
19692 result = (int)(arg1)->GetCount();
19693
19694 wxPyEndAllowThreads(__tstate);
19695 if (PyErr_Occurred()) SWIG_fail;
19696 }
19697 {
19698 resultobj = SWIG_From_int((int)(result));
19699 }
19700 return resultobj;
19701 fail:
19702 return NULL;
19703 }
19704
19705
19706 static PyObject * BrushList_swigregister(PyObject *, PyObject *args) {
19707 PyObject *obj;
19708 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19709 SWIG_TypeClientData(SWIGTYPE_p_wxBrushList, obj);
19710 Py_INCREF(obj);
19711 return Py_BuildValue((char *)"");
19712 }
19713 static PyObject *_wrap_new_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
19714 PyObject *resultobj;
19715 wxColourDatabase *result;
19716 char *kwnames[] = {
19717 NULL
19718 };
19719
19720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ColourDatabase",kwnames)) goto fail;
19721 {
19722 if (!wxPyCheckForApp()) SWIG_fail;
19723 PyThreadState* __tstate = wxPyBeginAllowThreads();
19724 result = (wxColourDatabase *)new wxColourDatabase();
19725
19726 wxPyEndAllowThreads(__tstate);
19727 if (PyErr_Occurred()) SWIG_fail;
19728 }
19729 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColourDatabase, 1);
19730 return resultobj;
19731 fail:
19732 return NULL;
19733 }
19734
19735
19736 static PyObject *_wrap_delete_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
19737 PyObject *resultobj;
19738 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19739 PyObject * obj0 = 0 ;
19740 char *kwnames[] = {
19741 (char *) "self", NULL
19742 };
19743
19744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ColourDatabase",kwnames,&obj0)) goto fail;
19745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19746 if (SWIG_arg_fail(1)) SWIG_fail;
19747 {
19748 PyThreadState* __tstate = wxPyBeginAllowThreads();
19749 delete arg1;
19750
19751 wxPyEndAllowThreads(__tstate);
19752 if (PyErr_Occurred()) SWIG_fail;
19753 }
19754 Py_INCREF(Py_None); resultobj = Py_None;
19755 return resultobj;
19756 fail:
19757 return NULL;
19758 }
19759
19760
19761 static PyObject *_wrap_ColourDatabase_Find(PyObject *, PyObject *args, PyObject *kwargs) {
19762 PyObject *resultobj;
19763 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19764 wxString *arg2 = 0 ;
19765 wxColour result;
19766 bool temp2 = false ;
19767 PyObject * obj0 = 0 ;
19768 PyObject * obj1 = 0 ;
19769 char *kwnames[] = {
19770 (char *) "self",(char *) "name", NULL
19771 };
19772
19773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_Find",kwnames,&obj0,&obj1)) goto fail;
19774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19775 if (SWIG_arg_fail(1)) SWIG_fail;
19776 {
19777 arg2 = wxString_in_helper(obj1);
19778 if (arg2 == NULL) SWIG_fail;
19779 temp2 = true;
19780 }
19781 {
19782 PyThreadState* __tstate = wxPyBeginAllowThreads();
19783 result = ((wxColourDatabase const *)arg1)->Find((wxString const &)*arg2);
19784
19785 wxPyEndAllowThreads(__tstate);
19786 if (PyErr_Occurred()) SWIG_fail;
19787 }
19788 {
19789 wxColour * resultptr;
19790 resultptr = new wxColour((wxColour &)(result));
19791 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
19792 }
19793 {
19794 if (temp2)
19795 delete arg2;
19796 }
19797 return resultobj;
19798 fail:
19799 {
19800 if (temp2)
19801 delete arg2;
19802 }
19803 return NULL;
19804 }
19805
19806
19807 static PyObject *_wrap_ColourDatabase_FindName(PyObject *, PyObject *args, PyObject *kwargs) {
19808 PyObject *resultobj;
19809 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19810 wxColour *arg2 = 0 ;
19811 wxString result;
19812 wxColour temp2 ;
19813 PyObject * obj0 = 0 ;
19814 PyObject * obj1 = 0 ;
19815 char *kwnames[] = {
19816 (char *) "self",(char *) "colour", NULL
19817 };
19818
19819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_FindName",kwnames,&obj0,&obj1)) goto fail;
19820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19821 if (SWIG_arg_fail(1)) SWIG_fail;
19822 {
19823 arg2 = &temp2;
19824 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19825 }
19826 {
19827 PyThreadState* __tstate = wxPyBeginAllowThreads();
19828 result = ((wxColourDatabase const *)arg1)->FindName((wxColour const &)*arg2);
19829
19830 wxPyEndAllowThreads(__tstate);
19831 if (PyErr_Occurred()) SWIG_fail;
19832 }
19833 {
19834 #if wxUSE_UNICODE
19835 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19836 #else
19837 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19838 #endif
19839 }
19840 return resultobj;
19841 fail:
19842 return NULL;
19843 }
19844
19845
19846 static PyObject *_wrap_ColourDatabase_AddColour(PyObject *, PyObject *args, PyObject *kwargs) {
19847 PyObject *resultobj;
19848 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19849 wxString *arg2 = 0 ;
19850 wxColour *arg3 = 0 ;
19851 bool temp2 = false ;
19852 wxColour temp3 ;
19853 PyObject * obj0 = 0 ;
19854 PyObject * obj1 = 0 ;
19855 PyObject * obj2 = 0 ;
19856 char *kwnames[] = {
19857 (char *) "self",(char *) "name",(char *) "colour", NULL
19858 };
19859
19860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ColourDatabase_AddColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
19861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19862 if (SWIG_arg_fail(1)) SWIG_fail;
19863 {
19864 arg2 = wxString_in_helper(obj1);
19865 if (arg2 == NULL) SWIG_fail;
19866 temp2 = true;
19867 }
19868 {
19869 arg3 = &temp3;
19870 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
19871 }
19872 {
19873 PyThreadState* __tstate = wxPyBeginAllowThreads();
19874 (arg1)->AddColour((wxString const &)*arg2,(wxColour const &)*arg3);
19875
19876 wxPyEndAllowThreads(__tstate);
19877 if (PyErr_Occurred()) SWIG_fail;
19878 }
19879 Py_INCREF(Py_None); resultobj = Py_None;
19880 {
19881 if (temp2)
19882 delete arg2;
19883 }
19884 return resultobj;
19885 fail:
19886 {
19887 if (temp2)
19888 delete arg2;
19889 }
19890 return NULL;
19891 }
19892
19893
19894 static PyObject *_wrap_ColourDatabase_Append(PyObject *, PyObject *args, PyObject *kwargs) {
19895 PyObject *resultobj;
19896 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19897 wxString *arg2 = 0 ;
19898 int arg3 ;
19899 int arg4 ;
19900 int arg5 ;
19901 bool temp2 = false ;
19902 PyObject * obj0 = 0 ;
19903 PyObject * obj1 = 0 ;
19904 PyObject * obj2 = 0 ;
19905 PyObject * obj3 = 0 ;
19906 PyObject * obj4 = 0 ;
19907 char *kwnames[] = {
19908 (char *) "self",(char *) "name",(char *) "red",(char *) "green",(char *) "blue", NULL
19909 };
19910
19911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:ColourDatabase_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19913 if (SWIG_arg_fail(1)) SWIG_fail;
19914 {
19915 arg2 = wxString_in_helper(obj1);
19916 if (arg2 == NULL) SWIG_fail;
19917 temp2 = true;
19918 }
19919 {
19920 arg3 = (int)(SWIG_As_int(obj2));
19921 if (SWIG_arg_fail(3)) SWIG_fail;
19922 }
19923 {
19924 arg4 = (int)(SWIG_As_int(obj3));
19925 if (SWIG_arg_fail(4)) SWIG_fail;
19926 }
19927 {
19928 arg5 = (int)(SWIG_As_int(obj4));
19929 if (SWIG_arg_fail(5)) SWIG_fail;
19930 }
19931 {
19932 PyThreadState* __tstate = wxPyBeginAllowThreads();
19933 wxColourDatabase_Append(arg1,(wxString const &)*arg2,arg3,arg4,arg5);
19934
19935 wxPyEndAllowThreads(__tstate);
19936 if (PyErr_Occurred()) SWIG_fail;
19937 }
19938 Py_INCREF(Py_None); resultobj = Py_None;
19939 {
19940 if (temp2)
19941 delete arg2;
19942 }
19943 return resultobj;
19944 fail:
19945 {
19946 if (temp2)
19947 delete arg2;
19948 }
19949 return NULL;
19950 }
19951
19952
19953 static PyObject * ColourDatabase_swigregister(PyObject *, PyObject *args) {
19954 PyObject *obj;
19955 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19956 SWIG_TypeClientData(SWIGTYPE_p_wxColourDatabase, obj);
19957 Py_INCREF(obj);
19958 return Py_BuildValue((char *)"");
19959 }
19960 static PyObject *_wrap_FontList_AddFont(PyObject *, PyObject *args, PyObject *kwargs) {
19961 PyObject *resultobj;
19962 wxFontList *arg1 = (wxFontList *) 0 ;
19963 wxFont *arg2 = (wxFont *) 0 ;
19964 PyObject * obj0 = 0 ;
19965 PyObject * obj1 = 0 ;
19966 char *kwnames[] = {
19967 (char *) "self",(char *) "font", NULL
19968 };
19969
19970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_AddFont",kwnames,&obj0,&obj1)) goto fail;
19971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
19972 if (SWIG_arg_fail(1)) SWIG_fail;
19973 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
19974 if (SWIG_arg_fail(2)) SWIG_fail;
19975 {
19976 PyThreadState* __tstate = wxPyBeginAllowThreads();
19977 (arg1)->AddFont(arg2);
19978
19979 wxPyEndAllowThreads(__tstate);
19980 if (PyErr_Occurred()) SWIG_fail;
19981 }
19982 Py_INCREF(Py_None); resultobj = Py_None;
19983 return resultobj;
19984 fail:
19985 return NULL;
19986 }
19987
19988
19989 static PyObject *_wrap_FontList_FindOrCreateFont(PyObject *, PyObject *args, PyObject *kwargs) {
19990 PyObject *resultobj;
19991 wxFontList *arg1 = (wxFontList *) 0 ;
19992 int arg2 ;
19993 int arg3 ;
19994 int arg4 ;
19995 int arg5 ;
19996 bool arg6 = (bool) false ;
19997 wxString const &arg7_defvalue = wxPyEmptyString ;
19998 wxString *arg7 = (wxString *) &arg7_defvalue ;
19999 wxFontEncoding arg8 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
20000 wxFont *result;
20001 bool temp7 = false ;
20002 PyObject * obj0 = 0 ;
20003 PyObject * obj1 = 0 ;
20004 PyObject * obj2 = 0 ;
20005 PyObject * obj3 = 0 ;
20006 PyObject * obj4 = 0 ;
20007 PyObject * obj5 = 0 ;
20008 PyObject * obj6 = 0 ;
20009 PyObject * obj7 = 0 ;
20010 char *kwnames[] = {
20011 (char *) "self",(char *) "point_size",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "facename",(char *) "encoding", NULL
20012 };
20013
20014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:FontList_FindOrCreateFont",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
20015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20016 if (SWIG_arg_fail(1)) SWIG_fail;
20017 {
20018 arg2 = (int)(SWIG_As_int(obj1));
20019 if (SWIG_arg_fail(2)) SWIG_fail;
20020 }
20021 {
20022 arg3 = (int)(SWIG_As_int(obj2));
20023 if (SWIG_arg_fail(3)) SWIG_fail;
20024 }
20025 {
20026 arg4 = (int)(SWIG_As_int(obj3));
20027 if (SWIG_arg_fail(4)) SWIG_fail;
20028 }
20029 {
20030 arg5 = (int)(SWIG_As_int(obj4));
20031 if (SWIG_arg_fail(5)) SWIG_fail;
20032 }
20033 if (obj5) {
20034 {
20035 arg6 = (bool)(SWIG_As_bool(obj5));
20036 if (SWIG_arg_fail(6)) SWIG_fail;
20037 }
20038 }
20039 if (obj6) {
20040 {
20041 arg7 = wxString_in_helper(obj6);
20042 if (arg7 == NULL) SWIG_fail;
20043 temp7 = true;
20044 }
20045 }
20046 if (obj7) {
20047 {
20048 arg8 = (wxFontEncoding)(SWIG_As_int(obj7));
20049 if (SWIG_arg_fail(8)) SWIG_fail;
20050 }
20051 }
20052 {
20053 PyThreadState* __tstate = wxPyBeginAllowThreads();
20054 result = (wxFont *)(arg1)->FindOrCreateFont(arg2,arg3,arg4,arg5,arg6,(wxString const &)*arg7,(wxFontEncoding )arg8);
20055
20056 wxPyEndAllowThreads(__tstate);
20057 if (PyErr_Occurred()) SWIG_fail;
20058 }
20059 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
20060 {
20061 if (temp7)
20062 delete arg7;
20063 }
20064 return resultobj;
20065 fail:
20066 {
20067 if (temp7)
20068 delete arg7;
20069 }
20070 return NULL;
20071 }
20072
20073
20074 static PyObject *_wrap_FontList_RemoveFont(PyObject *, PyObject *args, PyObject *kwargs) {
20075 PyObject *resultobj;
20076 wxFontList *arg1 = (wxFontList *) 0 ;
20077 wxFont *arg2 = (wxFont *) 0 ;
20078 PyObject * obj0 = 0 ;
20079 PyObject * obj1 = 0 ;
20080 char *kwnames[] = {
20081 (char *) "self",(char *) "font", NULL
20082 };
20083
20084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_RemoveFont",kwnames,&obj0,&obj1)) goto fail;
20085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20086 if (SWIG_arg_fail(1)) SWIG_fail;
20087 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
20088 if (SWIG_arg_fail(2)) SWIG_fail;
20089 {
20090 PyThreadState* __tstate = wxPyBeginAllowThreads();
20091 (arg1)->RemoveFont(arg2);
20092
20093 wxPyEndAllowThreads(__tstate);
20094 if (PyErr_Occurred()) SWIG_fail;
20095 }
20096 Py_INCREF(Py_None); resultobj = Py_None;
20097 return resultobj;
20098 fail:
20099 return NULL;
20100 }
20101
20102
20103 static PyObject *_wrap_FontList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
20104 PyObject *resultobj;
20105 wxFontList *arg1 = (wxFontList *) 0 ;
20106 int result;
20107 PyObject * obj0 = 0 ;
20108 char *kwnames[] = {
20109 (char *) "self", NULL
20110 };
20111
20112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontList_GetCount",kwnames,&obj0)) goto fail;
20113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
20114 if (SWIG_arg_fail(1)) SWIG_fail;
20115 {
20116 PyThreadState* __tstate = wxPyBeginAllowThreads();
20117 result = (int)(arg1)->GetCount();
20118
20119 wxPyEndAllowThreads(__tstate);
20120 if (PyErr_Occurred()) SWIG_fail;
20121 }
20122 {
20123 resultobj = SWIG_From_int((int)(result));
20124 }
20125 return resultobj;
20126 fail:
20127 return NULL;
20128 }
20129
20130
20131 static PyObject * FontList_swigregister(PyObject *, PyObject *args) {
20132 PyObject *obj;
20133 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20134 SWIG_TypeClientData(SWIGTYPE_p_wxFontList, obj);
20135 Py_INCREF(obj);
20136 return Py_BuildValue((char *)"");
20137 }
20138 static int _wrap_TheFontList_set(PyObject *) {
20139 PyErr_SetString(PyExc_TypeError,"Variable TheFontList is read-only.");
20140 return 1;
20141 }
20142
20143
20144 static PyObject *_wrap_TheFontList_get(void) {
20145 PyObject *pyobj;
20146
20147 pyobj = SWIG_NewPointerObj((void *)(wxTheFontList), SWIGTYPE_p_wxFontList, 0);
20148 return pyobj;
20149 }
20150
20151
20152 static int _wrap_ThePenList_set(PyObject *) {
20153 PyErr_SetString(PyExc_TypeError,"Variable ThePenList is read-only.");
20154 return 1;
20155 }
20156
20157
20158 static PyObject *_wrap_ThePenList_get(void) {
20159 PyObject *pyobj;
20160
20161 pyobj = SWIG_NewPointerObj((void *)(wxThePenList), SWIGTYPE_p_wxPenList, 0);
20162 return pyobj;
20163 }
20164
20165
20166 static int _wrap_TheBrushList_set(PyObject *) {
20167 PyErr_SetString(PyExc_TypeError,"Variable TheBrushList is read-only.");
20168 return 1;
20169 }
20170
20171
20172 static PyObject *_wrap_TheBrushList_get(void) {
20173 PyObject *pyobj;
20174
20175 pyobj = SWIG_NewPointerObj((void *)(wxTheBrushList), SWIGTYPE_p_wxBrushList, 0);
20176 return pyobj;
20177 }
20178
20179
20180 static int _wrap_TheColourDatabase_set(PyObject *) {
20181 PyErr_SetString(PyExc_TypeError,"Variable TheColourDatabase is read-only.");
20182 return 1;
20183 }
20184
20185
20186 static PyObject *_wrap_TheColourDatabase_get(void) {
20187 PyObject *pyobj;
20188
20189 pyobj = SWIG_NewPointerObj((void *)(wxTheColourDatabase), SWIGTYPE_p_wxColourDatabase, 0);
20190 return pyobj;
20191 }
20192
20193
20194 static PyObject *_wrap_new_Effects(PyObject *, PyObject *args, PyObject *kwargs) {
20195 PyObject *resultobj;
20196 wxEffects *result;
20197 char *kwnames[] = {
20198 NULL
20199 };
20200
20201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Effects",kwnames)) goto fail;
20202 {
20203 PyThreadState* __tstate = wxPyBeginAllowThreads();
20204 result = (wxEffects *)new wxEffects();
20205
20206 wxPyEndAllowThreads(__tstate);
20207 if (PyErr_Occurred()) SWIG_fail;
20208 }
20209 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEffects, 1);
20210 return resultobj;
20211 fail:
20212 return NULL;
20213 }
20214
20215
20216 static PyObject *_wrap_Effects_GetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
20217 PyObject *resultobj;
20218 wxEffects *arg1 = (wxEffects *) 0 ;
20219 wxColour result;
20220 PyObject * obj0 = 0 ;
20221 char *kwnames[] = {
20222 (char *) "self", NULL
20223 };
20224
20225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetHighlightColour",kwnames,&obj0)) goto fail;
20226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20227 if (SWIG_arg_fail(1)) SWIG_fail;
20228 {
20229 PyThreadState* __tstate = wxPyBeginAllowThreads();
20230 result = ((wxEffects const *)arg1)->GetHighlightColour();
20231
20232 wxPyEndAllowThreads(__tstate);
20233 if (PyErr_Occurred()) SWIG_fail;
20234 }
20235 {
20236 wxColour * resultptr;
20237 resultptr = new wxColour((wxColour &)(result));
20238 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20239 }
20240 return resultobj;
20241 fail:
20242 return NULL;
20243 }
20244
20245
20246 static PyObject *_wrap_Effects_GetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20247 PyObject *resultobj;
20248 wxEffects *arg1 = (wxEffects *) 0 ;
20249 wxColour result;
20250 PyObject * obj0 = 0 ;
20251 char *kwnames[] = {
20252 (char *) "self", NULL
20253 };
20254
20255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetLightShadow",kwnames,&obj0)) goto fail;
20256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20257 if (SWIG_arg_fail(1)) SWIG_fail;
20258 {
20259 PyThreadState* __tstate = wxPyBeginAllowThreads();
20260 result = ((wxEffects const *)arg1)->GetLightShadow();
20261
20262 wxPyEndAllowThreads(__tstate);
20263 if (PyErr_Occurred()) SWIG_fail;
20264 }
20265 {
20266 wxColour * resultptr;
20267 resultptr = new wxColour((wxColour &)(result));
20268 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20269 }
20270 return resultobj;
20271 fail:
20272 return NULL;
20273 }
20274
20275
20276 static PyObject *_wrap_Effects_GetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
20277 PyObject *resultobj;
20278 wxEffects *arg1 = (wxEffects *) 0 ;
20279 wxColour result;
20280 PyObject * obj0 = 0 ;
20281 char *kwnames[] = {
20282 (char *) "self", NULL
20283 };
20284
20285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetFaceColour",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
20290 result = ((wxEffects const *)arg1)->GetFaceColour();
20291
20292 wxPyEndAllowThreads(__tstate);
20293 if (PyErr_Occurred()) SWIG_fail;
20294 }
20295 {
20296 wxColour * resultptr;
20297 resultptr = new wxColour((wxColour &)(result));
20298 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20299 }
20300 return resultobj;
20301 fail:
20302 return NULL;
20303 }
20304
20305
20306 static PyObject *_wrap_Effects_GetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20307 PyObject *resultobj;
20308 wxEffects *arg1 = (wxEffects *) 0 ;
20309 wxColour result;
20310 PyObject * obj0 = 0 ;
20311 char *kwnames[] = {
20312 (char *) "self", NULL
20313 };
20314
20315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetMediumShadow",kwnames,&obj0)) goto fail;
20316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20317 if (SWIG_arg_fail(1)) SWIG_fail;
20318 {
20319 PyThreadState* __tstate = wxPyBeginAllowThreads();
20320 result = ((wxEffects const *)arg1)->GetMediumShadow();
20321
20322 wxPyEndAllowThreads(__tstate);
20323 if (PyErr_Occurred()) SWIG_fail;
20324 }
20325 {
20326 wxColour * resultptr;
20327 resultptr = new wxColour((wxColour &)(result));
20328 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20329 }
20330 return resultobj;
20331 fail:
20332 return NULL;
20333 }
20334
20335
20336 static PyObject *_wrap_Effects_GetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20337 PyObject *resultobj;
20338 wxEffects *arg1 = (wxEffects *) 0 ;
20339 wxColour result;
20340 PyObject * obj0 = 0 ;
20341 char *kwnames[] = {
20342 (char *) "self", NULL
20343 };
20344
20345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetDarkShadow",kwnames,&obj0)) goto fail;
20346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20347 if (SWIG_arg_fail(1)) SWIG_fail;
20348 {
20349 PyThreadState* __tstate = wxPyBeginAllowThreads();
20350 result = ((wxEffects const *)arg1)->GetDarkShadow();
20351
20352 wxPyEndAllowThreads(__tstate);
20353 if (PyErr_Occurred()) SWIG_fail;
20354 }
20355 {
20356 wxColour * resultptr;
20357 resultptr = new wxColour((wxColour &)(result));
20358 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20359 }
20360 return resultobj;
20361 fail:
20362 return NULL;
20363 }
20364
20365
20366 static PyObject *_wrap_Effects_SetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
20367 PyObject *resultobj;
20368 wxEffects *arg1 = (wxEffects *) 0 ;
20369 wxColour *arg2 = 0 ;
20370 wxColour temp2 ;
20371 PyObject * obj0 = 0 ;
20372 PyObject * obj1 = 0 ;
20373 char *kwnames[] = {
20374 (char *) "self",(char *) "c", NULL
20375 };
20376
20377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetHighlightColour",kwnames,&obj0,&obj1)) goto fail;
20378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20379 if (SWIG_arg_fail(1)) SWIG_fail;
20380 {
20381 arg2 = &temp2;
20382 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20383 }
20384 {
20385 PyThreadState* __tstate = wxPyBeginAllowThreads();
20386 (arg1)->SetHighlightColour((wxColour const &)*arg2);
20387
20388 wxPyEndAllowThreads(__tstate);
20389 if (PyErr_Occurred()) SWIG_fail;
20390 }
20391 Py_INCREF(Py_None); resultobj = Py_None;
20392 return resultobj;
20393 fail:
20394 return NULL;
20395 }
20396
20397
20398 static PyObject *_wrap_Effects_SetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20399 PyObject *resultobj;
20400 wxEffects *arg1 = (wxEffects *) 0 ;
20401 wxColour *arg2 = 0 ;
20402 wxColour temp2 ;
20403 PyObject * obj0 = 0 ;
20404 PyObject * obj1 = 0 ;
20405 char *kwnames[] = {
20406 (char *) "self",(char *) "c", NULL
20407 };
20408
20409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetLightShadow",kwnames,&obj0,&obj1)) goto fail;
20410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20411 if (SWIG_arg_fail(1)) SWIG_fail;
20412 {
20413 arg2 = &temp2;
20414 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20415 }
20416 {
20417 PyThreadState* __tstate = wxPyBeginAllowThreads();
20418 (arg1)->SetLightShadow((wxColour const &)*arg2);
20419
20420 wxPyEndAllowThreads(__tstate);
20421 if (PyErr_Occurred()) SWIG_fail;
20422 }
20423 Py_INCREF(Py_None); resultobj = Py_None;
20424 return resultobj;
20425 fail:
20426 return NULL;
20427 }
20428
20429
20430 static PyObject *_wrap_Effects_SetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
20431 PyObject *resultobj;
20432 wxEffects *arg1 = (wxEffects *) 0 ;
20433 wxColour *arg2 = 0 ;
20434 wxColour temp2 ;
20435 PyObject * obj0 = 0 ;
20436 PyObject * obj1 = 0 ;
20437 char *kwnames[] = {
20438 (char *) "self",(char *) "c", NULL
20439 };
20440
20441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetFaceColour",kwnames,&obj0,&obj1)) goto fail;
20442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20443 if (SWIG_arg_fail(1)) SWIG_fail;
20444 {
20445 arg2 = &temp2;
20446 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20447 }
20448 {
20449 PyThreadState* __tstate = wxPyBeginAllowThreads();
20450 (arg1)->SetFaceColour((wxColour const &)*arg2);
20451
20452 wxPyEndAllowThreads(__tstate);
20453 if (PyErr_Occurred()) SWIG_fail;
20454 }
20455 Py_INCREF(Py_None); resultobj = Py_None;
20456 return resultobj;
20457 fail:
20458 return NULL;
20459 }
20460
20461
20462 static PyObject *_wrap_Effects_SetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20463 PyObject *resultobj;
20464 wxEffects *arg1 = (wxEffects *) 0 ;
20465 wxColour *arg2 = 0 ;
20466 wxColour temp2 ;
20467 PyObject * obj0 = 0 ;
20468 PyObject * obj1 = 0 ;
20469 char *kwnames[] = {
20470 (char *) "self",(char *) "c", NULL
20471 };
20472
20473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetMediumShadow",kwnames,&obj0,&obj1)) goto fail;
20474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20475 if (SWIG_arg_fail(1)) SWIG_fail;
20476 {
20477 arg2 = &temp2;
20478 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20479 }
20480 {
20481 PyThreadState* __tstate = wxPyBeginAllowThreads();
20482 (arg1)->SetMediumShadow((wxColour const &)*arg2);
20483
20484 wxPyEndAllowThreads(__tstate);
20485 if (PyErr_Occurred()) SWIG_fail;
20486 }
20487 Py_INCREF(Py_None); resultobj = Py_None;
20488 return resultobj;
20489 fail:
20490 return NULL;
20491 }
20492
20493
20494 static PyObject *_wrap_Effects_SetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20495 PyObject *resultobj;
20496 wxEffects *arg1 = (wxEffects *) 0 ;
20497 wxColour *arg2 = 0 ;
20498 wxColour temp2 ;
20499 PyObject * obj0 = 0 ;
20500 PyObject * obj1 = 0 ;
20501 char *kwnames[] = {
20502 (char *) "self",(char *) "c", NULL
20503 };
20504
20505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetDarkShadow",kwnames,&obj0,&obj1)) goto fail;
20506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20507 if (SWIG_arg_fail(1)) SWIG_fail;
20508 {
20509 arg2 = &temp2;
20510 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20511 }
20512 {
20513 PyThreadState* __tstate = wxPyBeginAllowThreads();
20514 (arg1)->SetDarkShadow((wxColour const &)*arg2);
20515
20516 wxPyEndAllowThreads(__tstate);
20517 if (PyErr_Occurred()) SWIG_fail;
20518 }
20519 Py_INCREF(Py_None); resultobj = Py_None;
20520 return resultobj;
20521 fail:
20522 return NULL;
20523 }
20524
20525
20526 static PyObject *_wrap_Effects_Set(PyObject *, PyObject *args, PyObject *kwargs) {
20527 PyObject *resultobj;
20528 wxEffects *arg1 = (wxEffects *) 0 ;
20529 wxColour *arg2 = 0 ;
20530 wxColour *arg3 = 0 ;
20531 wxColour *arg4 = 0 ;
20532 wxColour *arg5 = 0 ;
20533 wxColour *arg6 = 0 ;
20534 wxColour temp2 ;
20535 wxColour temp3 ;
20536 wxColour temp4 ;
20537 wxColour temp5 ;
20538 wxColour temp6 ;
20539 PyObject * obj0 = 0 ;
20540 PyObject * obj1 = 0 ;
20541 PyObject * obj2 = 0 ;
20542 PyObject * obj3 = 0 ;
20543 PyObject * obj4 = 0 ;
20544 PyObject * obj5 = 0 ;
20545 char *kwnames[] = {
20546 (char *) "self",(char *) "highlightColour",(char *) "lightShadow",(char *) "faceColour",(char *) "mediumShadow",(char *) "darkShadow", NULL
20547 };
20548
20549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Effects_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
20550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20551 if (SWIG_arg_fail(1)) SWIG_fail;
20552 {
20553 arg2 = &temp2;
20554 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20555 }
20556 {
20557 arg3 = &temp3;
20558 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
20559 }
20560 {
20561 arg4 = &temp4;
20562 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
20563 }
20564 {
20565 arg5 = &temp5;
20566 if ( ! wxColour_helper(obj4, &arg5)) SWIG_fail;
20567 }
20568 {
20569 arg6 = &temp6;
20570 if ( ! wxColour_helper(obj5, &arg6)) SWIG_fail;
20571 }
20572 {
20573 PyThreadState* __tstate = wxPyBeginAllowThreads();
20574 (arg1)->Set((wxColour const &)*arg2,(wxColour const &)*arg3,(wxColour const &)*arg4,(wxColour const &)*arg5,(wxColour const &)*arg6);
20575
20576 wxPyEndAllowThreads(__tstate);
20577 if (PyErr_Occurred()) SWIG_fail;
20578 }
20579 Py_INCREF(Py_None); resultobj = Py_None;
20580 return resultobj;
20581 fail:
20582 return NULL;
20583 }
20584
20585
20586 static PyObject *_wrap_Effects_DrawSunkenEdge(PyObject *, PyObject *args, PyObject *kwargs) {
20587 PyObject *resultobj;
20588 wxEffects *arg1 = (wxEffects *) 0 ;
20589 wxDC *arg2 = 0 ;
20590 wxRect *arg3 = 0 ;
20591 int arg4 = (int) 1 ;
20592 wxRect temp3 ;
20593 PyObject * obj0 = 0 ;
20594 PyObject * obj1 = 0 ;
20595 PyObject * obj2 = 0 ;
20596 PyObject * obj3 = 0 ;
20597 char *kwnames[] = {
20598 (char *) "self",(char *) "dc",(char *) "rect",(char *) "borderSize", NULL
20599 };
20600
20601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Effects_DrawSunkenEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20603 if (SWIG_arg_fail(1)) SWIG_fail;
20604 {
20605 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20606 if (SWIG_arg_fail(2)) SWIG_fail;
20607 if (arg2 == NULL) {
20608 SWIG_null_ref("wxDC");
20609 }
20610 if (SWIG_arg_fail(2)) SWIG_fail;
20611 }
20612 {
20613 arg3 = &temp3;
20614 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
20615 }
20616 if (obj3) {
20617 {
20618 arg4 = (int)(SWIG_As_int(obj3));
20619 if (SWIG_arg_fail(4)) SWIG_fail;
20620 }
20621 }
20622 {
20623 PyThreadState* __tstate = wxPyBeginAllowThreads();
20624 (arg1)->DrawSunkenEdge(*arg2,(wxRect const &)*arg3,arg4);
20625
20626 wxPyEndAllowThreads(__tstate);
20627 if (PyErr_Occurred()) SWIG_fail;
20628 }
20629 Py_INCREF(Py_None); resultobj = Py_None;
20630 return resultobj;
20631 fail:
20632 return NULL;
20633 }
20634
20635
20636 static PyObject *_wrap_Effects_TileBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
20637 PyObject *resultobj;
20638 wxEffects *arg1 = (wxEffects *) 0 ;
20639 wxRect *arg2 = 0 ;
20640 wxDC *arg3 = 0 ;
20641 wxBitmap *arg4 = 0 ;
20642 bool result;
20643 wxRect temp2 ;
20644 PyObject * obj0 = 0 ;
20645 PyObject * obj1 = 0 ;
20646 PyObject * obj2 = 0 ;
20647 PyObject * obj3 = 0 ;
20648 char *kwnames[] = {
20649 (char *) "self",(char *) "rect",(char *) "dc",(char *) "bitmap", NULL
20650 };
20651
20652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Effects_TileBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20654 if (SWIG_arg_fail(1)) SWIG_fail;
20655 {
20656 arg2 = &temp2;
20657 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
20658 }
20659 {
20660 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20661 if (SWIG_arg_fail(3)) SWIG_fail;
20662 if (arg3 == NULL) {
20663 SWIG_null_ref("wxDC");
20664 }
20665 if (SWIG_arg_fail(3)) SWIG_fail;
20666 }
20667 {
20668 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
20669 if (SWIG_arg_fail(4)) SWIG_fail;
20670 if (arg4 == NULL) {
20671 SWIG_null_ref("wxBitmap");
20672 }
20673 if (SWIG_arg_fail(4)) SWIG_fail;
20674 }
20675 {
20676 PyThreadState* __tstate = wxPyBeginAllowThreads();
20677 result = (bool)(arg1)->TileBitmap((wxRect const &)*arg2,*arg3,*arg4);
20678
20679 wxPyEndAllowThreads(__tstate);
20680 if (PyErr_Occurred()) SWIG_fail;
20681 }
20682 {
20683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20684 }
20685 return resultobj;
20686 fail:
20687 return NULL;
20688 }
20689
20690
20691 static PyObject * Effects_swigregister(PyObject *, PyObject *args) {
20692 PyObject *obj;
20693 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20694 SWIG_TypeClientData(SWIGTYPE_p_wxEffects, obj);
20695 Py_INCREF(obj);
20696 return Py_BuildValue((char *)"");
20697 }
20698 static PyMethodDef SwigMethods[] = {
20699 { (char *)"new_GDIObject", (PyCFunction) _wrap_new_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
20700 { (char *)"delete_GDIObject", (PyCFunction) _wrap_delete_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
20701 { (char *)"GDIObject_GetVisible", (PyCFunction) _wrap_GDIObject_GetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20702 { (char *)"GDIObject_SetVisible", (PyCFunction) _wrap_GDIObject_SetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20703 { (char *)"GDIObject_IsNull", (PyCFunction) _wrap_GDIObject_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
20704 { (char *)"GDIObject_swigregister", GDIObject_swigregister, METH_VARARGS, NULL},
20705 { (char *)"new_Colour", (PyCFunction) _wrap_new_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
20706 { (char *)"new_NamedColour", (PyCFunction) _wrap_new_NamedColour, METH_VARARGS | METH_KEYWORDS, NULL},
20707 { (char *)"new_ColourRGB", (PyCFunction) _wrap_new_ColourRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20708 { (char *)"delete_Colour", (PyCFunction) _wrap_delete_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
20709 { (char *)"Colour_Red", (PyCFunction) _wrap_Colour_Red, METH_VARARGS | METH_KEYWORDS, NULL},
20710 { (char *)"Colour_Green", (PyCFunction) _wrap_Colour_Green, METH_VARARGS | METH_KEYWORDS, NULL},
20711 { (char *)"Colour_Blue", (PyCFunction) _wrap_Colour_Blue, METH_VARARGS | METH_KEYWORDS, NULL},
20712 { (char *)"Colour_Ok", (PyCFunction) _wrap_Colour_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20713 { (char *)"Colour_Set", (PyCFunction) _wrap_Colour_Set, METH_VARARGS | METH_KEYWORDS, NULL},
20714 { (char *)"Colour_SetRGB", (PyCFunction) _wrap_Colour_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20715 { (char *)"Colour_SetFromName", (PyCFunction) _wrap_Colour_SetFromName, METH_VARARGS | METH_KEYWORDS, NULL},
20716 { (char *)"Colour_GetPixel", (PyCFunction) _wrap_Colour_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
20717 { (char *)"Colour___eq__", (PyCFunction) _wrap_Colour___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20718 { (char *)"Colour___ne__", (PyCFunction) _wrap_Colour___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20719 { (char *)"Colour_Get", (PyCFunction) _wrap_Colour_Get, METH_VARARGS | METH_KEYWORDS, NULL},
20720 { (char *)"Colour_GetRGB", (PyCFunction) _wrap_Colour_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20721 { (char *)"Colour_swigregister", Colour_swigregister, METH_VARARGS, NULL},
20722 { (char *)"new_Palette", (PyCFunction) _wrap_new_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
20723 { (char *)"delete_Palette", (PyCFunction) _wrap_delete_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
20724 { (char *)"Palette_GetPixel", (PyCFunction) _wrap_Palette_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
20725 { (char *)"Palette_GetRGB", (PyCFunction) _wrap_Palette_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20726 { (char *)"Palette_GetColoursCount", (PyCFunction) _wrap_Palette_GetColoursCount, METH_VARARGS | METH_KEYWORDS, NULL},
20727 { (char *)"Palette_Ok", (PyCFunction) _wrap_Palette_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20728 { (char *)"Palette_swigregister", Palette_swigregister, METH_VARARGS, NULL},
20729 { (char *)"new_Pen", (PyCFunction) _wrap_new_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
20730 { (char *)"delete_Pen", (PyCFunction) _wrap_delete_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
20731 { (char *)"Pen_GetCap", (PyCFunction) _wrap_Pen_GetCap, METH_VARARGS | METH_KEYWORDS, NULL},
20732 { (char *)"Pen_GetColour", (PyCFunction) _wrap_Pen_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20733 { (char *)"Pen_GetJoin", (PyCFunction) _wrap_Pen_GetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
20734 { (char *)"Pen_GetStyle", (PyCFunction) _wrap_Pen_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20735 { (char *)"Pen_GetWidth", (PyCFunction) _wrap_Pen_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20736 { (char *)"Pen_Ok", (PyCFunction) _wrap_Pen_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20737 { (char *)"Pen_SetCap", (PyCFunction) _wrap_Pen_SetCap, METH_VARARGS | METH_KEYWORDS, NULL},
20738 { (char *)"Pen_SetColour", (PyCFunction) _wrap_Pen_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20739 { (char *)"Pen_SetJoin", (PyCFunction) _wrap_Pen_SetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
20740 { (char *)"Pen_SetStyle", (PyCFunction) _wrap_Pen_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20741 { (char *)"Pen_SetWidth", (PyCFunction) _wrap_Pen_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20742 { (char *)"Pen_SetDashes", (PyCFunction) _wrap_Pen_SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
20743 { (char *)"Pen_GetDashes", (PyCFunction) _wrap_Pen_GetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
20744 { (char *)"Pen__SetDashes", (PyCFunction) _wrap_Pen__SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
20745 { (char *)"Pen___eq__", (PyCFunction) _wrap_Pen___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20746 { (char *)"Pen___ne__", (PyCFunction) _wrap_Pen___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20747 { (char *)"Pen_swigregister", Pen_swigregister, METH_VARARGS, NULL},
20748 { (char *)"new_Brush", (PyCFunction) _wrap_new_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
20749 { (char *)"delete_Brush", (PyCFunction) _wrap_delete_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
20750 { (char *)"Brush_SetColour", (PyCFunction) _wrap_Brush_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20751 { (char *)"Brush_SetStyle", (PyCFunction) _wrap_Brush_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20752 { (char *)"Brush_SetStipple", (PyCFunction) _wrap_Brush_SetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
20753 { (char *)"Brush_GetColour", (PyCFunction) _wrap_Brush_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20754 { (char *)"Brush_GetStyle", (PyCFunction) _wrap_Brush_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20755 { (char *)"Brush_GetStipple", (PyCFunction) _wrap_Brush_GetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
20756 { (char *)"Brush_IsHatch", (PyCFunction) _wrap_Brush_IsHatch, METH_VARARGS | METH_KEYWORDS, NULL},
20757 { (char *)"Brush_Ok", (PyCFunction) _wrap_Brush_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20758 { (char *)"Brush_MacGetTheme", (PyCFunction) _wrap_Brush_MacGetTheme, METH_VARARGS | METH_KEYWORDS, NULL},
20759 { (char *)"Brush_MacSetTheme", (PyCFunction) _wrap_Brush_MacSetTheme, METH_VARARGS | METH_KEYWORDS, NULL},
20760 { (char *)"Brush_swigregister", Brush_swigregister, METH_VARARGS, NULL},
20761 { (char *)"new_Bitmap", (PyCFunction) _wrap_new_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20762 { (char *)"delete_Bitmap", (PyCFunction) _wrap_delete_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20763 { (char *)"new_EmptyBitmap", (PyCFunction) _wrap_new_EmptyBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20764 { (char *)"new_BitmapFromIcon", (PyCFunction) _wrap_new_BitmapFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20765 { (char *)"new_BitmapFromImage", (PyCFunction) _wrap_new_BitmapFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
20766 { (char *)"new_BitmapFromXPMData", (PyCFunction) _wrap_new_BitmapFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
20767 { (char *)"new_BitmapFromBits", (PyCFunction) _wrap_new_BitmapFromBits, METH_VARARGS | METH_KEYWORDS, NULL},
20768 { (char *)"Bitmap_Ok", (PyCFunction) _wrap_Bitmap_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20769 { (char *)"Bitmap_GetWidth", (PyCFunction) _wrap_Bitmap_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20770 { (char *)"Bitmap_GetHeight", (PyCFunction) _wrap_Bitmap_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20771 { (char *)"Bitmap_GetDepth", (PyCFunction) _wrap_Bitmap_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20772 { (char *)"Bitmap_GetSize", (PyCFunction) _wrap_Bitmap_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20773 { (char *)"Bitmap_ConvertToImage", (PyCFunction) _wrap_Bitmap_ConvertToImage, METH_VARARGS | METH_KEYWORDS, NULL},
20774 { (char *)"Bitmap_GetMask", (PyCFunction) _wrap_Bitmap_GetMask, METH_VARARGS | METH_KEYWORDS, NULL},
20775 { (char *)"Bitmap_SetMask", (PyCFunction) _wrap_Bitmap_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
20776 { (char *)"Bitmap_SetMaskColour", (PyCFunction) _wrap_Bitmap_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
20777 { (char *)"Bitmap_GetSubBitmap", (PyCFunction) _wrap_Bitmap_GetSubBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20778 { (char *)"Bitmap_SaveFile", (PyCFunction) _wrap_Bitmap_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
20779 { (char *)"Bitmap_LoadFile", (PyCFunction) _wrap_Bitmap_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
20780 { (char *)"Bitmap_GetPalette", (PyCFunction) _wrap_Bitmap_GetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
20781 { (char *)"Bitmap_CopyFromIcon", (PyCFunction) _wrap_Bitmap_CopyFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20782 { (char *)"Bitmap_SetHeight", (PyCFunction) _wrap_Bitmap_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20783 { (char *)"Bitmap_SetWidth", (PyCFunction) _wrap_Bitmap_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20784 { (char *)"Bitmap_SetDepth", (PyCFunction) _wrap_Bitmap_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20785 { (char *)"Bitmap_SetSize", (PyCFunction) _wrap_Bitmap_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20786 { (char *)"Bitmap___eq__", (PyCFunction) _wrap_Bitmap___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20787 { (char *)"Bitmap___ne__", (PyCFunction) _wrap_Bitmap___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20788 { (char *)"Bitmap_swigregister", Bitmap_swigregister, METH_VARARGS, NULL},
20789 { (char *)"new_Mask", (PyCFunction) _wrap_new_Mask, METH_VARARGS | METH_KEYWORDS, NULL},
20790 { (char *)"Mask_swigregister", Mask_swigregister, METH_VARARGS, NULL},
20791 { (char *)"new_Icon", (PyCFunction) _wrap_new_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
20792 { (char *)"delete_Icon", (PyCFunction) _wrap_delete_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
20793 { (char *)"new_EmptyIcon", (PyCFunction) _wrap_new_EmptyIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20794 { (char *)"new_IconFromLocation", (PyCFunction) _wrap_new_IconFromLocation, METH_VARARGS | METH_KEYWORDS, NULL},
20795 { (char *)"new_IconFromBitmap", (PyCFunction) _wrap_new_IconFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20796 { (char *)"new_IconFromXPMData", (PyCFunction) _wrap_new_IconFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
20797 { (char *)"Icon_Ok", (PyCFunction) _wrap_Icon_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20798 { (char *)"Icon_GetWidth", (PyCFunction) _wrap_Icon_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20799 { (char *)"Icon_GetHeight", (PyCFunction) _wrap_Icon_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20800 { (char *)"Icon_GetDepth", (PyCFunction) _wrap_Icon_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20801 { (char *)"Icon_SetWidth", (PyCFunction) _wrap_Icon_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20802 { (char *)"Icon_SetHeight", (PyCFunction) _wrap_Icon_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20803 { (char *)"Icon_SetDepth", (PyCFunction) _wrap_Icon_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20804 { (char *)"Icon_CopyFromBitmap", (PyCFunction) _wrap_Icon_CopyFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20805 { (char *)"Icon_swigregister", Icon_swigregister, METH_VARARGS, NULL},
20806 { (char *)"new_IconLocation", (PyCFunction) _wrap_new_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
20807 { (char *)"delete_IconLocation", (PyCFunction) _wrap_delete_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
20808 { (char *)"IconLocation_IsOk", (PyCFunction) _wrap_IconLocation_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
20809 { (char *)"IconLocation_SetFileName", (PyCFunction) _wrap_IconLocation_SetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
20810 { (char *)"IconLocation_GetFileName", (PyCFunction) _wrap_IconLocation_GetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
20811 { (char *)"IconLocation_SetIndex", (PyCFunction) _wrap_IconLocation_SetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
20812 { (char *)"IconLocation_GetIndex", (PyCFunction) _wrap_IconLocation_GetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
20813 { (char *)"IconLocation_swigregister", IconLocation_swigregister, METH_VARARGS, NULL},
20814 { (char *)"new_IconBundle", (PyCFunction) _wrap_new_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
20815 { (char *)"new_IconBundleFromFile", (PyCFunction) _wrap_new_IconBundleFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
20816 { (char *)"new_IconBundleFromIcon", (PyCFunction) _wrap_new_IconBundleFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20817 { (char *)"delete_IconBundle", (PyCFunction) _wrap_delete_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
20818 { (char *)"IconBundle_AddIcon", (PyCFunction) _wrap_IconBundle_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20819 { (char *)"IconBundle_AddIconFromFile", (PyCFunction) _wrap_IconBundle_AddIconFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
20820 { (char *)"IconBundle_GetIcon", (PyCFunction) _wrap_IconBundle_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20821 { (char *)"IconBundle_swigregister", IconBundle_swigregister, METH_VARARGS, NULL},
20822 { (char *)"new_Cursor", (PyCFunction) _wrap_new_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
20823 { (char *)"delete_Cursor", (PyCFunction) _wrap_delete_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
20824 { (char *)"new_StockCursor", (PyCFunction) _wrap_new_StockCursor, METH_VARARGS | METH_KEYWORDS, NULL},
20825 { (char *)"new_CursorFromImage", (PyCFunction) _wrap_new_CursorFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
20826 { (char *)"Cursor_Ok", (PyCFunction) _wrap_Cursor_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20827 { (char *)"Cursor_swigregister", Cursor_swigregister, METH_VARARGS, NULL},
20828 { (char *)"new_Region", (PyCFunction) _wrap_new_Region, METH_VARARGS | METH_KEYWORDS, NULL},
20829 { (char *)"new_RegionFromBitmap", (PyCFunction) _wrap_new_RegionFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20830 { (char *)"new_RegionFromBitmapColour", (PyCFunction) _wrap_new_RegionFromBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
20831 { (char *)"new_RegionFromPoints", (PyCFunction) _wrap_new_RegionFromPoints, METH_VARARGS | METH_KEYWORDS, NULL},
20832 { (char *)"delete_Region", (PyCFunction) _wrap_delete_Region, METH_VARARGS | METH_KEYWORDS, NULL},
20833 { (char *)"Region_Clear", (PyCFunction) _wrap_Region_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
20834 { (char *)"Region_Offset", (PyCFunction) _wrap_Region_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
20835 { (char *)"Region_Contains", (PyCFunction) _wrap_Region_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
20836 { (char *)"Region_ContainsPoint", (PyCFunction) _wrap_Region_ContainsPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20837 { (char *)"Region_ContainsRect", (PyCFunction) _wrap_Region_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
20838 { (char *)"Region_ContainsRectDim", (PyCFunction) _wrap_Region_ContainsRectDim, METH_VARARGS | METH_KEYWORDS, NULL},
20839 { (char *)"Region_GetBox", (PyCFunction) _wrap_Region_GetBox, METH_VARARGS | METH_KEYWORDS, NULL},
20840 { (char *)"Region_Intersect", (PyCFunction) _wrap_Region_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
20841 { (char *)"Region_IntersectRect", (PyCFunction) _wrap_Region_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
20842 { (char *)"Region_IntersectRegion", (PyCFunction) _wrap_Region_IntersectRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20843 { (char *)"Region_IsEmpty", (PyCFunction) _wrap_Region_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
20844 { (char *)"Region_Union", (PyCFunction) _wrap_Region_Union, METH_VARARGS | METH_KEYWORDS, NULL},
20845 { (char *)"Region_UnionRect", (PyCFunction) _wrap_Region_UnionRect, METH_VARARGS | METH_KEYWORDS, NULL},
20846 { (char *)"Region_UnionRegion", (PyCFunction) _wrap_Region_UnionRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20847 { (char *)"Region_Subtract", (PyCFunction) _wrap_Region_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
20848 { (char *)"Region_SubtractRect", (PyCFunction) _wrap_Region_SubtractRect, METH_VARARGS | METH_KEYWORDS, NULL},
20849 { (char *)"Region_SubtractRegion", (PyCFunction) _wrap_Region_SubtractRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20850 { (char *)"Region_Xor", (PyCFunction) _wrap_Region_Xor, METH_VARARGS | METH_KEYWORDS, NULL},
20851 { (char *)"Region_XorRect", (PyCFunction) _wrap_Region_XorRect, METH_VARARGS | METH_KEYWORDS, NULL},
20852 { (char *)"Region_XorRegion", (PyCFunction) _wrap_Region_XorRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20853 { (char *)"Region_ConvertToBitmap", (PyCFunction) _wrap_Region_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20854 { (char *)"Region_UnionBitmap", (PyCFunction) _wrap_Region_UnionBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20855 { (char *)"Region_UnionBitmapColour", (PyCFunction) _wrap_Region_UnionBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
20856 { (char *)"Region_swigregister", Region_swigregister, METH_VARARGS, NULL},
20857 { (char *)"new_RegionIterator", (PyCFunction) _wrap_new_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
20858 { (char *)"delete_RegionIterator", (PyCFunction) _wrap_delete_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
20859 { (char *)"RegionIterator_GetX", (PyCFunction) _wrap_RegionIterator_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
20860 { (char *)"RegionIterator_GetY", (PyCFunction) _wrap_RegionIterator_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
20861 { (char *)"RegionIterator_GetW", (PyCFunction) _wrap_RegionIterator_GetW, METH_VARARGS | METH_KEYWORDS, NULL},
20862 { (char *)"RegionIterator_GetWidth", (PyCFunction) _wrap_RegionIterator_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20863 { (char *)"RegionIterator_GetH", (PyCFunction) _wrap_RegionIterator_GetH, METH_VARARGS | METH_KEYWORDS, NULL},
20864 { (char *)"RegionIterator_GetHeight", (PyCFunction) _wrap_RegionIterator_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20865 { (char *)"RegionIterator_GetRect", (PyCFunction) _wrap_RegionIterator_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
20866 { (char *)"RegionIterator_HaveRects", (PyCFunction) _wrap_RegionIterator_HaveRects, METH_VARARGS | METH_KEYWORDS, NULL},
20867 { (char *)"RegionIterator_Reset", (PyCFunction) _wrap_RegionIterator_Reset, METH_VARARGS | METH_KEYWORDS, NULL},
20868 { (char *)"RegionIterator_Next", (PyCFunction) _wrap_RegionIterator_Next, METH_VARARGS | METH_KEYWORDS, NULL},
20869 { (char *)"RegionIterator___nonzero__", (PyCFunction) _wrap_RegionIterator___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
20870 { (char *)"RegionIterator_swigregister", RegionIterator_swigregister, METH_VARARGS, NULL},
20871 { (char *)"new_NativeFontInfo", (PyCFunction) _wrap_new_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20872 { (char *)"delete_NativeFontInfo", (PyCFunction) _wrap_delete_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20873 { (char *)"NativeFontInfo_Init", (PyCFunction) _wrap_NativeFontInfo_Init, METH_VARARGS | METH_KEYWORDS, NULL},
20874 { (char *)"NativeFontInfo_InitFromFont", (PyCFunction) _wrap_NativeFontInfo_InitFromFont, METH_VARARGS | METH_KEYWORDS, NULL},
20875 { (char *)"NativeFontInfo_GetPointSize", (PyCFunction) _wrap_NativeFontInfo_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20876 { (char *)"NativeFontInfo_GetStyle", (PyCFunction) _wrap_NativeFontInfo_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20877 { (char *)"NativeFontInfo_GetWeight", (PyCFunction) _wrap_NativeFontInfo_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20878 { (char *)"NativeFontInfo_GetUnderlined", (PyCFunction) _wrap_NativeFontInfo_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20879 { (char *)"NativeFontInfo_GetFaceName", (PyCFunction) _wrap_NativeFontInfo_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20880 { (char *)"NativeFontInfo_GetFamily", (PyCFunction) _wrap_NativeFontInfo_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20881 { (char *)"NativeFontInfo_GetEncoding", (PyCFunction) _wrap_NativeFontInfo_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20882 { (char *)"NativeFontInfo_SetPointSize", (PyCFunction) _wrap_NativeFontInfo_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20883 { (char *)"NativeFontInfo_SetStyle", (PyCFunction) _wrap_NativeFontInfo_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20884 { (char *)"NativeFontInfo_SetWeight", (PyCFunction) _wrap_NativeFontInfo_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20885 { (char *)"NativeFontInfo_SetUnderlined", (PyCFunction) _wrap_NativeFontInfo_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20886 { (char *)"NativeFontInfo_SetFaceName", (PyCFunction) _wrap_NativeFontInfo_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20887 { (char *)"NativeFontInfo_SetFamily", (PyCFunction) _wrap_NativeFontInfo_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20888 { (char *)"NativeFontInfo_SetEncoding", (PyCFunction) _wrap_NativeFontInfo_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20889 { (char *)"NativeFontInfo_FromString", (PyCFunction) _wrap_NativeFontInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
20890 { (char *)"NativeFontInfo_ToString", (PyCFunction) _wrap_NativeFontInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
20891 { (char *)"NativeFontInfo___str__", (PyCFunction) _wrap_NativeFontInfo___str__, METH_VARARGS | METH_KEYWORDS, NULL},
20892 { (char *)"NativeFontInfo_FromUserString", (PyCFunction) _wrap_NativeFontInfo_FromUserString, METH_VARARGS | METH_KEYWORDS, NULL},
20893 { (char *)"NativeFontInfo_ToUserString", (PyCFunction) _wrap_NativeFontInfo_ToUserString, METH_VARARGS | METH_KEYWORDS, NULL},
20894 { (char *)"NativeFontInfo_swigregister", NativeFontInfo_swigregister, METH_VARARGS, NULL},
20895 { (char *)"NativeEncodingInfo_facename_set", (PyCFunction) _wrap_NativeEncodingInfo_facename_set, METH_VARARGS | METH_KEYWORDS, NULL},
20896 { (char *)"NativeEncodingInfo_facename_get", (PyCFunction) _wrap_NativeEncodingInfo_facename_get, METH_VARARGS | METH_KEYWORDS, NULL},
20897 { (char *)"NativeEncodingInfo_encoding_set", (PyCFunction) _wrap_NativeEncodingInfo_encoding_set, METH_VARARGS | METH_KEYWORDS, NULL},
20898 { (char *)"NativeEncodingInfo_encoding_get", (PyCFunction) _wrap_NativeEncodingInfo_encoding_get, METH_VARARGS | METH_KEYWORDS, NULL},
20899 { (char *)"new_NativeEncodingInfo", (PyCFunction) _wrap_new_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20900 { (char *)"delete_NativeEncodingInfo", (PyCFunction) _wrap_delete_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20901 { (char *)"NativeEncodingInfo_FromString", (PyCFunction) _wrap_NativeEncodingInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
20902 { (char *)"NativeEncodingInfo_ToString", (PyCFunction) _wrap_NativeEncodingInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
20903 { (char *)"NativeEncodingInfo_swigregister", NativeEncodingInfo_swigregister, METH_VARARGS, NULL},
20904 { (char *)"GetNativeFontEncoding", (PyCFunction) _wrap_GetNativeFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20905 { (char *)"TestFontEncoding", (PyCFunction) _wrap_TestFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20906 { (char *)"new_FontMapper", (PyCFunction) _wrap_new_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
20907 { (char *)"delete_FontMapper", (PyCFunction) _wrap_delete_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
20908 { (char *)"FontMapper_Get", (PyCFunction) _wrap_FontMapper_Get, METH_VARARGS | METH_KEYWORDS, NULL},
20909 { (char *)"FontMapper_Set", (PyCFunction) _wrap_FontMapper_Set, METH_VARARGS | METH_KEYWORDS, NULL},
20910 { (char *)"FontMapper_CharsetToEncoding", (PyCFunction) _wrap_FontMapper_CharsetToEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20911 { (char *)"FontMapper_GetSupportedEncodingsCount", (PyCFunction) _wrap_FontMapper_GetSupportedEncodingsCount, METH_VARARGS | METH_KEYWORDS, NULL},
20912 { (char *)"FontMapper_GetEncoding", (PyCFunction) _wrap_FontMapper_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20913 { (char *)"FontMapper_GetEncodingName", (PyCFunction) _wrap_FontMapper_GetEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
20914 { (char *)"FontMapper_GetEncodingDescription", (PyCFunction) _wrap_FontMapper_GetEncodingDescription, METH_VARARGS | METH_KEYWORDS, NULL},
20915 { (char *)"FontMapper_GetEncodingFromName", (PyCFunction) _wrap_FontMapper_GetEncodingFromName, METH_VARARGS | METH_KEYWORDS, NULL},
20916 { (char *)"FontMapper_SetConfig", (PyCFunction) _wrap_FontMapper_SetConfig, METH_VARARGS | METH_KEYWORDS, NULL},
20917 { (char *)"FontMapper_SetConfigPath", (PyCFunction) _wrap_FontMapper_SetConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
20918 { (char *)"FontMapper_GetDefaultConfigPath", (PyCFunction) _wrap_FontMapper_GetDefaultConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
20919 { (char *)"FontMapper_GetAltForEncoding", (PyCFunction) _wrap_FontMapper_GetAltForEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20920 { (char *)"FontMapper_IsEncodingAvailable", (PyCFunction) _wrap_FontMapper_IsEncodingAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
20921 { (char *)"FontMapper_SetDialogParent", (PyCFunction) _wrap_FontMapper_SetDialogParent, METH_VARARGS | METH_KEYWORDS, NULL},
20922 { (char *)"FontMapper_SetDialogTitle", (PyCFunction) _wrap_FontMapper_SetDialogTitle, METH_VARARGS | METH_KEYWORDS, NULL},
20923 { (char *)"FontMapper_swigregister", FontMapper_swigregister, METH_VARARGS, NULL},
20924 { (char *)"new_Font", (PyCFunction) _wrap_new_Font, METH_VARARGS | METH_KEYWORDS, NULL},
20925 { (char *)"delete_Font", (PyCFunction) _wrap_delete_Font, METH_VARARGS | METH_KEYWORDS, NULL},
20926 { (char *)"new_FontFromNativeInfo", (PyCFunction) _wrap_new_FontFromNativeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20927 { (char *)"new_FontFromNativeInfoString", (PyCFunction) _wrap_new_FontFromNativeInfoString, METH_VARARGS | METH_KEYWORDS, NULL},
20928 { (char *)"new_Font2", (PyCFunction) _wrap_new_Font2, METH_VARARGS | METH_KEYWORDS, NULL},
20929 { (char *)"new_FontFromPixelSize", (PyCFunction) _wrap_new_FontFromPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20930 { (char *)"Font_Ok", (PyCFunction) _wrap_Font_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20931 { (char *)"Font___eq__", (PyCFunction) _wrap_Font___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20932 { (char *)"Font___ne__", (PyCFunction) _wrap_Font___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20933 { (char *)"Font_GetPointSize", (PyCFunction) _wrap_Font_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20934 { (char *)"Font_GetPixelSize", (PyCFunction) _wrap_Font_GetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20935 { (char *)"Font_IsUsingSizeInPixels", (PyCFunction) _wrap_Font_IsUsingSizeInPixels, METH_VARARGS | METH_KEYWORDS, NULL},
20936 { (char *)"Font_GetFamily", (PyCFunction) _wrap_Font_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20937 { (char *)"Font_GetStyle", (PyCFunction) _wrap_Font_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20938 { (char *)"Font_GetWeight", (PyCFunction) _wrap_Font_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20939 { (char *)"Font_GetUnderlined", (PyCFunction) _wrap_Font_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20940 { (char *)"Font_GetFaceName", (PyCFunction) _wrap_Font_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20941 { (char *)"Font_GetEncoding", (PyCFunction) _wrap_Font_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20942 { (char *)"Font_GetNativeFontInfo", (PyCFunction) _wrap_Font_GetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20943 { (char *)"Font_IsFixedWidth", (PyCFunction) _wrap_Font_IsFixedWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20944 { (char *)"Font_GetNativeFontInfoDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoDesc, METH_VARARGS | METH_KEYWORDS, NULL},
20945 { (char *)"Font_GetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
20946 { (char *)"Font_SetPointSize", (PyCFunction) _wrap_Font_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20947 { (char *)"Font_SetPixelSize", (PyCFunction) _wrap_Font_SetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20948 { (char *)"Font_SetFamily", (PyCFunction) _wrap_Font_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20949 { (char *)"Font_SetStyle", (PyCFunction) _wrap_Font_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20950 { (char *)"Font_SetWeight", (PyCFunction) _wrap_Font_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20951 { (char *)"Font_SetFaceName", (PyCFunction) _wrap_Font_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20952 { (char *)"Font_SetUnderlined", (PyCFunction) _wrap_Font_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20953 { (char *)"Font_SetEncoding", (PyCFunction) _wrap_Font_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20954 { (char *)"Font_SetNativeFontInfo", (PyCFunction) _wrap_Font_SetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20955 { (char *)"Font_SetNativeFontInfoFromString", (PyCFunction) _wrap_Font_SetNativeFontInfoFromString, METH_VARARGS | METH_KEYWORDS, NULL},
20956 { (char *)"Font_SetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_SetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
20957 { (char *)"Font_GetFamilyString", (PyCFunction) _wrap_Font_GetFamilyString, METH_VARARGS | METH_KEYWORDS, NULL},
20958 { (char *)"Font_GetStyleString", (PyCFunction) _wrap_Font_GetStyleString, METH_VARARGS | METH_KEYWORDS, NULL},
20959 { (char *)"Font_GetWeightString", (PyCFunction) _wrap_Font_GetWeightString, METH_VARARGS | METH_KEYWORDS, NULL},
20960 { (char *)"Font_SetNoAntiAliasing", (PyCFunction) _wrap_Font_SetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
20961 { (char *)"Font_GetNoAntiAliasing", (PyCFunction) _wrap_Font_GetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
20962 { (char *)"Font_GetDefaultEncoding", (PyCFunction) _wrap_Font_GetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20963 { (char *)"Font_SetDefaultEncoding", (PyCFunction) _wrap_Font_SetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20964 { (char *)"Font_swigregister", Font_swigregister, METH_VARARGS, NULL},
20965 { (char *)"new_FontEnumerator", (PyCFunction) _wrap_new_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
20966 { (char *)"delete_FontEnumerator", (PyCFunction) _wrap_delete_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
20967 { (char *)"FontEnumerator__setCallbackInfo", (PyCFunction) _wrap_FontEnumerator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20968 { (char *)"FontEnumerator_EnumerateFacenames", (PyCFunction) _wrap_FontEnumerator_EnumerateFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
20969 { (char *)"FontEnumerator_EnumerateEncodings", (PyCFunction) _wrap_FontEnumerator_EnumerateEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
20970 { (char *)"FontEnumerator_GetEncodings", (PyCFunction) _wrap_FontEnumerator_GetEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
20971 { (char *)"FontEnumerator_GetFacenames", (PyCFunction) _wrap_FontEnumerator_GetFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
20972 { (char *)"FontEnumerator_swigregister", FontEnumerator_swigregister, METH_VARARGS, NULL},
20973 { (char *)"LanguageInfo_Language_set", (PyCFunction) _wrap_LanguageInfo_Language_set, METH_VARARGS | METH_KEYWORDS, NULL},
20974 { (char *)"LanguageInfo_Language_get", (PyCFunction) _wrap_LanguageInfo_Language_get, METH_VARARGS | METH_KEYWORDS, NULL},
20975 { (char *)"LanguageInfo_CanonicalName_set", (PyCFunction) _wrap_LanguageInfo_CanonicalName_set, METH_VARARGS | METH_KEYWORDS, NULL},
20976 { (char *)"LanguageInfo_CanonicalName_get", (PyCFunction) _wrap_LanguageInfo_CanonicalName_get, METH_VARARGS | METH_KEYWORDS, NULL},
20977 { (char *)"LanguageInfo_Description_set", (PyCFunction) _wrap_LanguageInfo_Description_set, METH_VARARGS | METH_KEYWORDS, NULL},
20978 { (char *)"LanguageInfo_Description_get", (PyCFunction) _wrap_LanguageInfo_Description_get, METH_VARARGS | METH_KEYWORDS, NULL},
20979 { (char *)"LanguageInfo_swigregister", LanguageInfo_swigregister, METH_VARARGS, NULL},
20980 { (char *)"new_Locale", (PyCFunction) _wrap_new_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
20981 { (char *)"delete_Locale", (PyCFunction) _wrap_delete_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
20982 { (char *)"Locale_Init1", (PyCFunction) _wrap_Locale_Init1, METH_VARARGS | METH_KEYWORDS, NULL},
20983 { (char *)"Locale_Init2", (PyCFunction) _wrap_Locale_Init2, METH_VARARGS | METH_KEYWORDS, NULL},
20984 { (char *)"Locale_GetSystemLanguage", (PyCFunction) _wrap_Locale_GetSystemLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
20985 { (char *)"Locale_GetSystemEncoding", (PyCFunction) _wrap_Locale_GetSystemEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20986 { (char *)"Locale_GetSystemEncodingName", (PyCFunction) _wrap_Locale_GetSystemEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
20987 { (char *)"Locale_IsOk", (PyCFunction) _wrap_Locale_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
20988 { (char *)"Locale_GetLocale", (PyCFunction) _wrap_Locale_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
20989 { (char *)"Locale_GetLanguage", (PyCFunction) _wrap_Locale_GetLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
20990 { (char *)"Locale_GetSysName", (PyCFunction) _wrap_Locale_GetSysName, METH_VARARGS | METH_KEYWORDS, NULL},
20991 { (char *)"Locale_GetCanonicalName", (PyCFunction) _wrap_Locale_GetCanonicalName, METH_VARARGS | METH_KEYWORDS, NULL},
20992 { (char *)"Locale_AddCatalogLookupPathPrefix", (PyCFunction) _wrap_Locale_AddCatalogLookupPathPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
20993 { (char *)"Locale_AddCatalog", (PyCFunction) _wrap_Locale_AddCatalog, METH_VARARGS | METH_KEYWORDS, NULL},
20994 { (char *)"Locale_IsLoaded", (PyCFunction) _wrap_Locale_IsLoaded, METH_VARARGS | METH_KEYWORDS, NULL},
20995 { (char *)"Locale_GetLanguageInfo", (PyCFunction) _wrap_Locale_GetLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20996 { (char *)"Locale_GetLanguageName", (PyCFunction) _wrap_Locale_GetLanguageName, METH_VARARGS | METH_KEYWORDS, NULL},
20997 { (char *)"Locale_FindLanguageInfo", (PyCFunction) _wrap_Locale_FindLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20998 { (char *)"Locale_AddLanguage", (PyCFunction) _wrap_Locale_AddLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
20999 { (char *)"Locale_GetString", (PyCFunction) _wrap_Locale_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
21000 { (char *)"Locale_GetName", (PyCFunction) _wrap_Locale_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
21001 { (char *)"Locale_swigregister", Locale_swigregister, METH_VARARGS, NULL},
21002 { (char *)"GetLocale", (PyCFunction) _wrap_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
21003 { (char *)"GetTranslation", _wrap_GetTranslation, METH_VARARGS, NULL},
21004 { (char *)"new_EncodingConverter", (PyCFunction) _wrap_new_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
21005 { (char *)"delete_EncodingConverter", (PyCFunction) _wrap_delete_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
21006 { (char *)"EncodingConverter_Init", (PyCFunction) _wrap_EncodingConverter_Init, METH_VARARGS | METH_KEYWORDS, NULL},
21007 { (char *)"EncodingConverter_Convert", (PyCFunction) _wrap_EncodingConverter_Convert, METH_VARARGS | METH_KEYWORDS, NULL},
21008 { (char *)"EncodingConverter_GetPlatformEquivalents", (PyCFunction) _wrap_EncodingConverter_GetPlatformEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
21009 { (char *)"EncodingConverter_GetAllEquivalents", (PyCFunction) _wrap_EncodingConverter_GetAllEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
21010 { (char *)"EncodingConverter_CanConvert", (PyCFunction) _wrap_EncodingConverter_CanConvert, METH_VARARGS | METH_KEYWORDS, NULL},
21011 { (char *)"EncodingConverter_swigregister", EncodingConverter_swigregister, METH_VARARGS, NULL},
21012 { (char *)"delete_DC", (PyCFunction) _wrap_delete_DC, METH_VARARGS | METH_KEYWORDS, NULL},
21013 { (char *)"DC_BeginDrawing", (PyCFunction) _wrap_DC_BeginDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
21014 { (char *)"DC_EndDrawing", (PyCFunction) _wrap_DC_EndDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
21015 { (char *)"DC_FloodFill", (PyCFunction) _wrap_DC_FloodFill, METH_VARARGS | METH_KEYWORDS, NULL},
21016 { (char *)"DC_FloodFillPoint", (PyCFunction) _wrap_DC_FloodFillPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21017 { (char *)"DC_GetPixel", (PyCFunction) _wrap_DC_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
21018 { (char *)"DC_GetPixelPoint", (PyCFunction) _wrap_DC_GetPixelPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21019 { (char *)"DC_DrawLine", (PyCFunction) _wrap_DC_DrawLine, METH_VARARGS | METH_KEYWORDS, NULL},
21020 { (char *)"DC_DrawLinePoint", (PyCFunction) _wrap_DC_DrawLinePoint, METH_VARARGS | METH_KEYWORDS, NULL},
21021 { (char *)"DC_CrossHair", (PyCFunction) _wrap_DC_CrossHair, METH_VARARGS | METH_KEYWORDS, NULL},
21022 { (char *)"DC_CrossHairPoint", (PyCFunction) _wrap_DC_CrossHairPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21023 { (char *)"DC_DrawArc", (PyCFunction) _wrap_DC_DrawArc, METH_VARARGS | METH_KEYWORDS, NULL},
21024 { (char *)"DC_DrawArcPoint", (PyCFunction) _wrap_DC_DrawArcPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21025 { (char *)"DC_DrawCheckMark", (PyCFunction) _wrap_DC_DrawCheckMark, METH_VARARGS | METH_KEYWORDS, NULL},
21026 { (char *)"DC_DrawCheckMarkRect", (PyCFunction) _wrap_DC_DrawCheckMarkRect, METH_VARARGS | METH_KEYWORDS, NULL},
21027 { (char *)"DC_DrawEllipticArc", (PyCFunction) _wrap_DC_DrawEllipticArc, METH_VARARGS | METH_KEYWORDS, NULL},
21028 { (char *)"DC_DrawEllipticArcPointSize", (PyCFunction) _wrap_DC_DrawEllipticArcPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21029 { (char *)"DC_DrawPoint", (PyCFunction) _wrap_DC_DrawPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21030 { (char *)"DC_DrawPointPoint", (PyCFunction) _wrap_DC_DrawPointPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21031 { (char *)"DC_DrawRectangle", (PyCFunction) _wrap_DC_DrawRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
21032 { (char *)"DC_DrawRectangleRect", (PyCFunction) _wrap_DC_DrawRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
21033 { (char *)"DC_DrawRectanglePointSize", (PyCFunction) _wrap_DC_DrawRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21034 { (char *)"DC_DrawRoundedRectangle", (PyCFunction) _wrap_DC_DrawRoundedRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
21035 { (char *)"DC_DrawRoundedRectangleRect", (PyCFunction) _wrap_DC_DrawRoundedRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
21036 { (char *)"DC_DrawRoundedRectanglePointSize", (PyCFunction) _wrap_DC_DrawRoundedRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21037 { (char *)"DC_DrawCircle", (PyCFunction) _wrap_DC_DrawCircle, METH_VARARGS | METH_KEYWORDS, NULL},
21038 { (char *)"DC_DrawCirclePoint", (PyCFunction) _wrap_DC_DrawCirclePoint, METH_VARARGS | METH_KEYWORDS, NULL},
21039 { (char *)"DC_DrawEllipse", (PyCFunction) _wrap_DC_DrawEllipse, METH_VARARGS | METH_KEYWORDS, NULL},
21040 { (char *)"DC_DrawEllipseRect", (PyCFunction) _wrap_DC_DrawEllipseRect, METH_VARARGS | METH_KEYWORDS, NULL},
21041 { (char *)"DC_DrawEllipsePointSize", (PyCFunction) _wrap_DC_DrawEllipsePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21042 { (char *)"DC_DrawIcon", (PyCFunction) _wrap_DC_DrawIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21043 { (char *)"DC_DrawIconPoint", (PyCFunction) _wrap_DC_DrawIconPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21044 { (char *)"DC_DrawBitmap", (PyCFunction) _wrap_DC_DrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21045 { (char *)"DC_DrawBitmapPoint", (PyCFunction) _wrap_DC_DrawBitmapPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21046 { (char *)"DC_DrawText", (PyCFunction) _wrap_DC_DrawText, METH_VARARGS | METH_KEYWORDS, NULL},
21047 { (char *)"DC_DrawTextPoint", (PyCFunction) _wrap_DC_DrawTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21048 { (char *)"DC_DrawRotatedText", (PyCFunction) _wrap_DC_DrawRotatedText, METH_VARARGS | METH_KEYWORDS, NULL},
21049 { (char *)"DC_DrawRotatedTextPoint", (PyCFunction) _wrap_DC_DrawRotatedTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21050 { (char *)"DC_Blit", (PyCFunction) _wrap_DC_Blit, METH_VARARGS | METH_KEYWORDS, NULL},
21051 { (char *)"DC_BlitPointSize", (PyCFunction) _wrap_DC_BlitPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21052 { (char *)"DC_SetClippingRegion", (PyCFunction) _wrap_DC_SetClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21053 { (char *)"DC_SetClippingRegionPointSize", (PyCFunction) _wrap_DC_SetClippingRegionPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
21054 { (char *)"DC_SetClippingRegionAsRegion", (PyCFunction) _wrap_DC_SetClippingRegionAsRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21055 { (char *)"DC_SetClippingRect", (PyCFunction) _wrap_DC_SetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
21056 { (char *)"DC_DrawLines", (PyCFunction) _wrap_DC_DrawLines, METH_VARARGS | METH_KEYWORDS, NULL},
21057 { (char *)"DC_DrawPolygon", (PyCFunction) _wrap_DC_DrawPolygon, METH_VARARGS | METH_KEYWORDS, NULL},
21058 { (char *)"DC_DrawLabel", (PyCFunction) _wrap_DC_DrawLabel, METH_VARARGS | METH_KEYWORDS, NULL},
21059 { (char *)"DC_DrawImageLabel", (PyCFunction) _wrap_DC_DrawImageLabel, METH_VARARGS | METH_KEYWORDS, NULL},
21060 { (char *)"DC_DrawSpline", (PyCFunction) _wrap_DC_DrawSpline, METH_VARARGS | METH_KEYWORDS, NULL},
21061 { (char *)"DC_Clear", (PyCFunction) _wrap_DC_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
21062 { (char *)"DC_StartDoc", (PyCFunction) _wrap_DC_StartDoc, METH_VARARGS | METH_KEYWORDS, NULL},
21063 { (char *)"DC_EndDoc", (PyCFunction) _wrap_DC_EndDoc, METH_VARARGS | METH_KEYWORDS, NULL},
21064 { (char *)"DC_StartPage", (PyCFunction) _wrap_DC_StartPage, METH_VARARGS | METH_KEYWORDS, NULL},
21065 { (char *)"DC_EndPage", (PyCFunction) _wrap_DC_EndPage, METH_VARARGS | METH_KEYWORDS, NULL},
21066 { (char *)"DC_SetFont", (PyCFunction) _wrap_DC_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
21067 { (char *)"DC_SetPen", (PyCFunction) _wrap_DC_SetPen, METH_VARARGS | METH_KEYWORDS, NULL},
21068 { (char *)"DC_SetBrush", (PyCFunction) _wrap_DC_SetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21069 { (char *)"DC_SetBackground", (PyCFunction) _wrap_DC_SetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21070 { (char *)"DC_SetBackgroundMode", (PyCFunction) _wrap_DC_SetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
21071 { (char *)"DC_SetPalette", (PyCFunction) _wrap_DC_SetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
21072 { (char *)"DC_DestroyClippingRegion", (PyCFunction) _wrap_DC_DestroyClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
21073 { (char *)"DC_GetClippingBox", (PyCFunction) _wrap_DC_GetClippingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21074 { (char *)"DC_GetClippingRect", (PyCFunction) _wrap_DC_GetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
21075 { (char *)"DC_GetCharHeight", (PyCFunction) _wrap_DC_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21076 { (char *)"DC_GetCharWidth", (PyCFunction) _wrap_DC_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21077 { (char *)"DC_GetTextExtent", (PyCFunction) _wrap_DC_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21078 { (char *)"DC_GetFullTextExtent", (PyCFunction) _wrap_DC_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21079 { (char *)"DC_GetMultiLineTextExtent", (PyCFunction) _wrap_DC_GetMultiLineTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21080 { (char *)"DC_GetPartialTextExtents", (PyCFunction) _wrap_DC_GetPartialTextExtents, METH_VARARGS | METH_KEYWORDS, NULL},
21081 { (char *)"DC_GetSize", (PyCFunction) _wrap_DC_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21082 { (char *)"DC_GetSizeTuple", (PyCFunction) _wrap_DC_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21083 { (char *)"DC_GetSizeMM", (PyCFunction) _wrap_DC_GetSizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
21084 { (char *)"DC_GetSizeMMTuple", (PyCFunction) _wrap_DC_GetSizeMMTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21085 { (char *)"DC_DeviceToLogicalX", (PyCFunction) _wrap_DC_DeviceToLogicalX, METH_VARARGS | METH_KEYWORDS, NULL},
21086 { (char *)"DC_DeviceToLogicalY", (PyCFunction) _wrap_DC_DeviceToLogicalY, METH_VARARGS | METH_KEYWORDS, NULL},
21087 { (char *)"DC_DeviceToLogicalXRel", (PyCFunction) _wrap_DC_DeviceToLogicalXRel, METH_VARARGS | METH_KEYWORDS, NULL},
21088 { (char *)"DC_DeviceToLogicalYRel", (PyCFunction) _wrap_DC_DeviceToLogicalYRel, METH_VARARGS | METH_KEYWORDS, NULL},
21089 { (char *)"DC_LogicalToDeviceX", (PyCFunction) _wrap_DC_LogicalToDeviceX, METH_VARARGS | METH_KEYWORDS, NULL},
21090 { (char *)"DC_LogicalToDeviceY", (PyCFunction) _wrap_DC_LogicalToDeviceY, METH_VARARGS | METH_KEYWORDS, NULL},
21091 { (char *)"DC_LogicalToDeviceXRel", (PyCFunction) _wrap_DC_LogicalToDeviceXRel, METH_VARARGS | METH_KEYWORDS, NULL},
21092 { (char *)"DC_LogicalToDeviceYRel", (PyCFunction) _wrap_DC_LogicalToDeviceYRel, METH_VARARGS | METH_KEYWORDS, NULL},
21093 { (char *)"DC_CanDrawBitmap", (PyCFunction) _wrap_DC_CanDrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21094 { (char *)"DC_CanGetTextExtent", (PyCFunction) _wrap_DC_CanGetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
21095 { (char *)"DC_GetDepth", (PyCFunction) _wrap_DC_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
21096 { (char *)"DC_GetPPI", (PyCFunction) _wrap_DC_GetPPI, METH_VARARGS | METH_KEYWORDS, NULL},
21097 { (char *)"DC_Ok", (PyCFunction) _wrap_DC_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21098 { (char *)"DC_GetBackgroundMode", (PyCFunction) _wrap_DC_GetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
21099 { (char *)"DC_GetBackground", (PyCFunction) _wrap_DC_GetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21100 { (char *)"DC_GetBrush", (PyCFunction) _wrap_DC_GetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21101 { (char *)"DC_GetFont", (PyCFunction) _wrap_DC_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
21102 { (char *)"DC_GetPen", (PyCFunction) _wrap_DC_GetPen, METH_VARARGS | METH_KEYWORDS, NULL},
21103 { (char *)"DC_GetTextBackground", (PyCFunction) _wrap_DC_GetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21104 { (char *)"DC_GetTextForeground", (PyCFunction) _wrap_DC_GetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
21105 { (char *)"DC_SetTextForeground", (PyCFunction) _wrap_DC_SetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
21106 { (char *)"DC_SetTextBackground", (PyCFunction) _wrap_DC_SetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
21107 { (char *)"DC_GetMapMode", (PyCFunction) _wrap_DC_GetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
21108 { (char *)"DC_SetMapMode", (PyCFunction) _wrap_DC_SetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
21109 { (char *)"DC_GetUserScale", (PyCFunction) _wrap_DC_GetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
21110 { (char *)"DC_SetUserScale", (PyCFunction) _wrap_DC_SetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
21111 { (char *)"DC_GetLogicalScale", (PyCFunction) _wrap_DC_GetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
21112 { (char *)"DC_SetLogicalScale", (PyCFunction) _wrap_DC_SetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
21113 { (char *)"DC_GetLogicalOrigin", (PyCFunction) _wrap_DC_GetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21114 { (char *)"DC_GetLogicalOriginTuple", (PyCFunction) _wrap_DC_GetLogicalOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21115 { (char *)"DC_SetLogicalOrigin", (PyCFunction) _wrap_DC_SetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21116 { (char *)"DC_SetLogicalOriginPoint", (PyCFunction) _wrap_DC_SetLogicalOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21117 { (char *)"DC_GetDeviceOrigin", (PyCFunction) _wrap_DC_GetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21118 { (char *)"DC_GetDeviceOriginTuple", (PyCFunction) _wrap_DC_GetDeviceOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
21119 { (char *)"DC_SetDeviceOrigin", (PyCFunction) _wrap_DC_SetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21120 { (char *)"DC_SetDeviceOriginPoint", (PyCFunction) _wrap_DC_SetDeviceOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21121 { (char *)"DC_SetAxisOrientation", (PyCFunction) _wrap_DC_SetAxisOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
21122 { (char *)"DC_GetLogicalFunction", (PyCFunction) _wrap_DC_GetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
21123 { (char *)"DC_SetLogicalFunction", (PyCFunction) _wrap_DC_SetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
21124 { (char *)"DC_ComputeScaleAndOrigin", (PyCFunction) _wrap_DC_ComputeScaleAndOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
21125 { (char *)"DC_CalcBoundingBox", (PyCFunction) _wrap_DC_CalcBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21126 { (char *)"DC_CalcBoundingBoxPoint", (PyCFunction) _wrap_DC_CalcBoundingBoxPoint, METH_VARARGS | METH_KEYWORDS, NULL},
21127 { (char *)"DC_ResetBoundingBox", (PyCFunction) _wrap_DC_ResetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21128 { (char *)"DC_MinX", (PyCFunction) _wrap_DC_MinX, METH_VARARGS | METH_KEYWORDS, NULL},
21129 { (char *)"DC_MaxX", (PyCFunction) _wrap_DC_MaxX, METH_VARARGS | METH_KEYWORDS, NULL},
21130 { (char *)"DC_MinY", (PyCFunction) _wrap_DC_MinY, METH_VARARGS | METH_KEYWORDS, NULL},
21131 { (char *)"DC_MaxY", (PyCFunction) _wrap_DC_MaxY, METH_VARARGS | METH_KEYWORDS, NULL},
21132 { (char *)"DC_GetBoundingBox", (PyCFunction) _wrap_DC_GetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
21133 { (char *)"DC__DrawPointList", (PyCFunction) _wrap_DC__DrawPointList, METH_VARARGS | METH_KEYWORDS, NULL},
21134 { (char *)"DC__DrawLineList", (PyCFunction) _wrap_DC__DrawLineList, METH_VARARGS | METH_KEYWORDS, NULL},
21135 { (char *)"DC__DrawRectangleList", (PyCFunction) _wrap_DC__DrawRectangleList, METH_VARARGS | METH_KEYWORDS, NULL},
21136 { (char *)"DC__DrawEllipseList", (PyCFunction) _wrap_DC__DrawEllipseList, METH_VARARGS | METH_KEYWORDS, NULL},
21137 { (char *)"DC__DrawPolygonList", (PyCFunction) _wrap_DC__DrawPolygonList, METH_VARARGS | METH_KEYWORDS, NULL},
21138 { (char *)"DC__DrawTextList", (PyCFunction) _wrap_DC__DrawTextList, METH_VARARGS | METH_KEYWORDS, NULL},
21139 { (char *)"DC_swigregister", DC_swigregister, METH_VARARGS, NULL},
21140 { (char *)"new_MemoryDC", (PyCFunction) _wrap_new_MemoryDC, METH_VARARGS | METH_KEYWORDS, NULL},
21141 { (char *)"new_MemoryDCFromDC", (PyCFunction) _wrap_new_MemoryDCFromDC, METH_VARARGS | METH_KEYWORDS, NULL},
21142 { (char *)"MemoryDC_SelectObject", (PyCFunction) _wrap_MemoryDC_SelectObject, METH_VARARGS | METH_KEYWORDS, NULL},
21143 { (char *)"MemoryDC_swigregister", MemoryDC_swigregister, METH_VARARGS, NULL},
21144 { (char *)"new_BufferedDC", _wrap_new_BufferedDC, METH_VARARGS, NULL},
21145 { (char *)"delete_BufferedDC", (PyCFunction) _wrap_delete_BufferedDC, METH_VARARGS | METH_KEYWORDS, NULL},
21146 { (char *)"BufferedDC_UnMask", (PyCFunction) _wrap_BufferedDC_UnMask, METH_VARARGS | METH_KEYWORDS, NULL},
21147 { (char *)"BufferedDC_swigregister", BufferedDC_swigregister, METH_VARARGS, NULL},
21148 { (char *)"new_BufferedPaintDC", (PyCFunction) _wrap_new_BufferedPaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
21149 { (char *)"BufferedPaintDC_swigregister", BufferedPaintDC_swigregister, METH_VARARGS, NULL},
21150 { (char *)"new_ScreenDC", (PyCFunction) _wrap_new_ScreenDC, METH_VARARGS | METH_KEYWORDS, NULL},
21151 { (char *)"ScreenDC_StartDrawingOnTopWin", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTopWin, METH_VARARGS | METH_KEYWORDS, NULL},
21152 { (char *)"ScreenDC_StartDrawingOnTop", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
21153 { (char *)"ScreenDC_EndDrawingOnTop", (PyCFunction) _wrap_ScreenDC_EndDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
21154 { (char *)"ScreenDC_swigregister", ScreenDC_swigregister, METH_VARARGS, NULL},
21155 { (char *)"new_ClientDC", (PyCFunction) _wrap_new_ClientDC, METH_VARARGS | METH_KEYWORDS, NULL},
21156 { (char *)"ClientDC_swigregister", ClientDC_swigregister, METH_VARARGS, NULL},
21157 { (char *)"new_PaintDC", (PyCFunction) _wrap_new_PaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
21158 { (char *)"PaintDC_swigregister", PaintDC_swigregister, METH_VARARGS, NULL},
21159 { (char *)"new_WindowDC", (PyCFunction) _wrap_new_WindowDC, METH_VARARGS | METH_KEYWORDS, NULL},
21160 { (char *)"WindowDC_swigregister", WindowDC_swigregister, METH_VARARGS, NULL},
21161 { (char *)"new_MirrorDC", (PyCFunction) _wrap_new_MirrorDC, METH_VARARGS | METH_KEYWORDS, NULL},
21162 { (char *)"MirrorDC_swigregister", MirrorDC_swigregister, METH_VARARGS, NULL},
21163 { (char *)"new_PostScriptDC", (PyCFunction) _wrap_new_PostScriptDC, METH_VARARGS | METH_KEYWORDS, NULL},
21164 { (char *)"PostScriptDC_GetPrintData", (PyCFunction) _wrap_PostScriptDC_GetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
21165 { (char *)"PostScriptDC_SetPrintData", (PyCFunction) _wrap_PostScriptDC_SetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
21166 { (char *)"PostScriptDC_SetResolution", (PyCFunction) _wrap_PostScriptDC_SetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
21167 { (char *)"PostScriptDC_GetResolution", (PyCFunction) _wrap_PostScriptDC_GetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
21168 { (char *)"PostScriptDC_swigregister", PostScriptDC_swigregister, METH_VARARGS, NULL},
21169 { (char *)"new_MetaFile", (PyCFunction) _wrap_new_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
21170 { (char *)"delete_MetaFile", (PyCFunction) _wrap_delete_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
21171 { (char *)"MetaFile_Ok", (PyCFunction) _wrap_MetaFile_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
21172 { (char *)"MetaFile_SetClipboard", (PyCFunction) _wrap_MetaFile_SetClipboard, METH_VARARGS | METH_KEYWORDS, NULL},
21173 { (char *)"MetaFile_GetSize", (PyCFunction) _wrap_MetaFile_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21174 { (char *)"MetaFile_GetWidth", (PyCFunction) _wrap_MetaFile_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
21175 { (char *)"MetaFile_GetHeight", (PyCFunction) _wrap_MetaFile_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
21176 { (char *)"MetaFile_swigregister", MetaFile_swigregister, METH_VARARGS, NULL},
21177 { (char *)"new_MetaFileDC", (PyCFunction) _wrap_new_MetaFileDC, METH_VARARGS | METH_KEYWORDS, NULL},
21178 { (char *)"MetaFileDC_Close", (PyCFunction) _wrap_MetaFileDC_Close, METH_VARARGS | METH_KEYWORDS, NULL},
21179 { (char *)"MetaFileDC_swigregister", MetaFileDC_swigregister, METH_VARARGS, NULL},
21180 { (char *)"new_PrinterDC", (PyCFunction) _wrap_new_PrinterDC, METH_VARARGS | METH_KEYWORDS, NULL},
21181 { (char *)"PrinterDC_swigregister", PrinterDC_swigregister, METH_VARARGS, NULL},
21182 { (char *)"new_ImageList", (PyCFunction) _wrap_new_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
21183 { (char *)"delete_ImageList", (PyCFunction) _wrap_delete_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
21184 { (char *)"ImageList_Add", (PyCFunction) _wrap_ImageList_Add, METH_VARARGS | METH_KEYWORDS, NULL},
21185 { (char *)"ImageList_AddWithColourMask", (PyCFunction) _wrap_ImageList_AddWithColourMask, METH_VARARGS | METH_KEYWORDS, NULL},
21186 { (char *)"ImageList_AddIcon", (PyCFunction) _wrap_ImageList_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21187 { (char *)"ImageList_GetBitmap", (PyCFunction) _wrap_ImageList_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21188 { (char *)"ImageList_GetIcon", (PyCFunction) _wrap_ImageList_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
21189 { (char *)"ImageList_Replace", (PyCFunction) _wrap_ImageList_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
21190 { (char *)"ImageList_Draw", (PyCFunction) _wrap_ImageList_Draw, METH_VARARGS | METH_KEYWORDS, NULL},
21191 { (char *)"ImageList_GetImageCount", (PyCFunction) _wrap_ImageList_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
21192 { (char *)"ImageList_Remove", (PyCFunction) _wrap_ImageList_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
21193 { (char *)"ImageList_RemoveAll", (PyCFunction) _wrap_ImageList_RemoveAll, METH_VARARGS | METH_KEYWORDS, NULL},
21194 { (char *)"ImageList_GetSize", (PyCFunction) _wrap_ImageList_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
21195 { (char *)"ImageList_swigregister", ImageList_swigregister, METH_VARARGS, NULL},
21196 { (char *)"PenList_AddPen", (PyCFunction) _wrap_PenList_AddPen, METH_VARARGS | METH_KEYWORDS, NULL},
21197 { (char *)"PenList_FindOrCreatePen", (PyCFunction) _wrap_PenList_FindOrCreatePen, METH_VARARGS | METH_KEYWORDS, NULL},
21198 { (char *)"PenList_RemovePen", (PyCFunction) _wrap_PenList_RemovePen, METH_VARARGS | METH_KEYWORDS, NULL},
21199 { (char *)"PenList_GetCount", (PyCFunction) _wrap_PenList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
21200 { (char *)"PenList_swigregister", PenList_swigregister, METH_VARARGS, NULL},
21201 { (char *)"BrushList_AddBrush", (PyCFunction) _wrap_BrushList_AddBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21202 { (char *)"BrushList_FindOrCreateBrush", (PyCFunction) _wrap_BrushList_FindOrCreateBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21203 { (char *)"BrushList_RemoveBrush", (PyCFunction) _wrap_BrushList_RemoveBrush, METH_VARARGS | METH_KEYWORDS, NULL},
21204 { (char *)"BrushList_GetCount", (PyCFunction) _wrap_BrushList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
21205 { (char *)"BrushList_swigregister", BrushList_swigregister, METH_VARARGS, NULL},
21206 { (char *)"new_ColourDatabase", (PyCFunction) _wrap_new_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
21207 { (char *)"delete_ColourDatabase", (PyCFunction) _wrap_delete_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
21208 { (char *)"ColourDatabase_Find", (PyCFunction) _wrap_ColourDatabase_Find, METH_VARARGS | METH_KEYWORDS, NULL},
21209 { (char *)"ColourDatabase_FindName", (PyCFunction) _wrap_ColourDatabase_FindName, METH_VARARGS | METH_KEYWORDS, NULL},
21210 { (char *)"ColourDatabase_AddColour", (PyCFunction) _wrap_ColourDatabase_AddColour, METH_VARARGS | METH_KEYWORDS, NULL},
21211 { (char *)"ColourDatabase_Append", (PyCFunction) _wrap_ColourDatabase_Append, METH_VARARGS | METH_KEYWORDS, NULL},
21212 { (char *)"ColourDatabase_swigregister", ColourDatabase_swigregister, METH_VARARGS, NULL},
21213 { (char *)"FontList_AddFont", (PyCFunction) _wrap_FontList_AddFont, METH_VARARGS | METH_KEYWORDS, NULL},
21214 { (char *)"FontList_FindOrCreateFont", (PyCFunction) _wrap_FontList_FindOrCreateFont, METH_VARARGS | METH_KEYWORDS, NULL},
21215 { (char *)"FontList_RemoveFont", (PyCFunction) _wrap_FontList_RemoveFont, METH_VARARGS | METH_KEYWORDS, NULL},
21216 { (char *)"FontList_GetCount", (PyCFunction) _wrap_FontList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
21217 { (char *)"FontList_swigregister", FontList_swigregister, METH_VARARGS, NULL},
21218 { (char *)"new_Effects", (PyCFunction) _wrap_new_Effects, METH_VARARGS | METH_KEYWORDS, NULL},
21219 { (char *)"Effects_GetHighlightColour", (PyCFunction) _wrap_Effects_GetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
21220 { (char *)"Effects_GetLightShadow", (PyCFunction) _wrap_Effects_GetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21221 { (char *)"Effects_GetFaceColour", (PyCFunction) _wrap_Effects_GetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
21222 { (char *)"Effects_GetMediumShadow", (PyCFunction) _wrap_Effects_GetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21223 { (char *)"Effects_GetDarkShadow", (PyCFunction) _wrap_Effects_GetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21224 { (char *)"Effects_SetHighlightColour", (PyCFunction) _wrap_Effects_SetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
21225 { (char *)"Effects_SetLightShadow", (PyCFunction) _wrap_Effects_SetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21226 { (char *)"Effects_SetFaceColour", (PyCFunction) _wrap_Effects_SetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
21227 { (char *)"Effects_SetMediumShadow", (PyCFunction) _wrap_Effects_SetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21228 { (char *)"Effects_SetDarkShadow", (PyCFunction) _wrap_Effects_SetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
21229 { (char *)"Effects_Set", (PyCFunction) _wrap_Effects_Set, METH_VARARGS | METH_KEYWORDS, NULL},
21230 { (char *)"Effects_DrawSunkenEdge", (PyCFunction) _wrap_Effects_DrawSunkenEdge, METH_VARARGS | METH_KEYWORDS, NULL},
21231 { (char *)"Effects_TileBitmap", (PyCFunction) _wrap_Effects_TileBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
21232 { (char *)"Effects_swigregister", Effects_swigregister, METH_VARARGS, NULL},
21233 { NULL, NULL, 0, NULL }
21234 };
21235
21236
21237 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
21238
21239 static void *_p_wxBufferedDCTo_p_wxMemoryDC(void *x) {
21240 return (void *)((wxMemoryDC *) ((wxBufferedDC *) x));
21241 }
21242 static void *_p_wxBufferedPaintDCTo_p_wxMemoryDC(void *x) {
21243 return (void *)((wxMemoryDC *) (wxBufferedDC *) ((wxBufferedPaintDC *) x));
21244 }
21245 static void *_p_wxIconTo_p_wxGDIObject(void *x) {
21246 return (void *)((wxGDIObject *) ((wxIcon *) x));
21247 }
21248 static void *_p_wxPaletteTo_p_wxGDIObject(void *x) {
21249 return (void *)((wxGDIObject *) ((wxPalette *) x));
21250 }
21251 static void *_p_wxPenTo_p_wxGDIObject(void *x) {
21252 return (void *)((wxGDIObject *) ((wxPen *) x));
21253 }
21254 static void *_p_wxFontTo_p_wxGDIObject(void *x) {
21255 return (void *)((wxGDIObject *) ((wxFont *) x));
21256 }
21257 static void *_p_wxCursorTo_p_wxGDIObject(void *x) {
21258 return (void *)((wxGDIObject *) ((wxCursor *) x));
21259 }
21260 static void *_p_wxBitmapTo_p_wxGDIObject(void *x) {
21261 return (void *)((wxGDIObject *) ((wxBitmap *) x));
21262 }
21263 static void *_p_wxRegionTo_p_wxGDIObject(void *x) {
21264 return (void *)((wxGDIObject *) ((wxRegion *) x));
21265 }
21266 static void *_p_wxBrushTo_p_wxGDIObject(void *x) {
21267 return (void *)((wxGDIObject *) ((wxBrush *) x));
21268 }
21269 static void *_p_wxBufferedDCTo_p_wxDC(void *x) {
21270 return (void *)((wxDC *) (wxMemoryDC *) ((wxBufferedDC *) x));
21271 }
21272 static void *_p_wxScreenDCTo_p_wxDC(void *x) {
21273 return (void *)((wxDC *) ((wxScreenDC *) x));
21274 }
21275 static void *_p_wxMirrorDCTo_p_wxDC(void *x) {
21276 return (void *)((wxDC *) ((wxMirrorDC *) x));
21277 }
21278 static void *_p_wxMemoryDCTo_p_wxDC(void *x) {
21279 return (void *)((wxDC *) ((wxMemoryDC *) x));
21280 }
21281 static void *_p_wxWindowDCTo_p_wxDC(void *x) {
21282 return (void *)((wxDC *) ((wxWindowDC *) x));
21283 }
21284 static void *_p_wxMetaFileDCTo_p_wxDC(void *x) {
21285 return (void *)((wxDC *) ((wxMetaFileDC *) x));
21286 }
21287 static void *_p_wxBufferedPaintDCTo_p_wxDC(void *x) {
21288 return (void *)((wxDC *) (wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
21289 }
21290 static void *_p_wxClientDCTo_p_wxDC(void *x) {
21291 return (void *)((wxDC *) ((wxClientDC *) x));
21292 }
21293 static void *_p_wxPaintDCTo_p_wxDC(void *x) {
21294 return (void *)((wxDC *) ((wxPaintDC *) x));
21295 }
21296 static void *_p_wxPostScriptDCTo_p_wxDC(void *x) {
21297 return (void *)((wxDC *) ((wxPostScriptDC *) x));
21298 }
21299 static void *_p_wxPrinterDCTo_p_wxDC(void *x) {
21300 return (void *)((wxDC *) ((wxPrinterDC *) x));
21301 }
21302 static void *_p_wxBufferedPaintDCTo_p_wxBufferedDC(void *x) {
21303 return (void *)((wxBufferedDC *) ((wxBufferedPaintDC *) x));
21304 }
21305 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
21306 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
21307 }
21308 static void *_p_wxPenTo_p_wxObject(void *x) {
21309 return (void *)((wxObject *) (wxGDIObject *) ((wxPen *) x));
21310 }
21311 static void *_p_wxRegionIteratorTo_p_wxObject(void *x) {
21312 return (void *)((wxObject *) ((wxRegionIterator *) x));
21313 }
21314 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
21315 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
21316 }
21317 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
21318 return (void *)((wxObject *) ((wxSizerItem *) x));
21319 }
21320 static void *_p_wxColourDatabaseTo_p_wxObject(void *x) {
21321 return (void *)((wxObject *) ((wxColourDatabase *) x));
21322 }
21323 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
21324 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
21325 }
21326 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
21327 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
21328 }
21329 static void *_p_wxIconTo_p_wxObject(void *x) {
21330 return (void *)((wxObject *) (wxGDIObject *) ((wxIcon *) x));
21331 }
21332 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
21333 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
21334 }
21335 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
21336 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
21337 }
21338 static void *_p_wxSizerTo_p_wxObject(void *x) {
21339 return (void *)((wxObject *) ((wxSizer *) x));
21340 }
21341 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
21342 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
21343 }
21344 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
21345 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
21346 }
21347 static void *_p_wxPenListTo_p_wxObject(void *x) {
21348 return (void *)((wxObject *) ((wxPenList *) x));
21349 }
21350 static void *_p_wxEventTo_p_wxObject(void *x) {
21351 return (void *)((wxObject *) ((wxEvent *) x));
21352 }
21353 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
21354 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
21355 }
21356 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
21357 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
21358 }
21359 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
21360 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
21361 }
21362 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
21363 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
21364 }
21365 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
21366 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
21367 }
21368 static void *_p_wxDCTo_p_wxObject(void *x) {
21369 return (void *)((wxObject *) ((wxDC *) x));
21370 }
21371 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
21372 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
21373 }
21374 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
21375 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
21376 }
21377 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
21378 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
21379 }
21380 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
21381 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
21382 }
21383 static void *_p_wxControlTo_p_wxObject(void *x) {
21384 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
21385 }
21386 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
21387 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
21388 }
21389 static void *_p_wxClientDCTo_p_wxObject(void *x) {
21390 return (void *)((wxObject *) (wxDC *) ((wxClientDC *) x));
21391 }
21392 static void *_p_wxFSFileTo_p_wxObject(void *x) {
21393 return (void *)((wxObject *) ((wxFSFile *) x));
21394 }
21395 static void *_p_wxMemoryDCTo_p_wxObject(void *x) {
21396 return (void *)((wxObject *) (wxDC *) ((wxMemoryDC *) x));
21397 }
21398 static void *_p_wxRegionTo_p_wxObject(void *x) {
21399 return (void *)((wxObject *) (wxGDIObject *) ((wxRegion *) x));
21400 }
21401 static void *_p_wxPySizerTo_p_wxObject(void *x) {
21402 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
21403 }
21404 static void *_p_wxWindowDCTo_p_wxObject(void *x) {
21405 return (void *)((wxObject *) (wxDC *) ((wxWindowDC *) x));
21406 }
21407 static void *_p_wxGDIObjectTo_p_wxObject(void *x) {
21408 return (void *)((wxObject *) ((wxGDIObject *) x));
21409 }
21410 static void *_p_wxEffectsTo_p_wxObject(void *x) {
21411 return (void *)((wxObject *) ((wxEffects *) x));
21412 }
21413 static void *_p_wxPyEventTo_p_wxObject(void *x) {
21414 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
21415 }
21416 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
21417 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
21418 }
21419 static void *_p_wxPostScriptDCTo_p_wxObject(void *x) {
21420 return (void *)((wxObject *) (wxDC *) ((wxPostScriptDC *) x));
21421 }
21422 static void *_p_wxShowEventTo_p_wxObject(void *x) {
21423 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
21424 }
21425 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
21426 return (void *)((wxObject *) ((wxMenuItem *) x));
21427 }
21428 static void *_p_wxDateEventTo_p_wxObject(void *x) {
21429 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
21430 }
21431 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
21432 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
21433 }
21434 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
21435 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
21436 }
21437 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
21438 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
21439 }
21440 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
21441 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
21442 }
21443 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
21444 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
21445 }
21446 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
21447 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
21448 }
21449 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
21450 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
21451 }
21452 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
21453 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
21454 }
21455 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
21456 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
21457 }
21458 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
21459 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
21460 }
21461 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
21462 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
21463 }
21464 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
21465 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
21466 }
21467 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
21468 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
21469 }
21470 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
21471 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
21472 }
21473 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
21474 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
21475 }
21476 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
21477 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
21478 }
21479 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
21480 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
21481 }
21482 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
21483 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
21484 }
21485 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
21486 return (void *)((wxObject *) ((wxImageHandler *) x));
21487 }
21488 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
21489 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
21490 }
21491 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
21492 return (void *)((wxObject *) ((wxEvtHandler *) x));
21493 }
21494 static void *_p_wxBufferedPaintDCTo_p_wxObject(void *x) {
21495 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
21496 }
21497 static void *_p_wxPaintDCTo_p_wxObject(void *x) {
21498 return (void *)((wxObject *) (wxDC *) ((wxPaintDC *) x));
21499 }
21500 static void *_p_wxPrinterDCTo_p_wxObject(void *x) {
21501 return (void *)((wxObject *) (wxDC *) ((wxPrinterDC *) x));
21502 }
21503 static void *_p_wxScreenDCTo_p_wxObject(void *x) {
21504 return (void *)((wxObject *) (wxDC *) ((wxScreenDC *) x));
21505 }
21506 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
21507 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
21508 }
21509 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
21510 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
21511 }
21512 static void *_p_wxImageTo_p_wxObject(void *x) {
21513 return (void *)((wxObject *) ((wxImage *) x));
21514 }
21515 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
21516 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
21517 }
21518 static void *_p_wxPaletteTo_p_wxObject(void *x) {
21519 return (void *)((wxObject *) (wxGDIObject *) ((wxPalette *) x));
21520 }
21521 static void *_p_wxBufferedDCTo_p_wxObject(void *x) {
21522 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *) ((wxBufferedDC *) x));
21523 }
21524 static void *_p_wxImageListTo_p_wxObject(void *x) {
21525 return (void *)((wxObject *) ((wxImageList *) x));
21526 }
21527 static void *_p_wxCursorTo_p_wxObject(void *x) {
21528 return (void *)((wxObject *) (wxGDIObject *) ((wxCursor *) x));
21529 }
21530 static void *_p_wxEncodingConverterTo_p_wxObject(void *x) {
21531 return (void *)((wxObject *) ((wxEncodingConverter *) x));
21532 }
21533 static void *_p_wxMirrorDCTo_p_wxObject(void *x) {
21534 return (void *)((wxObject *) (wxDC *) ((wxMirrorDC *) x));
21535 }
21536 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
21537 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21538 }
21539 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
21540 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
21541 }
21542 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
21543 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
21544 }
21545 static void *_p_wxWindowTo_p_wxObject(void *x) {
21546 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
21547 }
21548 static void *_p_wxMenuTo_p_wxObject(void *x) {
21549 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
21550 }
21551 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
21552 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
21553 }
21554 static void *_p_wxMetaFileDCTo_p_wxObject(void *x) {
21555 return (void *)((wxObject *) (wxDC *) ((wxMetaFileDC *) x));
21556 }
21557 static void *_p_wxBrushListTo_p_wxObject(void *x) {
21558 return (void *)((wxObject *) ((wxBrushList *) x));
21559 }
21560 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
21561 return (void *)((wxObject *) ((wxFileSystem *) x));
21562 }
21563 static void *_p_wxBitmapTo_p_wxObject(void *x) {
21564 return (void *)((wxObject *) (wxGDIObject *) ((wxBitmap *) x));
21565 }
21566 static void *_p_wxMaskTo_p_wxObject(void *x) {
21567 return (void *)((wxObject *) ((wxMask *) x));
21568 }
21569 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
21570 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
21571 }
21572 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
21573 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
21574 }
21575 static void *_p_wxPyAppTo_p_wxObject(void *x) {
21576 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
21577 }
21578 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
21579 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
21580 }
21581 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
21582 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
21583 }
21584 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
21585 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
21586 }
21587 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
21588 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
21589 }
21590 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
21591 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
21592 }
21593 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
21594 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
21595 }
21596 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
21597 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
21598 }
21599 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
21600 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
21601 }
21602 static void *_p_wxFontTo_p_wxObject(void *x) {
21603 return (void *)((wxObject *) (wxGDIObject *) ((wxFont *) x));
21604 }
21605 static void *_p_wxBrushTo_p_wxObject(void *x) {
21606 return (void *)((wxObject *) (wxGDIObject *) ((wxBrush *) x));
21607 }
21608 static void *_p_wxMetaFileTo_p_wxObject(void *x) {
21609 return (void *)((wxObject *) ((wxMetaFile *) x));
21610 }
21611 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
21612 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
21613 }
21614 static void *_p_wxColourTo_p_wxObject(void *x) {
21615 return (void *)((wxObject *) ((wxColour *) x));
21616 }
21617 static void *_p_wxFontListTo_p_wxObject(void *x) {
21618 return (void *)((wxObject *) ((wxFontList *) x));
21619 }
21620 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
21621 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
21622 }
21623 static void *_p_wxValidatorTo_p_wxObject(void *x) {
21624 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
21625 }
21626 static void *_p_wxControlTo_p_wxWindow(void *x) {
21627 return (void *)((wxWindow *) ((wxControl *) x));
21628 }
21629 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
21630 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
21631 }
21632 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
21633 return (void *)((wxWindow *) ((wxMenuBar *) x));
21634 }
21635 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}};
21636 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}};
21637 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}};
21638 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}};
21639 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}};
21640 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}};
21641 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}};
21642 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}};
21643 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}};
21644 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}};
21645 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}};
21646 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}};
21647 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}};
21648 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}};
21649 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}};
21650 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}};
21651 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}};
21652 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}};
21653 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}};
21654 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}};
21655 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}};
21656 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}};
21657 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}};
21658 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}};
21659 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}};
21660 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}};
21661 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}};
21662 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}};
21663 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}};
21664 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}};
21665 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}};
21666 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}};
21667 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}};
21668 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}};
21669 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}};
21670 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}};
21671 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}};
21672 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}};
21673 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}};
21674 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}};
21675 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}};
21676 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}};
21677 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}};
21678 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}};
21679 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}};
21680 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}};
21681 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}};
21682 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}};
21683 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}};
21684 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}};
21685 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}};
21686 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}};
21687 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}};
21688 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}};
21689 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}};
21690 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}};
21691 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}};
21692 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}};
21693 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}};
21694 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}};
21695 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}};
21696 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}};
21697
21698 static swig_type_info *swig_types_initial[] = {
21699 _swigt__p_wxPostScriptDC,
21700 _swigt__p_wxBrush,
21701 _swigt__p_wxColour,
21702 _swigt__p_wxDC,
21703 _swigt__p_wxMirrorDC,
21704 _swigt__p_form_ops_t,
21705 _swigt__p_wxDuplexMode,
21706 _swigt__p_wxPyFontEnumerator,
21707 _swigt__p_char,
21708 _swigt__p_wxIconLocation,
21709 _swigt__p_wxImage,
21710 _swigt__p_wxMetaFileDC,
21711 _swigt__p_wxMask,
21712 _swigt__p_wxSize,
21713 _swigt__p_wxFont,
21714 _swigt__p_wxWindow,
21715 _swigt__p_double,
21716 _swigt__p_wxMemoryDC,
21717 _swigt__p_wxFontMapper,
21718 _swigt__p_wxEffects,
21719 _swigt__p_wxNativeEncodingInfo,
21720 _swigt__p_wxPalette,
21721 _swigt__p_wxBitmap,
21722 _swigt__p_wxObject,
21723 _swigt__p_wxRegionIterator,
21724 _swigt__p_wxRect,
21725 _swigt__p_wxPaperSize,
21726 _swigt__p_wxString,
21727 _swigt__unsigned_int,
21728 _swigt__p_unsigned_int,
21729 _swigt__p_wxPrinterDC,
21730 _swigt__p_wxIconBundle,
21731 _swigt__p_wxPoint,
21732 _swigt__p_wxDash,
21733 _swigt__p_wxScreenDC,
21734 _swigt__p_wxCursor,
21735 _swigt__p_wxClientDC,
21736 _swigt__p_wxBufferedDC,
21737 _swigt__p_wxImageList,
21738 _swigt__p_unsigned_char,
21739 _swigt__p_wxGDIObject,
21740 _swigt__p_wxIcon,
21741 _swigt__p_wxLocale,
21742 _swigt__ptrdiff_t,
21743 _swigt__std__ptrdiff_t,
21744 _swigt__p_wxRegion,
21745 _swigt__p_wxConfigBase,
21746 _swigt__p_wxLanguageInfo,
21747 _swigt__p_wxWindowDC,
21748 _swigt__p_wxPrintData,
21749 _swigt__p_wxBrushList,
21750 _swigt__p_wxFontList,
21751 _swigt__p_wxPen,
21752 _swigt__p_wxBufferedPaintDC,
21753 _swigt__p_wxPaintDC,
21754 _swigt__p_wxPenList,
21755 _swigt__p_int,
21756 _swigt__p_wxMetaFile,
21757 _swigt__p_unsigned_long,
21758 _swigt__p_wxNativeFontInfo,
21759 _swigt__p_wxEncodingConverter,
21760 _swigt__p_wxColourDatabase,
21761 0
21762 };
21763
21764
21765 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
21766
21767 static swig_const_info swig_const_table[] = {
21768 {0, 0, 0, 0.0, 0, 0}};
21769
21770 #ifdef __cplusplus
21771 }
21772 #endif
21773
21774
21775 #ifdef __cplusplus
21776 extern "C" {
21777 #endif
21778
21779 /* Python-specific SWIG API */
21780 #define SWIG_newvarlink() SWIG_Python_newvarlink()
21781 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
21782 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
21783
21784 /* -----------------------------------------------------------------------------
21785 * global variable support code.
21786 * ----------------------------------------------------------------------------- */
21787
21788 typedef struct swig_globalvar {
21789 char *name; /* Name of global variable */
21790 PyObject *(*get_attr)(); /* Return the current value */
21791 int (*set_attr)(PyObject *); /* Set the value */
21792 struct swig_globalvar *next;
21793 } swig_globalvar;
21794
21795 typedef struct swig_varlinkobject {
21796 PyObject_HEAD
21797 swig_globalvar *vars;
21798 } swig_varlinkobject;
21799
21800 static PyObject *
21801 swig_varlink_repr(swig_varlinkobject *v) {
21802 v = v;
21803 return PyString_FromString("<Swig global variables>");
21804 }
21805
21806 static int
21807 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
21808 swig_globalvar *var;
21809 flags = flags;
21810 fprintf(fp,"Swig global variables { ");
21811 for (var = v->vars; var; var=var->next) {
21812 fprintf(fp,"%s", var->name);
21813 if (var->next) fprintf(fp,", ");
21814 }
21815 fprintf(fp," }\n");
21816 return 0;
21817 }
21818
21819 static PyObject *
21820 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
21821 swig_globalvar *var = v->vars;
21822 while (var) {
21823 if (strcmp(var->name,n) == 0) {
21824 return (*var->get_attr)();
21825 }
21826 var = var->next;
21827 }
21828 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
21829 return NULL;
21830 }
21831
21832 static int
21833 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
21834 swig_globalvar *var = v->vars;
21835 while (var) {
21836 if (strcmp(var->name,n) == 0) {
21837 return (*var->set_attr)(p);
21838 }
21839 var = var->next;
21840 }
21841 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
21842 return 1;
21843 }
21844
21845 static PyTypeObject varlinktype = {
21846 PyObject_HEAD_INIT(0)
21847 0, /* Number of items in variable part (ob_size) */
21848 (char *)"swigvarlink", /* Type name (tp_name) */
21849 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
21850 0, /* Itemsize (tp_itemsize) */
21851 0, /* Deallocator (tp_dealloc) */
21852 (printfunc) swig_varlink_print, /* Print (tp_print) */
21853 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
21854 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
21855 0, /* tp_compare */
21856 (reprfunc) swig_varlink_repr, /* tp_repr */
21857 0, /* tp_as_number */
21858 0, /* tp_as_sequence */
21859 0, /* tp_as_mapping */
21860 0, /* tp_hash */
21861 0, /* tp_call */
21862 0, /* tp_str */
21863 0, /* tp_getattro */
21864 0, /* tp_setattro */
21865 0, /* tp_as_buffer */
21866 0, /* tp_flags */
21867 0, /* tp_doc */
21868 #if PY_VERSION_HEX >= 0x02000000
21869 0, /* tp_traverse */
21870 0, /* tp_clear */
21871 #endif
21872 #if PY_VERSION_HEX >= 0x02010000
21873 0, /* tp_richcompare */
21874 0, /* tp_weaklistoffset */
21875 #endif
21876 #if PY_VERSION_HEX >= 0x02020000
21877 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
21878 #endif
21879 #if PY_VERSION_HEX >= 0x02030000
21880 0, /* tp_del */
21881 #endif
21882 #ifdef COUNT_ALLOCS
21883 0,0,0,0 /* tp_alloc -> tp_next */
21884 #endif
21885 };
21886
21887 /* Create a variable linking object for use later */
21888 static PyObject *
21889 SWIG_Python_newvarlink(void) {
21890 swig_varlinkobject *result = 0;
21891 result = PyMem_NEW(swig_varlinkobject,1);
21892 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
21893 result->ob_type = &varlinktype;
21894 result->vars = 0;
21895 result->ob_refcnt = 0;
21896 Py_XINCREF((PyObject *) result);
21897 return ((PyObject*) result);
21898 }
21899
21900 static void
21901 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
21902 swig_varlinkobject *v;
21903 swig_globalvar *gv;
21904 v= (swig_varlinkobject *) p;
21905 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
21906 gv->name = (char *) malloc(strlen(name)+1);
21907 strcpy(gv->name,name);
21908 gv->get_attr = get_attr;
21909 gv->set_attr = set_attr;
21910 gv->next = v->vars;
21911 v->vars = gv;
21912 }
21913
21914 /* -----------------------------------------------------------------------------
21915 * constants/methods manipulation
21916 * ----------------------------------------------------------------------------- */
21917
21918 /* Install Constants */
21919 static void
21920 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
21921 PyObject *obj = 0;
21922 size_t i;
21923 for (i = 0; constants[i].type; i++) {
21924 switch(constants[i].type) {
21925 case SWIG_PY_INT:
21926 obj = PyInt_FromLong(constants[i].lvalue);
21927 break;
21928 case SWIG_PY_FLOAT:
21929 obj = PyFloat_FromDouble(constants[i].dvalue);
21930 break;
21931 case SWIG_PY_STRING:
21932 if (constants[i].pvalue) {
21933 obj = PyString_FromString((char *) constants[i].pvalue);
21934 } else {
21935 Py_INCREF(Py_None);
21936 obj = Py_None;
21937 }
21938 break;
21939 case SWIG_PY_POINTER:
21940 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
21941 break;
21942 case SWIG_PY_BINARY:
21943 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
21944 break;
21945 default:
21946 obj = 0;
21947 break;
21948 }
21949 if (obj) {
21950 PyDict_SetItemString(d,constants[i].name,obj);
21951 Py_DECREF(obj);
21952 }
21953 }
21954 }
21955
21956 /* -----------------------------------------------------------------------------*/
21957 /* Fix SwigMethods to carry the callback ptrs when needed */
21958 /* -----------------------------------------------------------------------------*/
21959
21960 static void
21961 SWIG_Python_FixMethods(PyMethodDef *methods,
21962 swig_const_info *const_table,
21963 swig_type_info **types,
21964 swig_type_info **types_initial) {
21965 size_t i;
21966 for (i = 0; methods[i].ml_name; ++i) {
21967 char *c = methods[i].ml_doc;
21968 if (c && (c = strstr(c, "swig_ptr: "))) {
21969 int j;
21970 swig_const_info *ci = 0;
21971 char *name = c + 10;
21972 for (j = 0; const_table[j].type; j++) {
21973 if (strncmp(const_table[j].name, name,
21974 strlen(const_table[j].name)) == 0) {
21975 ci = &(const_table[j]);
21976 break;
21977 }
21978 }
21979 if (ci) {
21980 size_t shift = (ci->ptype) - types;
21981 swig_type_info *ty = types_initial[shift];
21982 size_t ldoc = (c - methods[i].ml_doc);
21983 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
21984 char *ndoc = (char*)malloc(ldoc + lptr + 10);
21985 char *buff = ndoc;
21986 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
21987 strncpy(buff, methods[i].ml_doc, ldoc);
21988 buff += ldoc;
21989 strncpy(buff, "swig_ptr: ", 10);
21990 buff += 10;
21991 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
21992 methods[i].ml_doc = ndoc;
21993 }
21994 }
21995 }
21996 }
21997
21998 /* -----------------------------------------------------------------------------*
21999 * Initialize type list
22000 * -----------------------------------------------------------------------------*/
22001
22002 #if PY_MAJOR_VERSION < 2
22003 /* PyModule_AddObject function was introduced in Python 2.0. The following function
22004 is copied out of Python/modsupport.c in python version 2.3.4 */
22005 static int
22006 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
22007 {
22008 PyObject *dict;
22009 if (!PyModule_Check(m)) {
22010 PyErr_SetString(PyExc_TypeError,
22011 "PyModule_AddObject() needs module as first arg");
22012 return -1;
22013 }
22014 if (!o) {
22015 PyErr_SetString(PyExc_TypeError,
22016 "PyModule_AddObject() needs non-NULL value");
22017 return -1;
22018 }
22019
22020 dict = PyModule_GetDict(m);
22021 if (dict == NULL) {
22022 /* Internal error -- modules must have a dict! */
22023 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
22024 PyModule_GetName(m));
22025 return -1;
22026 }
22027 if (PyDict_SetItemString(dict, name, o))
22028 return -1;
22029 Py_DECREF(o);
22030 return 0;
22031 }
22032 #endif
22033
22034 static swig_type_info **
22035 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
22036 static PyMethodDef swig_empty_runtime_method_table[] = {
22037 {
22038 NULL, NULL, 0, NULL
22039 }
22040 };/* Sentinel */
22041
22042 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
22043 swig_empty_runtime_method_table);
22044 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
22045 if (pointer && module) {
22046 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
22047 }
22048 return type_list_handle;
22049 }
22050
22051 static swig_type_info **
22052 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
22053 swig_type_info **type_pointer;
22054
22055 /* first check if module already created */
22056 type_pointer = SWIG_Python_GetTypeListHandle();
22057 if (type_pointer) {
22058 return type_pointer;
22059 } else {
22060 /* create a new module and variable */
22061 return SWIG_Python_SetTypeListHandle(type_list_handle);
22062 }
22063 }
22064
22065 #ifdef __cplusplus
22066 }
22067 #endif
22068
22069 /* -----------------------------------------------------------------------------*
22070 * Partial Init method
22071 * -----------------------------------------------------------------------------*/
22072
22073 #ifdef SWIG_LINK_RUNTIME
22074 #ifdef __cplusplus
22075 extern "C"
22076 #endif
22077 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
22078 #endif
22079
22080 #ifdef __cplusplus
22081 extern "C"
22082 #endif
22083 SWIGEXPORT(void) SWIG_init(void) {
22084 static PyObject *SWIG_globals = 0;
22085 static int typeinit = 0;
22086 PyObject *m, *d;
22087 int i;
22088 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
22089
22090 /* Fix SwigMethods to carry the callback ptrs when needed */
22091 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
22092
22093 m = Py_InitModule((char *) SWIG_name, SwigMethods);
22094 d = PyModule_GetDict(m);
22095
22096 if (!typeinit) {
22097 #ifdef SWIG_LINK_RUNTIME
22098 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
22099 #else
22100 # ifndef SWIG_STATIC_RUNTIME
22101 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
22102 # endif
22103 #endif
22104 for (i = 0; swig_types_initial[i]; i++) {
22105 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
22106 }
22107 typeinit = 1;
22108 }
22109 SWIG_InstallConstants(d,swig_const_table);
22110
22111 {
22112 PyDict_SetItemString(d,"OutRegion", SWIG_From_int((int)(wxOutRegion)));
22113 }
22114 {
22115 PyDict_SetItemString(d,"PartRegion", SWIG_From_int((int)(wxPartRegion)));
22116 }
22117 {
22118 PyDict_SetItemString(d,"InRegion", SWIG_From_int((int)(wxInRegion)));
22119 }
22120 {
22121 PyDict_SetItemString(d,"FONTFAMILY_DEFAULT", SWIG_From_int((int)(wxFONTFAMILY_DEFAULT)));
22122 }
22123 {
22124 PyDict_SetItemString(d,"FONTFAMILY_DECORATIVE", SWIG_From_int((int)(wxFONTFAMILY_DECORATIVE)));
22125 }
22126 {
22127 PyDict_SetItemString(d,"FONTFAMILY_ROMAN", SWIG_From_int((int)(wxFONTFAMILY_ROMAN)));
22128 }
22129 {
22130 PyDict_SetItemString(d,"FONTFAMILY_SCRIPT", SWIG_From_int((int)(wxFONTFAMILY_SCRIPT)));
22131 }
22132 {
22133 PyDict_SetItemString(d,"FONTFAMILY_SWISS", SWIG_From_int((int)(wxFONTFAMILY_SWISS)));
22134 }
22135 {
22136 PyDict_SetItemString(d,"FONTFAMILY_MODERN", SWIG_From_int((int)(wxFONTFAMILY_MODERN)));
22137 }
22138 {
22139 PyDict_SetItemString(d,"FONTFAMILY_TELETYPE", SWIG_From_int((int)(wxFONTFAMILY_TELETYPE)));
22140 }
22141 {
22142 PyDict_SetItemString(d,"FONTFAMILY_MAX", SWIG_From_int((int)(wxFONTFAMILY_MAX)));
22143 }
22144 {
22145 PyDict_SetItemString(d,"FONTFAMILY_UNKNOWN", SWIG_From_int((int)(wxFONTFAMILY_UNKNOWN)));
22146 }
22147 {
22148 PyDict_SetItemString(d,"FONTSTYLE_NORMAL", SWIG_From_int((int)(wxFONTSTYLE_NORMAL)));
22149 }
22150 {
22151 PyDict_SetItemString(d,"FONTSTYLE_ITALIC", SWIG_From_int((int)(wxFONTSTYLE_ITALIC)));
22152 }
22153 {
22154 PyDict_SetItemString(d,"FONTSTYLE_SLANT", SWIG_From_int((int)(wxFONTSTYLE_SLANT)));
22155 }
22156 {
22157 PyDict_SetItemString(d,"FONTSTYLE_MAX", SWIG_From_int((int)(wxFONTSTYLE_MAX)));
22158 }
22159 {
22160 PyDict_SetItemString(d,"FONTWEIGHT_NORMAL", SWIG_From_int((int)(wxFONTWEIGHT_NORMAL)));
22161 }
22162 {
22163 PyDict_SetItemString(d,"FONTWEIGHT_LIGHT", SWIG_From_int((int)(wxFONTWEIGHT_LIGHT)));
22164 }
22165 {
22166 PyDict_SetItemString(d,"FONTWEIGHT_BOLD", SWIG_From_int((int)(wxFONTWEIGHT_BOLD)));
22167 }
22168 {
22169 PyDict_SetItemString(d,"FONTWEIGHT_MAX", SWIG_From_int((int)(wxFONTWEIGHT_MAX)));
22170 }
22171 {
22172 PyDict_SetItemString(d,"FONTFLAG_DEFAULT", SWIG_From_int((int)(wxFONTFLAG_DEFAULT)));
22173 }
22174 {
22175 PyDict_SetItemString(d,"FONTFLAG_ITALIC", SWIG_From_int((int)(wxFONTFLAG_ITALIC)));
22176 }
22177 {
22178 PyDict_SetItemString(d,"FONTFLAG_SLANT", SWIG_From_int((int)(wxFONTFLAG_SLANT)));
22179 }
22180 {
22181 PyDict_SetItemString(d,"FONTFLAG_LIGHT", SWIG_From_int((int)(wxFONTFLAG_LIGHT)));
22182 }
22183 {
22184 PyDict_SetItemString(d,"FONTFLAG_BOLD", SWIG_From_int((int)(wxFONTFLAG_BOLD)));
22185 }
22186 {
22187 PyDict_SetItemString(d,"FONTFLAG_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_ANTIALIASED)));
22188 }
22189 {
22190 PyDict_SetItemString(d,"FONTFLAG_NOT_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_NOT_ANTIALIASED)));
22191 }
22192 {
22193 PyDict_SetItemString(d,"FONTFLAG_UNDERLINED", SWIG_From_int((int)(wxFONTFLAG_UNDERLINED)));
22194 }
22195 {
22196 PyDict_SetItemString(d,"FONTFLAG_STRIKETHROUGH", SWIG_From_int((int)(wxFONTFLAG_STRIKETHROUGH)));
22197 }
22198 {
22199 PyDict_SetItemString(d,"FONTFLAG_MASK", SWIG_From_int((int)(wxFONTFLAG_MASK)));
22200 }
22201 {
22202 PyDict_SetItemString(d,"FONTENCODING_SYSTEM", SWIG_From_int((int)(wxFONTENCODING_SYSTEM)));
22203 }
22204 {
22205 PyDict_SetItemString(d,"FONTENCODING_DEFAULT", SWIG_From_int((int)(wxFONTENCODING_DEFAULT)));
22206 }
22207 {
22208 PyDict_SetItemString(d,"FONTENCODING_ISO8859_1", SWIG_From_int((int)(wxFONTENCODING_ISO8859_1)));
22209 }
22210 {
22211 PyDict_SetItemString(d,"FONTENCODING_ISO8859_2", SWIG_From_int((int)(wxFONTENCODING_ISO8859_2)));
22212 }
22213 {
22214 PyDict_SetItemString(d,"FONTENCODING_ISO8859_3", SWIG_From_int((int)(wxFONTENCODING_ISO8859_3)));
22215 }
22216 {
22217 PyDict_SetItemString(d,"FONTENCODING_ISO8859_4", SWIG_From_int((int)(wxFONTENCODING_ISO8859_4)));
22218 }
22219 {
22220 PyDict_SetItemString(d,"FONTENCODING_ISO8859_5", SWIG_From_int((int)(wxFONTENCODING_ISO8859_5)));
22221 }
22222 {
22223 PyDict_SetItemString(d,"FONTENCODING_ISO8859_6", SWIG_From_int((int)(wxFONTENCODING_ISO8859_6)));
22224 }
22225 {
22226 PyDict_SetItemString(d,"FONTENCODING_ISO8859_7", SWIG_From_int((int)(wxFONTENCODING_ISO8859_7)));
22227 }
22228 {
22229 PyDict_SetItemString(d,"FONTENCODING_ISO8859_8", SWIG_From_int((int)(wxFONTENCODING_ISO8859_8)));
22230 }
22231 {
22232 PyDict_SetItemString(d,"FONTENCODING_ISO8859_9", SWIG_From_int((int)(wxFONTENCODING_ISO8859_9)));
22233 }
22234 {
22235 PyDict_SetItemString(d,"FONTENCODING_ISO8859_10", SWIG_From_int((int)(wxFONTENCODING_ISO8859_10)));
22236 }
22237 {
22238 PyDict_SetItemString(d,"FONTENCODING_ISO8859_11", SWIG_From_int((int)(wxFONTENCODING_ISO8859_11)));
22239 }
22240 {
22241 PyDict_SetItemString(d,"FONTENCODING_ISO8859_12", SWIG_From_int((int)(wxFONTENCODING_ISO8859_12)));
22242 }
22243 {
22244 PyDict_SetItemString(d,"FONTENCODING_ISO8859_13", SWIG_From_int((int)(wxFONTENCODING_ISO8859_13)));
22245 }
22246 {
22247 PyDict_SetItemString(d,"FONTENCODING_ISO8859_14", SWIG_From_int((int)(wxFONTENCODING_ISO8859_14)));
22248 }
22249 {
22250 PyDict_SetItemString(d,"FONTENCODING_ISO8859_15", SWIG_From_int((int)(wxFONTENCODING_ISO8859_15)));
22251 }
22252 {
22253 PyDict_SetItemString(d,"FONTENCODING_ISO8859_MAX", SWIG_From_int((int)(wxFONTENCODING_ISO8859_MAX)));
22254 }
22255 {
22256 PyDict_SetItemString(d,"FONTENCODING_KOI8", SWIG_From_int((int)(wxFONTENCODING_KOI8)));
22257 }
22258 {
22259 PyDict_SetItemString(d,"FONTENCODING_KOI8_U", SWIG_From_int((int)(wxFONTENCODING_KOI8_U)));
22260 }
22261 {
22262 PyDict_SetItemString(d,"FONTENCODING_ALTERNATIVE", SWIG_From_int((int)(wxFONTENCODING_ALTERNATIVE)));
22263 }
22264 {
22265 PyDict_SetItemString(d,"FONTENCODING_BULGARIAN", SWIG_From_int((int)(wxFONTENCODING_BULGARIAN)));
22266 }
22267 {
22268 PyDict_SetItemString(d,"FONTENCODING_CP437", SWIG_From_int((int)(wxFONTENCODING_CP437)));
22269 }
22270 {
22271 PyDict_SetItemString(d,"FONTENCODING_CP850", SWIG_From_int((int)(wxFONTENCODING_CP850)));
22272 }
22273 {
22274 PyDict_SetItemString(d,"FONTENCODING_CP852", SWIG_From_int((int)(wxFONTENCODING_CP852)));
22275 }
22276 {
22277 PyDict_SetItemString(d,"FONTENCODING_CP855", SWIG_From_int((int)(wxFONTENCODING_CP855)));
22278 }
22279 {
22280 PyDict_SetItemString(d,"FONTENCODING_CP866", SWIG_From_int((int)(wxFONTENCODING_CP866)));
22281 }
22282 {
22283 PyDict_SetItemString(d,"FONTENCODING_CP874", SWIG_From_int((int)(wxFONTENCODING_CP874)));
22284 }
22285 {
22286 PyDict_SetItemString(d,"FONTENCODING_CP932", SWIG_From_int((int)(wxFONTENCODING_CP932)));
22287 }
22288 {
22289 PyDict_SetItemString(d,"FONTENCODING_CP936", SWIG_From_int((int)(wxFONTENCODING_CP936)));
22290 }
22291 {
22292 PyDict_SetItemString(d,"FONTENCODING_CP949", SWIG_From_int((int)(wxFONTENCODING_CP949)));
22293 }
22294 {
22295 PyDict_SetItemString(d,"FONTENCODING_CP950", SWIG_From_int((int)(wxFONTENCODING_CP950)));
22296 }
22297 {
22298 PyDict_SetItemString(d,"FONTENCODING_CP1250", SWIG_From_int((int)(wxFONTENCODING_CP1250)));
22299 }
22300 {
22301 PyDict_SetItemString(d,"FONTENCODING_CP1251", SWIG_From_int((int)(wxFONTENCODING_CP1251)));
22302 }
22303 {
22304 PyDict_SetItemString(d,"FONTENCODING_CP1252", SWIG_From_int((int)(wxFONTENCODING_CP1252)));
22305 }
22306 {
22307 PyDict_SetItemString(d,"FONTENCODING_CP1253", SWIG_From_int((int)(wxFONTENCODING_CP1253)));
22308 }
22309 {
22310 PyDict_SetItemString(d,"FONTENCODING_CP1254", SWIG_From_int((int)(wxFONTENCODING_CP1254)));
22311 }
22312 {
22313 PyDict_SetItemString(d,"FONTENCODING_CP1255", SWIG_From_int((int)(wxFONTENCODING_CP1255)));
22314 }
22315 {
22316 PyDict_SetItemString(d,"FONTENCODING_CP1256", SWIG_From_int((int)(wxFONTENCODING_CP1256)));
22317 }
22318 {
22319 PyDict_SetItemString(d,"FONTENCODING_CP1257", SWIG_From_int((int)(wxFONTENCODING_CP1257)));
22320 }
22321 {
22322 PyDict_SetItemString(d,"FONTENCODING_CP12_MAX", SWIG_From_int((int)(wxFONTENCODING_CP12_MAX)));
22323 }
22324 {
22325 PyDict_SetItemString(d,"FONTENCODING_UTF7", SWIG_From_int((int)(wxFONTENCODING_UTF7)));
22326 }
22327 {
22328 PyDict_SetItemString(d,"FONTENCODING_UTF8", SWIG_From_int((int)(wxFONTENCODING_UTF8)));
22329 }
22330 {
22331 PyDict_SetItemString(d,"FONTENCODING_EUC_JP", SWIG_From_int((int)(wxFONTENCODING_EUC_JP)));
22332 }
22333 {
22334 PyDict_SetItemString(d,"FONTENCODING_UTF16BE", SWIG_From_int((int)(wxFONTENCODING_UTF16BE)));
22335 }
22336 {
22337 PyDict_SetItemString(d,"FONTENCODING_UTF16LE", SWIG_From_int((int)(wxFONTENCODING_UTF16LE)));
22338 }
22339 {
22340 PyDict_SetItemString(d,"FONTENCODING_UTF32BE", SWIG_From_int((int)(wxFONTENCODING_UTF32BE)));
22341 }
22342 {
22343 PyDict_SetItemString(d,"FONTENCODING_UTF32LE", SWIG_From_int((int)(wxFONTENCODING_UTF32LE)));
22344 }
22345 {
22346 PyDict_SetItemString(d,"FONTENCODING_MACROMAN", SWIG_From_int((int)(wxFONTENCODING_MACROMAN)));
22347 }
22348 {
22349 PyDict_SetItemString(d,"FONTENCODING_MACJAPANESE", SWIG_From_int((int)(wxFONTENCODING_MACJAPANESE)));
22350 }
22351 {
22352 PyDict_SetItemString(d,"FONTENCODING_MACCHINESETRAD", SWIG_From_int((int)(wxFONTENCODING_MACCHINESETRAD)));
22353 }
22354 {
22355 PyDict_SetItemString(d,"FONTENCODING_MACKOREAN", SWIG_From_int((int)(wxFONTENCODING_MACKOREAN)));
22356 }
22357 {
22358 PyDict_SetItemString(d,"FONTENCODING_MACARABIC", SWIG_From_int((int)(wxFONTENCODING_MACARABIC)));
22359 }
22360 {
22361 PyDict_SetItemString(d,"FONTENCODING_MACHEBREW", SWIG_From_int((int)(wxFONTENCODING_MACHEBREW)));
22362 }
22363 {
22364 PyDict_SetItemString(d,"FONTENCODING_MACGREEK", SWIG_From_int((int)(wxFONTENCODING_MACGREEK)));
22365 }
22366 {
22367 PyDict_SetItemString(d,"FONTENCODING_MACCYRILLIC", SWIG_From_int((int)(wxFONTENCODING_MACCYRILLIC)));
22368 }
22369 {
22370 PyDict_SetItemString(d,"FONTENCODING_MACDEVANAGARI", SWIG_From_int((int)(wxFONTENCODING_MACDEVANAGARI)));
22371 }
22372 {
22373 PyDict_SetItemString(d,"FONTENCODING_MACGURMUKHI", SWIG_From_int((int)(wxFONTENCODING_MACGURMUKHI)));
22374 }
22375 {
22376 PyDict_SetItemString(d,"FONTENCODING_MACGUJARATI", SWIG_From_int((int)(wxFONTENCODING_MACGUJARATI)));
22377 }
22378 {
22379 PyDict_SetItemString(d,"FONTENCODING_MACORIYA", SWIG_From_int((int)(wxFONTENCODING_MACORIYA)));
22380 }
22381 {
22382 PyDict_SetItemString(d,"FONTENCODING_MACBENGALI", SWIG_From_int((int)(wxFONTENCODING_MACBENGALI)));
22383 }
22384 {
22385 PyDict_SetItemString(d,"FONTENCODING_MACTAMIL", SWIG_From_int((int)(wxFONTENCODING_MACTAMIL)));
22386 }
22387 {
22388 PyDict_SetItemString(d,"FONTENCODING_MACTELUGU", SWIG_From_int((int)(wxFONTENCODING_MACTELUGU)));
22389 }
22390 {
22391 PyDict_SetItemString(d,"FONTENCODING_MACKANNADA", SWIG_From_int((int)(wxFONTENCODING_MACKANNADA)));
22392 }
22393 {
22394 PyDict_SetItemString(d,"FONTENCODING_MACMALAJALAM", SWIG_From_int((int)(wxFONTENCODING_MACMALAJALAM)));
22395 }
22396 {
22397 PyDict_SetItemString(d,"FONTENCODING_MACSINHALESE", SWIG_From_int((int)(wxFONTENCODING_MACSINHALESE)));
22398 }
22399 {
22400 PyDict_SetItemString(d,"FONTENCODING_MACBURMESE", SWIG_From_int((int)(wxFONTENCODING_MACBURMESE)));
22401 }
22402 {
22403 PyDict_SetItemString(d,"FONTENCODING_MACKHMER", SWIG_From_int((int)(wxFONTENCODING_MACKHMER)));
22404 }
22405 {
22406 PyDict_SetItemString(d,"FONTENCODING_MACTHAI", SWIG_From_int((int)(wxFONTENCODING_MACTHAI)));
22407 }
22408 {
22409 PyDict_SetItemString(d,"FONTENCODING_MACLAOTIAN", SWIG_From_int((int)(wxFONTENCODING_MACLAOTIAN)));
22410 }
22411 {
22412 PyDict_SetItemString(d,"FONTENCODING_MACGEORGIAN", SWIG_From_int((int)(wxFONTENCODING_MACGEORGIAN)));
22413 }
22414 {
22415 PyDict_SetItemString(d,"FONTENCODING_MACARMENIAN", SWIG_From_int((int)(wxFONTENCODING_MACARMENIAN)));
22416 }
22417 {
22418 PyDict_SetItemString(d,"FONTENCODING_MACCHINESESIMP", SWIG_From_int((int)(wxFONTENCODING_MACCHINESESIMP)));
22419 }
22420 {
22421 PyDict_SetItemString(d,"FONTENCODING_MACTIBETAN", SWIG_From_int((int)(wxFONTENCODING_MACTIBETAN)));
22422 }
22423 {
22424 PyDict_SetItemString(d,"FONTENCODING_MACMONGOLIAN", SWIG_From_int((int)(wxFONTENCODING_MACMONGOLIAN)));
22425 }
22426 {
22427 PyDict_SetItemString(d,"FONTENCODING_MACETHIOPIC", SWIG_From_int((int)(wxFONTENCODING_MACETHIOPIC)));
22428 }
22429 {
22430 PyDict_SetItemString(d,"FONTENCODING_MACCENTRALEUR", SWIG_From_int((int)(wxFONTENCODING_MACCENTRALEUR)));
22431 }
22432 {
22433 PyDict_SetItemString(d,"FONTENCODING_MACVIATNAMESE", SWIG_From_int((int)(wxFONTENCODING_MACVIATNAMESE)));
22434 }
22435 {
22436 PyDict_SetItemString(d,"FONTENCODING_MACARABICEXT", SWIG_From_int((int)(wxFONTENCODING_MACARABICEXT)));
22437 }
22438 {
22439 PyDict_SetItemString(d,"FONTENCODING_MACSYMBOL", SWIG_From_int((int)(wxFONTENCODING_MACSYMBOL)));
22440 }
22441 {
22442 PyDict_SetItemString(d,"FONTENCODING_MACDINGBATS", SWIG_From_int((int)(wxFONTENCODING_MACDINGBATS)));
22443 }
22444 {
22445 PyDict_SetItemString(d,"FONTENCODING_MACTURKISH", SWIG_From_int((int)(wxFONTENCODING_MACTURKISH)));
22446 }
22447 {
22448 PyDict_SetItemString(d,"FONTENCODING_MACCROATIAN", SWIG_From_int((int)(wxFONTENCODING_MACCROATIAN)));
22449 }
22450 {
22451 PyDict_SetItemString(d,"FONTENCODING_MACICELANDIC", SWIG_From_int((int)(wxFONTENCODING_MACICELANDIC)));
22452 }
22453 {
22454 PyDict_SetItemString(d,"FONTENCODING_MACROMANIAN", SWIG_From_int((int)(wxFONTENCODING_MACROMANIAN)));
22455 }
22456 {
22457 PyDict_SetItemString(d,"FONTENCODING_MACCELTIC", SWIG_From_int((int)(wxFONTENCODING_MACCELTIC)));
22458 }
22459 {
22460 PyDict_SetItemString(d,"FONTENCODING_MACGAELIC", SWIG_From_int((int)(wxFONTENCODING_MACGAELIC)));
22461 }
22462 {
22463 PyDict_SetItemString(d,"FONTENCODING_MACKEYBOARD", SWIG_From_int((int)(wxFONTENCODING_MACKEYBOARD)));
22464 }
22465 {
22466 PyDict_SetItemString(d,"FONTENCODING_MACMIN", SWIG_From_int((int)(wxFONTENCODING_MACMIN)));
22467 }
22468 {
22469 PyDict_SetItemString(d,"FONTENCODING_MACMAX", SWIG_From_int((int)(wxFONTENCODING_MACMAX)));
22470 }
22471 {
22472 PyDict_SetItemString(d,"FONTENCODING_MAX", SWIG_From_int((int)(wxFONTENCODING_MAX)));
22473 }
22474 {
22475 PyDict_SetItemString(d,"FONTENCODING_UTF16", SWIG_From_int((int)(wxFONTENCODING_UTF16)));
22476 }
22477 {
22478 PyDict_SetItemString(d,"FONTENCODING_UTF32", SWIG_From_int((int)(wxFONTENCODING_UTF32)));
22479 }
22480 {
22481 PyDict_SetItemString(d,"FONTENCODING_UNICODE", SWIG_From_int((int)(wxFONTENCODING_UNICODE)));
22482 }
22483 {
22484 PyDict_SetItemString(d,"FONTENCODING_GB2312", SWIG_From_int((int)(wxFONTENCODING_GB2312)));
22485 }
22486 {
22487 PyDict_SetItemString(d,"FONTENCODING_BIG5", SWIG_From_int((int)(wxFONTENCODING_BIG5)));
22488 }
22489 {
22490 PyDict_SetItemString(d,"FONTENCODING_SHIFT_JIS", SWIG_From_int((int)(wxFONTENCODING_SHIFT_JIS)));
22491 }
22492
22493 wxPyPtrTypeMap_Add("wxFontEnumerator", "wxPyFontEnumerator");
22494
22495 {
22496 PyDict_SetItemString(d,"LANGUAGE_DEFAULT", SWIG_From_int((int)(wxLANGUAGE_DEFAULT)));
22497 }
22498 {
22499 PyDict_SetItemString(d,"LANGUAGE_UNKNOWN", SWIG_From_int((int)(wxLANGUAGE_UNKNOWN)));
22500 }
22501 {
22502 PyDict_SetItemString(d,"LANGUAGE_ABKHAZIAN", SWIG_From_int((int)(wxLANGUAGE_ABKHAZIAN)));
22503 }
22504 {
22505 PyDict_SetItemString(d,"LANGUAGE_AFAR", SWIG_From_int((int)(wxLANGUAGE_AFAR)));
22506 }
22507 {
22508 PyDict_SetItemString(d,"LANGUAGE_AFRIKAANS", SWIG_From_int((int)(wxLANGUAGE_AFRIKAANS)));
22509 }
22510 {
22511 PyDict_SetItemString(d,"LANGUAGE_ALBANIAN", SWIG_From_int((int)(wxLANGUAGE_ALBANIAN)));
22512 }
22513 {
22514 PyDict_SetItemString(d,"LANGUAGE_AMHARIC", SWIG_From_int((int)(wxLANGUAGE_AMHARIC)));
22515 }
22516 {
22517 PyDict_SetItemString(d,"LANGUAGE_ARABIC", SWIG_From_int((int)(wxLANGUAGE_ARABIC)));
22518 }
22519 {
22520 PyDict_SetItemString(d,"LANGUAGE_ARABIC_ALGERIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_ALGERIA)));
22521 }
22522 {
22523 PyDict_SetItemString(d,"LANGUAGE_ARABIC_BAHRAIN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_BAHRAIN)));
22524 }
22525 {
22526 PyDict_SetItemString(d,"LANGUAGE_ARABIC_EGYPT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_EGYPT)));
22527 }
22528 {
22529 PyDict_SetItemString(d,"LANGUAGE_ARABIC_IRAQ", SWIG_From_int((int)(wxLANGUAGE_ARABIC_IRAQ)));
22530 }
22531 {
22532 PyDict_SetItemString(d,"LANGUAGE_ARABIC_JORDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_JORDAN)));
22533 }
22534 {
22535 PyDict_SetItemString(d,"LANGUAGE_ARABIC_KUWAIT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_KUWAIT)));
22536 }
22537 {
22538 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LEBANON", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LEBANON)));
22539 }
22540 {
22541 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LIBYA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LIBYA)));
22542 }
22543 {
22544 PyDict_SetItemString(d,"LANGUAGE_ARABIC_MOROCCO", SWIG_From_int((int)(wxLANGUAGE_ARABIC_MOROCCO)));
22545 }
22546 {
22547 PyDict_SetItemString(d,"LANGUAGE_ARABIC_OMAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_OMAN)));
22548 }
22549 {
22550 PyDict_SetItemString(d,"LANGUAGE_ARABIC_QATAR", SWIG_From_int((int)(wxLANGUAGE_ARABIC_QATAR)));
22551 }
22552 {
22553 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SAUDI_ARABIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SAUDI_ARABIA)));
22554 }
22555 {
22556 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SUDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SUDAN)));
22557 }
22558 {
22559 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SYRIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SYRIA)));
22560 }
22561 {
22562 PyDict_SetItemString(d,"LANGUAGE_ARABIC_TUNISIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_TUNISIA)));
22563 }
22564 {
22565 PyDict_SetItemString(d,"LANGUAGE_ARABIC_UAE", SWIG_From_int((int)(wxLANGUAGE_ARABIC_UAE)));
22566 }
22567 {
22568 PyDict_SetItemString(d,"LANGUAGE_ARABIC_YEMEN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_YEMEN)));
22569 }
22570 {
22571 PyDict_SetItemString(d,"LANGUAGE_ARMENIAN", SWIG_From_int((int)(wxLANGUAGE_ARMENIAN)));
22572 }
22573 {
22574 PyDict_SetItemString(d,"LANGUAGE_ASSAMESE", SWIG_From_int((int)(wxLANGUAGE_ASSAMESE)));
22575 }
22576 {
22577 PyDict_SetItemString(d,"LANGUAGE_AYMARA", SWIG_From_int((int)(wxLANGUAGE_AYMARA)));
22578 }
22579 {
22580 PyDict_SetItemString(d,"LANGUAGE_AZERI", SWIG_From_int((int)(wxLANGUAGE_AZERI)));
22581 }
22582 {
22583 PyDict_SetItemString(d,"LANGUAGE_AZERI_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_AZERI_CYRILLIC)));
22584 }
22585 {
22586 PyDict_SetItemString(d,"LANGUAGE_AZERI_LATIN", SWIG_From_int((int)(wxLANGUAGE_AZERI_LATIN)));
22587 }
22588 {
22589 PyDict_SetItemString(d,"LANGUAGE_BASHKIR", SWIG_From_int((int)(wxLANGUAGE_BASHKIR)));
22590 }
22591 {
22592 PyDict_SetItemString(d,"LANGUAGE_BASQUE", SWIG_From_int((int)(wxLANGUAGE_BASQUE)));
22593 }
22594 {
22595 PyDict_SetItemString(d,"LANGUAGE_BELARUSIAN", SWIG_From_int((int)(wxLANGUAGE_BELARUSIAN)));
22596 }
22597 {
22598 PyDict_SetItemString(d,"LANGUAGE_BENGALI", SWIG_From_int((int)(wxLANGUAGE_BENGALI)));
22599 }
22600 {
22601 PyDict_SetItemString(d,"LANGUAGE_BHUTANI", SWIG_From_int((int)(wxLANGUAGE_BHUTANI)));
22602 }
22603 {
22604 PyDict_SetItemString(d,"LANGUAGE_BIHARI", SWIG_From_int((int)(wxLANGUAGE_BIHARI)));
22605 }
22606 {
22607 PyDict_SetItemString(d,"LANGUAGE_BISLAMA", SWIG_From_int((int)(wxLANGUAGE_BISLAMA)));
22608 }
22609 {
22610 PyDict_SetItemString(d,"LANGUAGE_BRETON", SWIG_From_int((int)(wxLANGUAGE_BRETON)));
22611 }
22612 {
22613 PyDict_SetItemString(d,"LANGUAGE_BULGARIAN", SWIG_From_int((int)(wxLANGUAGE_BULGARIAN)));
22614 }
22615 {
22616 PyDict_SetItemString(d,"LANGUAGE_BURMESE", SWIG_From_int((int)(wxLANGUAGE_BURMESE)));
22617 }
22618 {
22619 PyDict_SetItemString(d,"LANGUAGE_CAMBODIAN", SWIG_From_int((int)(wxLANGUAGE_CAMBODIAN)));
22620 }
22621 {
22622 PyDict_SetItemString(d,"LANGUAGE_CATALAN", SWIG_From_int((int)(wxLANGUAGE_CATALAN)));
22623 }
22624 {
22625 PyDict_SetItemString(d,"LANGUAGE_CHINESE", SWIG_From_int((int)(wxLANGUAGE_CHINESE)));
22626 }
22627 {
22628 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SIMPLIFIED", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SIMPLIFIED)));
22629 }
22630 {
22631 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TRADITIONAL", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TRADITIONAL)));
22632 }
22633 {
22634 PyDict_SetItemString(d,"LANGUAGE_CHINESE_HONGKONG", SWIG_From_int((int)(wxLANGUAGE_CHINESE_HONGKONG)));
22635 }
22636 {
22637 PyDict_SetItemString(d,"LANGUAGE_CHINESE_MACAU", SWIG_From_int((int)(wxLANGUAGE_CHINESE_MACAU)));
22638 }
22639 {
22640 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SINGAPORE", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SINGAPORE)));
22641 }
22642 {
22643 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TAIWAN", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TAIWAN)));
22644 }
22645 {
22646 PyDict_SetItemString(d,"LANGUAGE_CORSICAN", SWIG_From_int((int)(wxLANGUAGE_CORSICAN)));
22647 }
22648 {
22649 PyDict_SetItemString(d,"LANGUAGE_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_CROATIAN)));
22650 }
22651 {
22652 PyDict_SetItemString(d,"LANGUAGE_CZECH", SWIG_From_int((int)(wxLANGUAGE_CZECH)));
22653 }
22654 {
22655 PyDict_SetItemString(d,"LANGUAGE_DANISH", SWIG_From_int((int)(wxLANGUAGE_DANISH)));
22656 }
22657 {
22658 PyDict_SetItemString(d,"LANGUAGE_DUTCH", SWIG_From_int((int)(wxLANGUAGE_DUTCH)));
22659 }
22660 {
22661 PyDict_SetItemString(d,"LANGUAGE_DUTCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_DUTCH_BELGIAN)));
22662 }
22663 {
22664 PyDict_SetItemString(d,"LANGUAGE_ENGLISH", SWIG_From_int((int)(wxLANGUAGE_ENGLISH)));
22665 }
22666 {
22667 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_UK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_UK)));
22668 }
22669 {
22670 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_US", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_US)));
22671 }
22672 {
22673 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_AUSTRALIA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_AUSTRALIA)));
22674 }
22675 {
22676 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BELIZE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BELIZE)));
22677 }
22678 {
22679 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BOTSWANA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BOTSWANA)));
22680 }
22681 {
22682 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CANADA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CANADA)));
22683 }
22684 {
22685 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CARIBBEAN", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CARIBBEAN)));
22686 }
22687 {
22688 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_DENMARK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_DENMARK)));
22689 }
22690 {
22691 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_EIRE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_EIRE)));
22692 }
22693 {
22694 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_JAMAICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_JAMAICA)));
22695 }
22696 {
22697 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_NEW_ZEALAND", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_NEW_ZEALAND)));
22698 }
22699 {
22700 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_PHILIPPINES", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_PHILIPPINES)));
22701 }
22702 {
22703 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_SOUTH_AFRICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_SOUTH_AFRICA)));
22704 }
22705 {
22706 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_TRINIDAD", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_TRINIDAD)));
22707 }
22708 {
22709 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_ZIMBABWE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_ZIMBABWE)));
22710 }
22711 {
22712 PyDict_SetItemString(d,"LANGUAGE_ESPERANTO", SWIG_From_int((int)(wxLANGUAGE_ESPERANTO)));
22713 }
22714 {
22715 PyDict_SetItemString(d,"LANGUAGE_ESTONIAN", SWIG_From_int((int)(wxLANGUAGE_ESTONIAN)));
22716 }
22717 {
22718 PyDict_SetItemString(d,"LANGUAGE_FAEROESE", SWIG_From_int((int)(wxLANGUAGE_FAEROESE)));
22719 }
22720 {
22721 PyDict_SetItemString(d,"LANGUAGE_FARSI", SWIG_From_int((int)(wxLANGUAGE_FARSI)));
22722 }
22723 {
22724 PyDict_SetItemString(d,"LANGUAGE_FIJI", SWIG_From_int((int)(wxLANGUAGE_FIJI)));
22725 }
22726 {
22727 PyDict_SetItemString(d,"LANGUAGE_FINNISH", SWIG_From_int((int)(wxLANGUAGE_FINNISH)));
22728 }
22729 {
22730 PyDict_SetItemString(d,"LANGUAGE_FRENCH", SWIG_From_int((int)(wxLANGUAGE_FRENCH)));
22731 }
22732 {
22733 PyDict_SetItemString(d,"LANGUAGE_FRENCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_BELGIAN)));
22734 }
22735 {
22736 PyDict_SetItemString(d,"LANGUAGE_FRENCH_CANADIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_CANADIAN)));
22737 }
22738 {
22739 PyDict_SetItemString(d,"LANGUAGE_FRENCH_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_FRENCH_LUXEMBOURG)));
22740 }
22741 {
22742 PyDict_SetItemString(d,"LANGUAGE_FRENCH_MONACO", SWIG_From_int((int)(wxLANGUAGE_FRENCH_MONACO)));
22743 }
22744 {
22745 PyDict_SetItemString(d,"LANGUAGE_FRENCH_SWISS", SWIG_From_int((int)(wxLANGUAGE_FRENCH_SWISS)));
22746 }
22747 {
22748 PyDict_SetItemString(d,"LANGUAGE_FRISIAN", SWIG_From_int((int)(wxLANGUAGE_FRISIAN)));
22749 }
22750 {
22751 PyDict_SetItemString(d,"LANGUAGE_GALICIAN", SWIG_From_int((int)(wxLANGUAGE_GALICIAN)));
22752 }
22753 {
22754 PyDict_SetItemString(d,"LANGUAGE_GEORGIAN", SWIG_From_int((int)(wxLANGUAGE_GEORGIAN)));
22755 }
22756 {
22757 PyDict_SetItemString(d,"LANGUAGE_GERMAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN)));
22758 }
22759 {
22760 PyDict_SetItemString(d,"LANGUAGE_GERMAN_AUSTRIAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_AUSTRIAN)));
22761 }
22762 {
22763 PyDict_SetItemString(d,"LANGUAGE_GERMAN_BELGIUM", SWIG_From_int((int)(wxLANGUAGE_GERMAN_BELGIUM)));
22764 }
22765 {
22766 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LIECHTENSTEIN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LIECHTENSTEIN)));
22767 }
22768 {
22769 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LUXEMBOURG)));
22770 }
22771 {
22772 PyDict_SetItemString(d,"LANGUAGE_GERMAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_GERMAN_SWISS)));
22773 }
22774 {
22775 PyDict_SetItemString(d,"LANGUAGE_GREEK", SWIG_From_int((int)(wxLANGUAGE_GREEK)));
22776 }
22777 {
22778 PyDict_SetItemString(d,"LANGUAGE_GREENLANDIC", SWIG_From_int((int)(wxLANGUAGE_GREENLANDIC)));
22779 }
22780 {
22781 PyDict_SetItemString(d,"LANGUAGE_GUARANI", SWIG_From_int((int)(wxLANGUAGE_GUARANI)));
22782 }
22783 {
22784 PyDict_SetItemString(d,"LANGUAGE_GUJARATI", SWIG_From_int((int)(wxLANGUAGE_GUJARATI)));
22785 }
22786 {
22787 PyDict_SetItemString(d,"LANGUAGE_HAUSA", SWIG_From_int((int)(wxLANGUAGE_HAUSA)));
22788 }
22789 {
22790 PyDict_SetItemString(d,"LANGUAGE_HEBREW", SWIG_From_int((int)(wxLANGUAGE_HEBREW)));
22791 }
22792 {
22793 PyDict_SetItemString(d,"LANGUAGE_HINDI", SWIG_From_int((int)(wxLANGUAGE_HINDI)));
22794 }
22795 {
22796 PyDict_SetItemString(d,"LANGUAGE_HUNGARIAN", SWIG_From_int((int)(wxLANGUAGE_HUNGARIAN)));
22797 }
22798 {
22799 PyDict_SetItemString(d,"LANGUAGE_ICELANDIC", SWIG_From_int((int)(wxLANGUAGE_ICELANDIC)));
22800 }
22801 {
22802 PyDict_SetItemString(d,"LANGUAGE_INDONESIAN", SWIG_From_int((int)(wxLANGUAGE_INDONESIAN)));
22803 }
22804 {
22805 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUA", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUA)));
22806 }
22807 {
22808 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUE", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUE)));
22809 }
22810 {
22811 PyDict_SetItemString(d,"LANGUAGE_INUKTITUT", SWIG_From_int((int)(wxLANGUAGE_INUKTITUT)));
22812 }
22813 {
22814 PyDict_SetItemString(d,"LANGUAGE_INUPIAK", SWIG_From_int((int)(wxLANGUAGE_INUPIAK)));
22815 }
22816 {
22817 PyDict_SetItemString(d,"LANGUAGE_IRISH", SWIG_From_int((int)(wxLANGUAGE_IRISH)));
22818 }
22819 {
22820 PyDict_SetItemString(d,"LANGUAGE_ITALIAN", SWIG_From_int((int)(wxLANGUAGE_ITALIAN)));
22821 }
22822 {
22823 PyDict_SetItemString(d,"LANGUAGE_ITALIAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_ITALIAN_SWISS)));
22824 }
22825 {
22826 PyDict_SetItemString(d,"LANGUAGE_JAPANESE", SWIG_From_int((int)(wxLANGUAGE_JAPANESE)));
22827 }
22828 {
22829 PyDict_SetItemString(d,"LANGUAGE_JAVANESE", SWIG_From_int((int)(wxLANGUAGE_JAVANESE)));
22830 }
22831 {
22832 PyDict_SetItemString(d,"LANGUAGE_KANNADA", SWIG_From_int((int)(wxLANGUAGE_KANNADA)));
22833 }
22834 {
22835 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI)));
22836 }
22837 {
22838 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI_INDIA", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI_INDIA)));
22839 }
22840 {
22841 PyDict_SetItemString(d,"LANGUAGE_KAZAKH", SWIG_From_int((int)(wxLANGUAGE_KAZAKH)));
22842 }
22843 {
22844 PyDict_SetItemString(d,"LANGUAGE_KERNEWEK", SWIG_From_int((int)(wxLANGUAGE_KERNEWEK)));
22845 }
22846 {
22847 PyDict_SetItemString(d,"LANGUAGE_KINYARWANDA", SWIG_From_int((int)(wxLANGUAGE_KINYARWANDA)));
22848 }
22849 {
22850 PyDict_SetItemString(d,"LANGUAGE_KIRGHIZ", SWIG_From_int((int)(wxLANGUAGE_KIRGHIZ)));
22851 }
22852 {
22853 PyDict_SetItemString(d,"LANGUAGE_KIRUNDI", SWIG_From_int((int)(wxLANGUAGE_KIRUNDI)));
22854 }
22855 {
22856 PyDict_SetItemString(d,"LANGUAGE_KONKANI", SWIG_From_int((int)(wxLANGUAGE_KONKANI)));
22857 }
22858 {
22859 PyDict_SetItemString(d,"LANGUAGE_KOREAN", SWIG_From_int((int)(wxLANGUAGE_KOREAN)));
22860 }
22861 {
22862 PyDict_SetItemString(d,"LANGUAGE_KURDISH", SWIG_From_int((int)(wxLANGUAGE_KURDISH)));
22863 }
22864 {
22865 PyDict_SetItemString(d,"LANGUAGE_LAOTHIAN", SWIG_From_int((int)(wxLANGUAGE_LAOTHIAN)));
22866 }
22867 {
22868 PyDict_SetItemString(d,"LANGUAGE_LATIN", SWIG_From_int((int)(wxLANGUAGE_LATIN)));
22869 }
22870 {
22871 PyDict_SetItemString(d,"LANGUAGE_LATVIAN", SWIG_From_int((int)(wxLANGUAGE_LATVIAN)));
22872 }
22873 {
22874 PyDict_SetItemString(d,"LANGUAGE_LINGALA", SWIG_From_int((int)(wxLANGUAGE_LINGALA)));
22875 }
22876 {
22877 PyDict_SetItemString(d,"LANGUAGE_LITHUANIAN", SWIG_From_int((int)(wxLANGUAGE_LITHUANIAN)));
22878 }
22879 {
22880 PyDict_SetItemString(d,"LANGUAGE_MACEDONIAN", SWIG_From_int((int)(wxLANGUAGE_MACEDONIAN)));
22881 }
22882 {
22883 PyDict_SetItemString(d,"LANGUAGE_MALAGASY", SWIG_From_int((int)(wxLANGUAGE_MALAGASY)));
22884 }
22885 {
22886 PyDict_SetItemString(d,"LANGUAGE_MALAY", SWIG_From_int((int)(wxLANGUAGE_MALAY)));
22887 }
22888 {
22889 PyDict_SetItemString(d,"LANGUAGE_MALAYALAM", SWIG_From_int((int)(wxLANGUAGE_MALAYALAM)));
22890 }
22891 {
22892 PyDict_SetItemString(d,"LANGUAGE_MALAY_BRUNEI_DARUSSALAM", SWIG_From_int((int)(wxLANGUAGE_MALAY_BRUNEI_DARUSSALAM)));
22893 }
22894 {
22895 PyDict_SetItemString(d,"LANGUAGE_MALAY_MALAYSIA", SWIG_From_int((int)(wxLANGUAGE_MALAY_MALAYSIA)));
22896 }
22897 {
22898 PyDict_SetItemString(d,"LANGUAGE_MALTESE", SWIG_From_int((int)(wxLANGUAGE_MALTESE)));
22899 }
22900 {
22901 PyDict_SetItemString(d,"LANGUAGE_MANIPURI", SWIG_From_int((int)(wxLANGUAGE_MANIPURI)));
22902 }
22903 {
22904 PyDict_SetItemString(d,"LANGUAGE_MAORI", SWIG_From_int((int)(wxLANGUAGE_MAORI)));
22905 }
22906 {
22907 PyDict_SetItemString(d,"LANGUAGE_MARATHI", SWIG_From_int((int)(wxLANGUAGE_MARATHI)));
22908 }
22909 {
22910 PyDict_SetItemString(d,"LANGUAGE_MOLDAVIAN", SWIG_From_int((int)(wxLANGUAGE_MOLDAVIAN)));
22911 }
22912 {
22913 PyDict_SetItemString(d,"LANGUAGE_MONGOLIAN", SWIG_From_int((int)(wxLANGUAGE_MONGOLIAN)));
22914 }
22915 {
22916 PyDict_SetItemString(d,"LANGUAGE_NAURU", SWIG_From_int((int)(wxLANGUAGE_NAURU)));
22917 }
22918 {
22919 PyDict_SetItemString(d,"LANGUAGE_NEPALI", SWIG_From_int((int)(wxLANGUAGE_NEPALI)));
22920 }
22921 {
22922 PyDict_SetItemString(d,"LANGUAGE_NEPALI_INDIA", SWIG_From_int((int)(wxLANGUAGE_NEPALI_INDIA)));
22923 }
22924 {
22925 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_BOKMAL", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_BOKMAL)));
22926 }
22927 {
22928 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_NYNORSK", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_NYNORSK)));
22929 }
22930 {
22931 PyDict_SetItemString(d,"LANGUAGE_OCCITAN", SWIG_From_int((int)(wxLANGUAGE_OCCITAN)));
22932 }
22933 {
22934 PyDict_SetItemString(d,"LANGUAGE_ORIYA", SWIG_From_int((int)(wxLANGUAGE_ORIYA)));
22935 }
22936 {
22937 PyDict_SetItemString(d,"LANGUAGE_OROMO", SWIG_From_int((int)(wxLANGUAGE_OROMO)));
22938 }
22939 {
22940 PyDict_SetItemString(d,"LANGUAGE_PASHTO", SWIG_From_int((int)(wxLANGUAGE_PASHTO)));
22941 }
22942 {
22943 PyDict_SetItemString(d,"LANGUAGE_POLISH", SWIG_From_int((int)(wxLANGUAGE_POLISH)));
22944 }
22945 {
22946 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE)));
22947 }
22948 {
22949 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE_BRAZILIAN", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE_BRAZILIAN)));
22950 }
22951 {
22952 PyDict_SetItemString(d,"LANGUAGE_PUNJABI", SWIG_From_int((int)(wxLANGUAGE_PUNJABI)));
22953 }
22954 {
22955 PyDict_SetItemString(d,"LANGUAGE_QUECHUA", SWIG_From_int((int)(wxLANGUAGE_QUECHUA)));
22956 }
22957 {
22958 PyDict_SetItemString(d,"LANGUAGE_RHAETO_ROMANCE", SWIG_From_int((int)(wxLANGUAGE_RHAETO_ROMANCE)));
22959 }
22960 {
22961 PyDict_SetItemString(d,"LANGUAGE_ROMANIAN", SWIG_From_int((int)(wxLANGUAGE_ROMANIAN)));
22962 }
22963 {
22964 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN)));
22965 }
22966 {
22967 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN_UKRAINE", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN_UKRAINE)));
22968 }
22969 {
22970 PyDict_SetItemString(d,"LANGUAGE_SAMOAN", SWIG_From_int((int)(wxLANGUAGE_SAMOAN)));
22971 }
22972 {
22973 PyDict_SetItemString(d,"LANGUAGE_SANGHO", SWIG_From_int((int)(wxLANGUAGE_SANGHO)));
22974 }
22975 {
22976 PyDict_SetItemString(d,"LANGUAGE_SANSKRIT", SWIG_From_int((int)(wxLANGUAGE_SANSKRIT)));
22977 }
22978 {
22979 PyDict_SetItemString(d,"LANGUAGE_SCOTS_GAELIC", SWIG_From_int((int)(wxLANGUAGE_SCOTS_GAELIC)));
22980 }
22981 {
22982 PyDict_SetItemString(d,"LANGUAGE_SERBIAN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN)));
22983 }
22984 {
22985 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_CYRILLIC)));
22986 }
22987 {
22988 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_LATIN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_LATIN)));
22989 }
22990 {
22991 PyDict_SetItemString(d,"LANGUAGE_SERBO_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_SERBO_CROATIAN)));
22992 }
22993 {
22994 PyDict_SetItemString(d,"LANGUAGE_SESOTHO", SWIG_From_int((int)(wxLANGUAGE_SESOTHO)));
22995 }
22996 {
22997 PyDict_SetItemString(d,"LANGUAGE_SETSWANA", SWIG_From_int((int)(wxLANGUAGE_SETSWANA)));
22998 }
22999 {
23000 PyDict_SetItemString(d,"LANGUAGE_SHONA", SWIG_From_int((int)(wxLANGUAGE_SHONA)));
23001 }
23002 {
23003 PyDict_SetItemString(d,"LANGUAGE_SINDHI", SWIG_From_int((int)(wxLANGUAGE_SINDHI)));
23004 }
23005 {
23006 PyDict_SetItemString(d,"LANGUAGE_SINHALESE", SWIG_From_int((int)(wxLANGUAGE_SINHALESE)));
23007 }
23008 {
23009 PyDict_SetItemString(d,"LANGUAGE_SISWATI", SWIG_From_int((int)(wxLANGUAGE_SISWATI)));
23010 }
23011 {
23012 PyDict_SetItemString(d,"LANGUAGE_SLOVAK", SWIG_From_int((int)(wxLANGUAGE_SLOVAK)));
23013 }
23014 {
23015 PyDict_SetItemString(d,"LANGUAGE_SLOVENIAN", SWIG_From_int((int)(wxLANGUAGE_SLOVENIAN)));
23016 }
23017 {
23018 PyDict_SetItemString(d,"LANGUAGE_SOMALI", SWIG_From_int((int)(wxLANGUAGE_SOMALI)));
23019 }
23020 {
23021 PyDict_SetItemString(d,"LANGUAGE_SPANISH", SWIG_From_int((int)(wxLANGUAGE_SPANISH)));
23022 }
23023 {
23024 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ARGENTINA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ARGENTINA)));
23025 }
23026 {
23027 PyDict_SetItemString(d,"LANGUAGE_SPANISH_BOLIVIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_BOLIVIA)));
23028 }
23029 {
23030 PyDict_SetItemString(d,"LANGUAGE_SPANISH_CHILE", SWIG_From_int((int)(wxLANGUAGE_SPANISH_CHILE)));
23031 }
23032 {
23033 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COLOMBIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COLOMBIA)));
23034 }
23035 {
23036 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COSTA_RICA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COSTA_RICA)));
23037 }
23038 {
23039 PyDict_SetItemString(d,"LANGUAGE_SPANISH_DOMINICAN_REPUBLIC", SWIG_From_int((int)(wxLANGUAGE_SPANISH_DOMINICAN_REPUBLIC)));
23040 }
23041 {
23042 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ECUADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ECUADOR)));
23043 }
23044 {
23045 PyDict_SetItemString(d,"LANGUAGE_SPANISH_EL_SALVADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_EL_SALVADOR)));
23046 }
23047 {
23048 PyDict_SetItemString(d,"LANGUAGE_SPANISH_GUATEMALA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_GUATEMALA)));
23049 }
23050 {
23051 PyDict_SetItemString(d,"LANGUAGE_SPANISH_HONDURAS", SWIG_From_int((int)(wxLANGUAGE_SPANISH_HONDURAS)));
23052 }
23053 {
23054 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MEXICAN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MEXICAN)));
23055 }
23056 {
23057 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MODERN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MODERN)));
23058 }
23059 {
23060 PyDict_SetItemString(d,"LANGUAGE_SPANISH_NICARAGUA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_NICARAGUA)));
23061 }
23062 {
23063 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PANAMA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PANAMA)));
23064 }
23065 {
23066 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PARAGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PARAGUAY)));
23067 }
23068 {
23069 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PERU", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PERU)));
23070 }
23071 {
23072 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PUERTO_RICO", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PUERTO_RICO)));
23073 }
23074 {
23075 PyDict_SetItemString(d,"LANGUAGE_SPANISH_URUGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_URUGUAY)));
23076 }
23077 {
23078 PyDict_SetItemString(d,"LANGUAGE_SPANISH_US", SWIG_From_int((int)(wxLANGUAGE_SPANISH_US)));
23079 }
23080 {
23081 PyDict_SetItemString(d,"LANGUAGE_SPANISH_VENEZUELA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_VENEZUELA)));
23082 }
23083 {
23084 PyDict_SetItemString(d,"LANGUAGE_SUNDANESE", SWIG_From_int((int)(wxLANGUAGE_SUNDANESE)));
23085 }
23086 {
23087 PyDict_SetItemString(d,"LANGUAGE_SWAHILI", SWIG_From_int((int)(wxLANGUAGE_SWAHILI)));
23088 }
23089 {
23090 PyDict_SetItemString(d,"LANGUAGE_SWEDISH", SWIG_From_int((int)(wxLANGUAGE_SWEDISH)));
23091 }
23092 {
23093 PyDict_SetItemString(d,"LANGUAGE_SWEDISH_FINLAND", SWIG_From_int((int)(wxLANGUAGE_SWEDISH_FINLAND)));
23094 }
23095 {
23096 PyDict_SetItemString(d,"LANGUAGE_TAGALOG", SWIG_From_int((int)(wxLANGUAGE_TAGALOG)));
23097 }
23098 {
23099 PyDict_SetItemString(d,"LANGUAGE_TAJIK", SWIG_From_int((int)(wxLANGUAGE_TAJIK)));
23100 }
23101 {
23102 PyDict_SetItemString(d,"LANGUAGE_TAMIL", SWIG_From_int((int)(wxLANGUAGE_TAMIL)));
23103 }
23104 {
23105 PyDict_SetItemString(d,"LANGUAGE_TATAR", SWIG_From_int((int)(wxLANGUAGE_TATAR)));
23106 }
23107 {
23108 PyDict_SetItemString(d,"LANGUAGE_TELUGU", SWIG_From_int((int)(wxLANGUAGE_TELUGU)));
23109 }
23110 {
23111 PyDict_SetItemString(d,"LANGUAGE_THAI", SWIG_From_int((int)(wxLANGUAGE_THAI)));
23112 }
23113 {
23114 PyDict_SetItemString(d,"LANGUAGE_TIBETAN", SWIG_From_int((int)(wxLANGUAGE_TIBETAN)));
23115 }
23116 {
23117 PyDict_SetItemString(d,"LANGUAGE_TIGRINYA", SWIG_From_int((int)(wxLANGUAGE_TIGRINYA)));
23118 }
23119 {
23120 PyDict_SetItemString(d,"LANGUAGE_TONGA", SWIG_From_int((int)(wxLANGUAGE_TONGA)));
23121 }
23122 {
23123 PyDict_SetItemString(d,"LANGUAGE_TSONGA", SWIG_From_int((int)(wxLANGUAGE_TSONGA)));
23124 }
23125 {
23126 PyDict_SetItemString(d,"LANGUAGE_TURKISH", SWIG_From_int((int)(wxLANGUAGE_TURKISH)));
23127 }
23128 {
23129 PyDict_SetItemString(d,"LANGUAGE_TURKMEN", SWIG_From_int((int)(wxLANGUAGE_TURKMEN)));
23130 }
23131 {
23132 PyDict_SetItemString(d,"LANGUAGE_TWI", SWIG_From_int((int)(wxLANGUAGE_TWI)));
23133 }
23134 {
23135 PyDict_SetItemString(d,"LANGUAGE_UIGHUR", SWIG_From_int((int)(wxLANGUAGE_UIGHUR)));
23136 }
23137 {
23138 PyDict_SetItemString(d,"LANGUAGE_UKRAINIAN", SWIG_From_int((int)(wxLANGUAGE_UKRAINIAN)));
23139 }
23140 {
23141 PyDict_SetItemString(d,"LANGUAGE_URDU", SWIG_From_int((int)(wxLANGUAGE_URDU)));
23142 }
23143 {
23144 PyDict_SetItemString(d,"LANGUAGE_URDU_INDIA", SWIG_From_int((int)(wxLANGUAGE_URDU_INDIA)));
23145 }
23146 {
23147 PyDict_SetItemString(d,"LANGUAGE_URDU_PAKISTAN", SWIG_From_int((int)(wxLANGUAGE_URDU_PAKISTAN)));
23148 }
23149 {
23150 PyDict_SetItemString(d,"LANGUAGE_UZBEK", SWIG_From_int((int)(wxLANGUAGE_UZBEK)));
23151 }
23152 {
23153 PyDict_SetItemString(d,"LANGUAGE_UZBEK_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_UZBEK_CYRILLIC)));
23154 }
23155 {
23156 PyDict_SetItemString(d,"LANGUAGE_UZBEK_LATIN", SWIG_From_int((int)(wxLANGUAGE_UZBEK_LATIN)));
23157 }
23158 {
23159 PyDict_SetItemString(d,"LANGUAGE_VIETNAMESE", SWIG_From_int((int)(wxLANGUAGE_VIETNAMESE)));
23160 }
23161 {
23162 PyDict_SetItemString(d,"LANGUAGE_VOLAPUK", SWIG_From_int((int)(wxLANGUAGE_VOLAPUK)));
23163 }
23164 {
23165 PyDict_SetItemString(d,"LANGUAGE_WELSH", SWIG_From_int((int)(wxLANGUAGE_WELSH)));
23166 }
23167 {
23168 PyDict_SetItemString(d,"LANGUAGE_WOLOF", SWIG_From_int((int)(wxLANGUAGE_WOLOF)));
23169 }
23170 {
23171 PyDict_SetItemString(d,"LANGUAGE_XHOSA", SWIG_From_int((int)(wxLANGUAGE_XHOSA)));
23172 }
23173 {
23174 PyDict_SetItemString(d,"LANGUAGE_YIDDISH", SWIG_From_int((int)(wxLANGUAGE_YIDDISH)));
23175 }
23176 {
23177 PyDict_SetItemString(d,"LANGUAGE_YORUBA", SWIG_From_int((int)(wxLANGUAGE_YORUBA)));
23178 }
23179 {
23180 PyDict_SetItemString(d,"LANGUAGE_ZHUANG", SWIG_From_int((int)(wxLANGUAGE_ZHUANG)));
23181 }
23182 {
23183 PyDict_SetItemString(d,"LANGUAGE_ZULU", SWIG_From_int((int)(wxLANGUAGE_ZULU)));
23184 }
23185 {
23186 PyDict_SetItemString(d,"LANGUAGE_USER_DEFINED", SWIG_From_int((int)(wxLANGUAGE_USER_DEFINED)));
23187 }
23188 {
23189 PyDict_SetItemString(d,"LOCALE_CAT_NUMBER", SWIG_From_int((int)(wxLOCALE_CAT_NUMBER)));
23190 }
23191 {
23192 PyDict_SetItemString(d,"LOCALE_CAT_DATE", SWIG_From_int((int)(wxLOCALE_CAT_DATE)));
23193 }
23194 {
23195 PyDict_SetItemString(d,"LOCALE_CAT_MONEY", SWIG_From_int((int)(wxLOCALE_CAT_MONEY)));
23196 }
23197 {
23198 PyDict_SetItemString(d,"LOCALE_CAT_MAX", SWIG_From_int((int)(wxLOCALE_CAT_MAX)));
23199 }
23200 {
23201 PyDict_SetItemString(d,"LOCALE_THOUSANDS_SEP", SWIG_From_int((int)(wxLOCALE_THOUSANDS_SEP)));
23202 }
23203 {
23204 PyDict_SetItemString(d,"LOCALE_DECIMAL_POINT", SWIG_From_int((int)(wxLOCALE_DECIMAL_POINT)));
23205 }
23206 {
23207 PyDict_SetItemString(d,"LOCALE_LOAD_DEFAULT", SWIG_From_int((int)(wxLOCALE_LOAD_DEFAULT)));
23208 }
23209 {
23210 PyDict_SetItemString(d,"LOCALE_CONV_ENCODING", SWIG_From_int((int)(wxLOCALE_CONV_ENCODING)));
23211 }
23212 {
23213 PyDict_SetItemString(d,"CONVERT_STRICT", SWIG_From_int((int)(wxCONVERT_STRICT)));
23214 }
23215 {
23216 PyDict_SetItemString(d,"CONVERT_SUBSTITUTE", SWIG_From_int((int)(wxCONVERT_SUBSTITUTE)));
23217 }
23218 {
23219 PyDict_SetItemString(d,"PLATFORM_CURRENT", SWIG_From_int((int)(wxPLATFORM_CURRENT)));
23220 }
23221 {
23222 PyDict_SetItemString(d,"PLATFORM_UNIX", SWIG_From_int((int)(wxPLATFORM_UNIX)));
23223 }
23224 {
23225 PyDict_SetItemString(d,"PLATFORM_WINDOWS", SWIG_From_int((int)(wxPLATFORM_WINDOWS)));
23226 }
23227 {
23228 PyDict_SetItemString(d,"PLATFORM_OS2", SWIG_From_int((int)(wxPLATFORM_OS2)));
23229 }
23230 {
23231 PyDict_SetItemString(d,"PLATFORM_MAC", SWIG_From_int((int)(wxPLATFORM_MAC)));
23232 }
23233 {
23234 PyDict_SetItemString(d,"BUFFER_VIRTUAL_AREA", SWIG_From_int((int)(wxBUFFER_VIRTUAL_AREA)));
23235 }
23236 {
23237 PyDict_SetItemString(d,"BUFFER_CLIENT_AREA", SWIG_From_int((int)(wxBUFFER_CLIENT_AREA)));
23238 }
23239 {
23240 PyDict_SetItemString(d,"IMAGELIST_DRAW_NORMAL", SWIG_From_int((int)(wxIMAGELIST_DRAW_NORMAL)));
23241 }
23242 {
23243 PyDict_SetItemString(d,"IMAGELIST_DRAW_TRANSPARENT", SWIG_From_int((int)(wxIMAGELIST_DRAW_TRANSPARENT)));
23244 }
23245 {
23246 PyDict_SetItemString(d,"IMAGELIST_DRAW_SELECTED", SWIG_From_int((int)(wxIMAGELIST_DRAW_SELECTED)));
23247 }
23248 {
23249 PyDict_SetItemString(d,"IMAGELIST_DRAW_FOCUSED", SWIG_From_int((int)(wxIMAGELIST_DRAW_FOCUSED)));
23250 }
23251 {
23252 PyDict_SetItemString(d,"IMAGE_LIST_NORMAL", SWIG_From_int((int)(wxIMAGE_LIST_NORMAL)));
23253 }
23254 {
23255 PyDict_SetItemString(d,"IMAGE_LIST_SMALL", SWIG_From_int((int)(wxIMAGE_LIST_SMALL)));
23256 }
23257 {
23258 PyDict_SetItemString(d,"IMAGE_LIST_STATE", SWIG_From_int((int)(wxIMAGE_LIST_STATE)));
23259 }
23260 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
23261 SWIG_addvarlink(SWIG_globals,(char*)"NORMAL_FONT",_wrap_NORMAL_FONT_get, _wrap_NORMAL_FONT_set);
23262 SWIG_addvarlink(SWIG_globals,(char*)"SMALL_FONT",_wrap_SMALL_FONT_get, _wrap_SMALL_FONT_set);
23263 SWIG_addvarlink(SWIG_globals,(char*)"ITALIC_FONT",_wrap_ITALIC_FONT_get, _wrap_ITALIC_FONT_set);
23264 SWIG_addvarlink(SWIG_globals,(char*)"SWISS_FONT",_wrap_SWISS_FONT_get, _wrap_SWISS_FONT_set);
23265 SWIG_addvarlink(SWIG_globals,(char*)"RED_PEN",_wrap_RED_PEN_get, _wrap_RED_PEN_set);
23266 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_PEN",_wrap_CYAN_PEN_get, _wrap_CYAN_PEN_set);
23267 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_PEN",_wrap_GREEN_PEN_get, _wrap_GREEN_PEN_set);
23268 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_PEN",_wrap_BLACK_PEN_get, _wrap_BLACK_PEN_set);
23269 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_PEN",_wrap_WHITE_PEN_get, _wrap_WHITE_PEN_set);
23270 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_PEN",_wrap_TRANSPARENT_PEN_get, _wrap_TRANSPARENT_PEN_set);
23271 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_DASHED_PEN",_wrap_BLACK_DASHED_PEN_get, _wrap_BLACK_DASHED_PEN_set);
23272 SWIG_addvarlink(SWIG_globals,(char*)"GREY_PEN",_wrap_GREY_PEN_get, _wrap_GREY_PEN_set);
23273 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_PEN",_wrap_MEDIUM_GREY_PEN_get, _wrap_MEDIUM_GREY_PEN_set);
23274 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_PEN",_wrap_LIGHT_GREY_PEN_get, _wrap_LIGHT_GREY_PEN_set);
23275 SWIG_addvarlink(SWIG_globals,(char*)"BLUE_BRUSH",_wrap_BLUE_BRUSH_get, _wrap_BLUE_BRUSH_set);
23276 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_BRUSH",_wrap_GREEN_BRUSH_get, _wrap_GREEN_BRUSH_set);
23277 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_BRUSH",_wrap_WHITE_BRUSH_get, _wrap_WHITE_BRUSH_set);
23278 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_BRUSH",_wrap_BLACK_BRUSH_get, _wrap_BLACK_BRUSH_set);
23279 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_BRUSH",_wrap_TRANSPARENT_BRUSH_get, _wrap_TRANSPARENT_BRUSH_set);
23280 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_BRUSH",_wrap_CYAN_BRUSH_get, _wrap_CYAN_BRUSH_set);
23281 SWIG_addvarlink(SWIG_globals,(char*)"RED_BRUSH",_wrap_RED_BRUSH_get, _wrap_RED_BRUSH_set);
23282 SWIG_addvarlink(SWIG_globals,(char*)"GREY_BRUSH",_wrap_GREY_BRUSH_get, _wrap_GREY_BRUSH_set);
23283 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_BRUSH",_wrap_MEDIUM_GREY_BRUSH_get, _wrap_MEDIUM_GREY_BRUSH_set);
23284 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_BRUSH",_wrap_LIGHT_GREY_BRUSH_get, _wrap_LIGHT_GREY_BRUSH_set);
23285 SWIG_addvarlink(SWIG_globals,(char*)"BLACK",_wrap_BLACK_get, _wrap_BLACK_set);
23286 SWIG_addvarlink(SWIG_globals,(char*)"WHITE",_wrap_WHITE_get, _wrap_WHITE_set);
23287 SWIG_addvarlink(SWIG_globals,(char*)"RED",_wrap_RED_get, _wrap_RED_set);
23288 SWIG_addvarlink(SWIG_globals,(char*)"BLUE",_wrap_BLUE_get, _wrap_BLUE_set);
23289 SWIG_addvarlink(SWIG_globals,(char*)"GREEN",_wrap_GREEN_get, _wrap_GREEN_set);
23290 SWIG_addvarlink(SWIG_globals,(char*)"CYAN",_wrap_CYAN_get, _wrap_CYAN_set);
23291 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY",_wrap_LIGHT_GREY_get, _wrap_LIGHT_GREY_set);
23292 SWIG_addvarlink(SWIG_globals,(char*)"STANDARD_CURSOR",_wrap_STANDARD_CURSOR_get, _wrap_STANDARD_CURSOR_set);
23293 SWIG_addvarlink(SWIG_globals,(char*)"HOURGLASS_CURSOR",_wrap_HOURGLASS_CURSOR_get, _wrap_HOURGLASS_CURSOR_set);
23294 SWIG_addvarlink(SWIG_globals,(char*)"CROSS_CURSOR",_wrap_CROSS_CURSOR_get, _wrap_CROSS_CURSOR_set);
23295 SWIG_addvarlink(SWIG_globals,(char*)"NullBitmap",_wrap_NullBitmap_get, _wrap_NullBitmap_set);
23296 SWIG_addvarlink(SWIG_globals,(char*)"NullIcon",_wrap_NullIcon_get, _wrap_NullIcon_set);
23297 SWIG_addvarlink(SWIG_globals,(char*)"NullCursor",_wrap_NullCursor_get, _wrap_NullCursor_set);
23298 SWIG_addvarlink(SWIG_globals,(char*)"NullPen",_wrap_NullPen_get, _wrap_NullPen_set);
23299 SWIG_addvarlink(SWIG_globals,(char*)"NullBrush",_wrap_NullBrush_get, _wrap_NullBrush_set);
23300 SWIG_addvarlink(SWIG_globals,(char*)"NullPalette",_wrap_NullPalette_get, _wrap_NullPalette_set);
23301 SWIG_addvarlink(SWIG_globals,(char*)"NullFont",_wrap_NullFont_get, _wrap_NullFont_set);
23302 SWIG_addvarlink(SWIG_globals,(char*)"NullColour",_wrap_NullColour_get, _wrap_NullColour_set);
23303 SWIG_addvarlink(SWIG_globals,(char*)"TheFontList",_wrap_TheFontList_get, _wrap_TheFontList_set);
23304 SWIG_addvarlink(SWIG_globals,(char*)"ThePenList",_wrap_ThePenList_get, _wrap_ThePenList_set);
23305 SWIG_addvarlink(SWIG_globals,(char*)"TheBrushList",_wrap_TheBrushList_get, _wrap_TheBrushList_set);
23306 SWIG_addvarlink(SWIG_globals,(char*)"TheColourDatabase",_wrap_TheColourDatabase_get, _wrap_TheColourDatabase_set);
23307
23308 // Work around a chicken/egg problem in drawlist.cpp
23309 wxPyDrawList_SetAPIPtr();
23310
23311 }
23312
wxWidgets (Impactor)