]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_gdi_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Added EVT_COMMAND_TREE_ITEM_MENU
[wxWidgets.git] / wxPython / src / gtk / _gdi_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxPostScriptDC swig_types[0]
1342 #define SWIGTYPE_p_wxBrush swig_types[1]
1343 #define SWIGTYPE_p_wxColour swig_types[2]
1344 #define SWIGTYPE_p_wxDC swig_types[3]
1345 #define SWIGTYPE_p_wxMirrorDC swig_types[4]
1346 #define SWIGTYPE_p_form_ops_t swig_types[5]
1347 #define SWIGTYPE_p_wxDuplexMode swig_types[6]
1348 #define SWIGTYPE_p_wxPyFontEnumerator swig_types[7]
1349 #define SWIGTYPE_p_char swig_types[8]
1350 #define SWIGTYPE_p_wxIconLocation swig_types[9]
1351 #define SWIGTYPE_p_wxImage swig_types[10]
1352 #define SWIGTYPE_p_wxMetaFileDC swig_types[11]
1353 #define SWIGTYPE_p_wxMask swig_types[12]
1354 #define SWIGTYPE_p_wxSize swig_types[13]
1355 #define SWIGTYPE_p_wxFont swig_types[14]
1356 #define SWIGTYPE_p_wxWindow swig_types[15]
1357 #define SWIGTYPE_p_double swig_types[16]
1358 #define SWIGTYPE_p_wxMemoryDC swig_types[17]
1359 #define SWIGTYPE_p_wxFontMapper swig_types[18]
1360 #define SWIGTYPE_p_wxEffects swig_types[19]
1361 #define SWIGTYPE_p_wxNativeEncodingInfo swig_types[20]
1362 #define SWIGTYPE_p_wxPalette swig_types[21]
1363 #define SWIGTYPE_p_wxBitmap swig_types[22]
1364 #define SWIGTYPE_p_wxObject swig_types[23]
1365 #define SWIGTYPE_p_wxRegionIterator swig_types[24]
1366 #define SWIGTYPE_p_wxRect swig_types[25]
1367 #define SWIGTYPE_p_wxPaperSize swig_types[26]
1368 #define SWIGTYPE_p_wxString swig_types[27]
1369 #define SWIGTYPE_unsigned_int swig_types[28]
1370 #define SWIGTYPE_p_unsigned_int swig_types[29]
1371 #define SWIGTYPE_p_wxPrinterDC swig_types[30]
1372 #define SWIGTYPE_p_wxIconBundle swig_types[31]
1373 #define SWIGTYPE_p_wxPoint swig_types[32]
1374 #define SWIGTYPE_p_wxDash swig_types[33]
1375 #define SWIGTYPE_p_wxScreenDC swig_types[34]
1376 #define SWIGTYPE_p_wxCursor swig_types[35]
1377 #define SWIGTYPE_p_wxClientDC swig_types[36]
1378 #define SWIGTYPE_p_wxBufferedDC swig_types[37]
1379 #define SWIGTYPE_p_wxImageList swig_types[38]
1380 #define SWIGTYPE_p_unsigned_char swig_types[39]
1381 #define SWIGTYPE_p_wxGDIObject swig_types[40]
1382 #define SWIGTYPE_p_wxIcon swig_types[41]
1383 #define SWIGTYPE_p_wxLocale swig_types[42]
1384 #define SWIGTYPE_ptrdiff_t swig_types[43]
1385 #define SWIGTYPE_std__ptrdiff_t swig_types[44]
1386 #define SWIGTYPE_p_wxRegion swig_types[45]
1387 #define SWIGTYPE_p_wxConfigBase swig_types[46]
1388 #define SWIGTYPE_p_wxLanguageInfo swig_types[47]
1389 #define SWIGTYPE_p_wxWindowDC swig_types[48]
1390 #define SWIGTYPE_p_wxPrintData swig_types[49]
1391 #define SWIGTYPE_p_wxBrushList swig_types[50]
1392 #define SWIGTYPE_p_wxFontList swig_types[51]
1393 #define SWIGTYPE_p_wxPen swig_types[52]
1394 #define SWIGTYPE_p_wxBufferedPaintDC swig_types[53]
1395 #define SWIGTYPE_p_wxPaintDC swig_types[54]
1396 #define SWIGTYPE_p_wxPenList swig_types[55]
1397 #define SWIGTYPE_p_int swig_types[56]
1398 #define SWIGTYPE_p_wxMetaFile swig_types[57]
1399 #define SWIGTYPE_p_unsigned_long swig_types[58]
1400 #define SWIGTYPE_p_wxNativeFontInfo swig_types[59]
1401 #define SWIGTYPE_p_wxEncodingConverter swig_types[60]
1402 #define SWIGTYPE_p_wxColourDatabase swig_types[61]
1403 static swig_type_info *swig_types[63];
1404
1405 /* -------- TYPES TABLE (END) -------- */
1406
1407
1408 /*-----------------------------------------------
1409 @(target):= _gdi_.so
1410 ------------------------------------------------*/
1411 #define SWIG_init init_gdi_
1412
1413 #define SWIG_name "_gdi_"
1414
1415 #include "wx/wxPython/wxPython.h"
1416 #include "wx/wxPython/pyclasses.h"
1417
1418
1419 static const wxString wxPyEmptyString(wxEmptyString);
1420
1421 #include <limits.h>
1422
1423
1424 SWIGINTERN int
1425 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1426 const char *errmsg)
1427 {
1428 if (value < min_value) {
1429 if (errmsg) {
1430 PyErr_Format(PyExc_OverflowError,
1431 "value %ld is less than '%s' minimum %ld",
1432 value, errmsg, min_value);
1433 }
1434 return 0;
1435 } else if (value > max_value) {
1436 if (errmsg) {
1437 PyErr_Format(PyExc_OverflowError,
1438 "value %ld is greater than '%s' maximum %ld",
1439 value, errmsg, max_value);
1440 }
1441 return 0;
1442 }
1443 return 1;
1444 }
1445
1446
1447 SWIGINTERN int
1448 SWIG_AsVal_long(PyObject* obj, long* val)
1449 {
1450 if (PyNumber_Check(obj)) {
1451 if (val) *val = PyInt_AsLong(obj);
1452 return 1;
1453 }
1454 else {
1455 SWIG_type_error("number", obj);
1456 }
1457 return 0;
1458 }
1459
1460
1461 #if INT_MAX != LONG_MAX
1462 SWIGINTERN int
1463 SWIG_AsVal_int(PyObject *obj, int *val)
1464 {
1465 const char* errmsg = val ? "int" : (char*)0;
1466 long v;
1467 if (SWIG_AsVal_long(obj, &v)) {
1468 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1469 if (val) *val = (int)(v);
1470 return 1;
1471 } else {
1472 return 0;
1473 }
1474 } else {
1475 PyErr_Clear();
1476 }
1477 if (val) {
1478 SWIG_type_error(errmsg, obj);
1479 }
1480 return 0;
1481 }
1482 #else
1483 SWIGINTERNSHORT int
1484 SWIG_AsVal_int(PyObject *obj, int *val)
1485 {
1486 return SWIG_AsVal_long(obj,(long*)val);
1487 }
1488 #endif
1489
1490
1491 SWIGINTERN int
1492 SWIG_AsVal_bool(PyObject *obj, bool *val)
1493 {
1494 if (obj == Py_True) {
1495 if (val) *val = true;
1496 return 1;
1497 }
1498 if (obj == Py_False) {
1499 if (val) *val = false;
1500 return 1;
1501 }
1502 int res = 0;
1503 if (SWIG_AsVal_int(obj, &res)) {
1504 if (val) *val = res ? true : false;
1505 return 1;
1506 } else {
1507 PyErr_Clear();
1508 }
1509 if (val) {
1510 SWIG_type_error("bool", obj);
1511 }
1512 return 0;
1513 }
1514
1515
1516 SWIGINTERNSHORT bool
1517 SWIG_As_bool(PyObject* obj)
1518 {
1519 bool v;
1520 if (!SWIG_AsVal_bool(obj, &v)) {
1521 /*
1522 this is needed to make valgrind/purify happier.
1523 */
1524 memset((void*)&v, 0, sizeof(bool));
1525 }
1526 return v;
1527 }
1528
1529
1530 SWIGINTERNSHORT int
1531 SWIG_Check_bool(PyObject* obj)
1532 {
1533 return SWIG_AsVal_bool(obj, (bool*)0);
1534 }
1535
1536
1537 SWIGINTERN int
1538 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1539 {
1540 long v = 0;
1541 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1542 SWIG_type_error("unsigned number", obj);
1543 }
1544 else if (val)
1545 *val = (unsigned long)v;
1546 return 1;
1547 }
1548
1549
1550 SWIGINTERNSHORT int
1551 SWIG_CheckUnsignedLongInRange(unsigned long value,
1552 unsigned long max_value,
1553 const char *errmsg)
1554 {
1555 if (value > max_value) {
1556 if (errmsg) {
1557 PyErr_Format(PyExc_OverflowError,
1558 "value %lu is greater than '%s' minimum %lu",
1559 value, errmsg, max_value);
1560 }
1561 return 0;
1562 }
1563 return 1;
1564 }
1565
1566
1567 SWIGINTERN int
1568 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
1569 {
1570 const char* errmsg = val ? "unsigned char" : (char*)0;
1571 unsigned long v;
1572 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1573 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
1574 if (val) *val = (unsigned char)(v);
1575 return 1;
1576 } else {
1577 return 0;
1578 }
1579 } else {
1580 PyErr_Clear();
1581 }
1582 if (val) {
1583 SWIG_type_error(errmsg, obj);
1584 }
1585 return 0;
1586 }
1587
1588
1589 SWIGINTERNSHORT unsigned char
1590 SWIG_As_unsigned_SS_char(PyObject* obj)
1591 {
1592 unsigned char v;
1593 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
1594 /*
1595 this is needed to make valgrind/purify happier.
1596 */
1597 memset((void*)&v, 0, sizeof(unsigned char));
1598 }
1599 return v;
1600 }
1601
1602
1603 SWIGINTERNSHORT int
1604 SWIG_Check_unsigned_SS_char(PyObject* obj)
1605 {
1606 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
1607 }
1608
1609
1610 SWIGINTERNSHORT unsigned long
1611 SWIG_As_unsigned_SS_long(PyObject* obj)
1612 {
1613 unsigned long v;
1614 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1615 /*
1616 this is needed to make valgrind/purify happier.
1617 */
1618 memset((void*)&v, 0, sizeof(unsigned long));
1619 }
1620 return v;
1621 }
1622
1623
1624 SWIGINTERNSHORT int
1625 SWIG_Check_unsigned_SS_long(PyObject* obj)
1626 {
1627 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1628 }
1629
1630
1631 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1632 #define SWIG_From_unsigned_SS_char PyInt_FromLong
1633 /*@@*/
1634
1635
1636 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1637 #define SWIG_From_long PyInt_FromLong
1638 /*@@*/
1639
1640 static PyObject *wxColour_Get(wxColour *self){
1641 PyObject* rv = PyTuple_New(3);
1642 int red = -1;
1643 int green = -1;
1644 int blue = -1;
1645 if (self->Ok()) {
1646 red = self->Red();
1647 green = self->Green();
1648 blue = self->Blue();
1649 }
1650 PyTuple_SetItem(rv, 0, PyInt_FromLong(red));
1651 PyTuple_SetItem(rv, 1, PyInt_FromLong(green));
1652 PyTuple_SetItem(rv, 2, PyInt_FromLong(blue));
1653 return rv;
1654 }
1655 static unsigned long wxColour_GetRGB(wxColour *self){
1656 return self->Red() | (self->Green() << 8) | (self->Blue() << 16);
1657 }
1658
1659 SWIGINTERNSHORT PyObject*
1660 SWIG_From_unsigned_SS_long(unsigned long value)
1661 {
1662 return (value > LONG_MAX) ?
1663 PyLong_FromUnsignedLong(value)
1664 : PyInt_FromLong((long)(value));
1665 }
1666
1667
1668 SWIGINTERNSHORT int
1669 SWIG_As_int(PyObject* obj)
1670 {
1671 int v;
1672 if (!SWIG_AsVal_int(obj, &v)) {
1673 /*
1674 this is needed to make valgrind/purify happier.
1675 */
1676 memset((void*)&v, 0, sizeof(int));
1677 }
1678 return v;
1679 }
1680
1681
1682 SWIGINTERNSHORT int
1683 SWIG_Check_int(PyObject* obj)
1684 {
1685 return SWIG_AsVal_int(obj, (int*)0);
1686 }
1687
1688
1689 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1690 #define SWIG_From_int PyInt_FromLong
1691 /*@@*/
1692
1693
1694 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1695 PyObject* o2;
1696 PyObject* o3;
1697
1698 if (!target) {
1699 target = o;
1700 } else if (target == Py_None) {
1701 Py_DECREF(Py_None);
1702 target = o;
1703 } else {
1704 if (!PyTuple_Check(target)) {
1705 o2 = target;
1706 target = PyTuple_New(1);
1707 PyTuple_SetItem(target, 0, o2);
1708 }
1709 o3 = PyTuple_New(1);
1710 PyTuple_SetItem(o3, 0, o);
1711
1712 o2 = target;
1713 target = PySequence_Concat(o2, o3);
1714 Py_DECREF(o2);
1715 Py_DECREF(o3);
1716 }
1717 return target;
1718 }
1719
1720
1721 static PyObject *wxPen_GetDashes(wxPen *self){
1722 wxDash* dashes;
1723 int count = self->GetDashes(&dashes);
1724 bool blocked = wxPyBeginBlockThreads();
1725 PyObject* retval = PyList_New(0);
1726 for (int x=0; x<count; x++) {
1727 PyObject* pyint = PyInt_FromLong(dashes[x]);
1728 PyList_Append(retval, pyint);
1729 Py_DECREF(pyint);
1730 }
1731 wxPyEndBlockThreads(blocked);
1732 return retval;
1733 }
1734 static void wxPen__SetDashes(wxPen *self,PyObject *_self,PyObject *pyDashes){
1735 bool blocked = wxPyBeginBlockThreads();
1736 int size = PyList_Size(pyDashes);
1737 wxDash* dashes = (wxDash*)byte_LIST_helper(pyDashes);
1738
1739 // black magic warning! The array of wxDashes needs to exist as
1740 // long as the pen does because wxPen does not copy the array. So
1741 // stick a copy in a Python string object and attach it to _self,
1742 // and then call SetDashes with a pointer to that array. Then
1743 // when the Python pen object is destroyed the array will be
1744 // cleaned up too.
1745 PyObject* strDashes = PyString_FromStringAndSize((char*)dashes, size*sizeof(wxDash));
1746 PyObject_SetAttrString(_self, "_dashes", strDashes);
1747
1748 self->SetDashes(size, (wxDash*)PyString_AS_STRING(strDashes));
1749 delete [] dashes;
1750 Py_DECREF(strDashes);
1751 wxPyEndBlockThreads(blocked);
1752 }
1753 static bool wxPen___eq__(wxPen *self,wxPen const *other){ return other ? (*self == *other) : false; }
1754 static bool wxPen___ne__(wxPen *self,wxPen const *other){ return other ? (*self != *other) : true; }
1755
1756 #include <wx/image.h>
1757
1758 static char** ConvertListOfStrings(PyObject* listOfStrings) {
1759 char** cArray = NULL;
1760 int count;
1761
1762 if (!PyList_Check(listOfStrings)) {
1763 PyErr_SetString(PyExc_TypeError, "Expected a list of strings.");
1764 return NULL;
1765 }
1766 count = PyList_Size(listOfStrings);
1767 cArray = new char*[count];
1768
1769 for(int x=0; x<count; x++) {
1770 // TODO: Need some validation and error checking here
1771 cArray[x] = PyString_AsString(PyList_GET_ITEM(listOfStrings, x));
1772 }
1773 return cArray;
1774 }
1775
1776
1777 static wxBitmap *new_wxBitmap(PyObject *listOfStrings){
1778 char** cArray = NULL;
1779 wxBitmap* bmp;
1780
1781 cArray = ConvertListOfStrings(listOfStrings);
1782 if (! cArray)
1783 return NULL;
1784 bmp = new wxBitmap(cArray);
1785 delete [] cArray;
1786 return bmp;
1787 }
1788 static wxBitmap *new_wxBitmap(PyObject *bits,int width,int height,int depth=1){
1789 char* buf;
1790 int length;
1791 PyString_AsStringAndSize(bits, &buf, &length);
1792 return new wxBitmap(buf, width, height, depth);
1793 }
1794 static wxSize wxBitmap_GetSize(wxBitmap *self){
1795 wxSize size(self->GetWidth(), self->GetHeight());
1796 return size;
1797 }
1798 static void wxBitmap_SetMaskColour(wxBitmap *self,wxColour const &colour){
1799 wxMask *mask = new wxMask(*self, colour);
1800 self->SetMask(mask);
1801 }
1802 static void wxBitmap_SetSize(wxBitmap *self,wxSize const &size){
1803 self->SetWidth(size.x);
1804 self->SetHeight(size.y);
1805 }
1806 static bool wxBitmap___eq__(wxBitmap *self,wxBitmap const *other){ return other ? (*self == *other) : false; }
1807 static bool wxBitmap___ne__(wxBitmap *self,wxBitmap const *other){ return other ? (*self != *other) : true; }
1808 static wxMask *new_wxMask(wxBitmap const &bitmap,wxColour const &colour=wxNullColour){
1809 if ( !colour.Ok() )
1810 return new wxMask(bitmap, *wxBLACK);
1811 else
1812 return new wxMask(bitmap, colour);
1813 }
1814
1815 #include <wx/iconbndl.h>
1816
1817 static wxIcon *new_wxIcon(wxBitmap const &bmp){
1818 wxIcon* icon = new wxIcon();
1819 icon->CopyFromBitmap(bmp);
1820 return icon;
1821 }
1822 static wxIcon *new_wxIcon(PyObject *listOfStrings){
1823 char** cArray = NULL;
1824 wxIcon* icon;
1825
1826 cArray = ConvertListOfStrings(listOfStrings);
1827 if (! cArray)
1828 return NULL;
1829 icon = new wxIcon(cArray);
1830 delete [] cArray;
1831 return icon;
1832 }
1833 static wxIconLocation *new_wxIconLocation(wxString const *filename=&wxPyEmptyString,int num=0){
1834
1835
1836
1837 return new wxIconLocation(*filename);
1838
1839 }
1840 static void wxIconLocation_SetIndex(wxIconLocation *self,int num){
1841
1842
1843
1844 // do nothing
1845
1846 }
1847 static int wxIconLocation_GetIndex(wxIconLocation *self){
1848
1849
1850
1851 return -1;
1852
1853 }
1854
1855 SWIGINTERNSHORT long
1856 SWIG_As_long(PyObject* obj)
1857 {
1858 long v;
1859 if (!SWIG_AsVal_long(obj, &v)) {
1860 /*
1861 this is needed to make valgrind/purify happier.
1862 */
1863 memset((void*)&v, 0, sizeof(long));
1864 }
1865 return v;
1866 }
1867
1868
1869 SWIGINTERNSHORT int
1870 SWIG_Check_long(PyObject* obj)
1871 {
1872 return SWIG_AsVal_long(obj, (long*)0);
1873 }
1874
1875 static wxCursor *new_wxCursor(wxString const *cursorName,long type,int hotSpotX=0,int hotSpotY=0){
1876 #ifdef __WXGTK__
1877 wxCHECK_MSG(false, NULL,
1878 wxT("wx.Cursor constructor not implemented for wxGTK, use wx.StockCursor, wx.CursorFromImage, or wx.CursorFromBits instead."));
1879 #else
1880 return new wxCursor(*cursorName, type, hotSpotX, hotSpotY);
1881 #endif
1882 }
1883
1884
1885 static void wxRegionIterator_Next(wxRegionIterator *self){
1886 (*self) ++;
1887 }
1888 static bool wxRegionIterator___nonzero__(wxRegionIterator *self){
1889 return self->operator bool();
1890 }
1891
1892 #include <wx/fontutil.h>
1893 #include <wx/fontmap.h>
1894 #include <wx/fontenum.h>
1895
1896 static wxString wxNativeFontInfo___str__(wxNativeFontInfo *self){
1897 return self->ToString();
1898 }
1899
1900 wxNativeEncodingInfo* wxGetNativeFontEncoding(wxFontEncoding encoding) {
1901 static wxNativeEncodingInfo info;
1902 if ( wxGetNativeFontEncoding(encoding, &info) )
1903 return &info;
1904 else
1905 return NULL;
1906 }
1907
1908 static PyObject *wxFontMapper_GetAltForEncoding(wxFontMapper *self,wxFontEncoding encoding,wxString const &facename=wxPyEmptyString,bool interactive=true){
1909 wxFontEncoding alt_enc;
1910 if (self->GetAltForEncoding(encoding, &alt_enc, facename, interactive))
1911 return PyInt_FromLong(alt_enc);
1912 else {
1913 Py_INCREF(Py_None);
1914 return Py_None;
1915 }
1916 }
1917 static wxFont *new_wxFont(wxString const &info){
1918 wxNativeFontInfo nfi;
1919 nfi.FromString(info);
1920 return new wxFont(nfi);
1921 }
1922 static wxFont *new_wxFont(int pointSize,wxFontFamily family,int flags=wxFONTFLAG_DEFAULT,wxString const &face=wxPyEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1923 return wxFont::New(pointSize, family, flags, face, encoding);
1924 }
1925 static wxFont *new_wxFont(wxSize const &pixelSize,int family,int style,int weight,bool underlined=false,wxString const &face=wxEmptyString,wxFontEncoding encoding=wxFONTENCODING_DEFAULT){
1926 return wxFontBase::New(pixelSize, family,
1927 style, weight, underlined,
1928 face, encoding);
1929 }
1930 static bool wxFont___eq__(wxFont *self,wxFont const *other){ return other ? (*self == *other) : false; }
1931 static bool wxFont___ne__(wxFont *self,wxFont const *other){ return other ? (*self != *other) : true; }
1932
1933 class wxPyFontEnumerator : public wxFontEnumerator {
1934 public:
1935 wxPyFontEnumerator() {}
1936 ~wxPyFontEnumerator() {}
1937
1938 DEC_PYCALLBACK_BOOL_STRING(OnFacename);
1939 DEC_PYCALLBACK_BOOL_STRINGSTRING(OnFontEncoding);
1940
1941 PYPRIVATE;
1942 };
1943
1944 IMP_PYCALLBACK_BOOL_STRING(wxPyFontEnumerator, wxFontEnumerator, OnFacename);
1945 IMP_PYCALLBACK_BOOL_STRINGSTRING(wxPyFontEnumerator, wxFontEnumerator, OnFontEncoding);
1946
1947
1948 static PyObject *wxPyFontEnumerator_GetEncodings(wxPyFontEnumerator *self){
1949 wxArrayString* arr = self->GetEncodings();
1950 if (arr)
1951 return wxArrayString2PyList_helper(*arr);
1952 else
1953 return PyList_New(0);
1954 }
1955 static PyObject *wxPyFontEnumerator_GetFacenames(wxPyFontEnumerator *self){
1956 wxArrayString* arr = self->GetFacenames();
1957 if (arr)
1958 return wxArrayString2PyList_helper(*arr);
1959 else
1960 return PyList_New(0);
1961 }
1962
1963 #include <locale.h>
1964
1965 static wxLocale *new_wxLocale(int language=-1,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
1966 wxLocale* loc;
1967 if (language == -1)
1968 loc = new wxLocale();
1969 else
1970 loc = new wxLocale(language, flags);
1971 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1972 // for the floating point conversions and such to work right.
1973 #if PY_VERSION_HEX < 0x02040000
1974 setlocale(LC_NUMERIC, "C");
1975 #endif
1976 return loc;
1977 }
1978 static bool wxLocale_Init1(wxLocale *self,wxString const &szName,wxString const &szShort=wxPyEmptyString,wxString const &szLocale=wxPyEmptyString,bool bLoadDefault=true,bool bConvertEncoding=false){
1979 bool rc = self->Init(szName, szShort, szLocale, bLoadDefault, bConvertEncoding);
1980 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1981 // for the floating point conversions and such to work right.
1982 #if PY_VERSION_HEX < 0x02040000
1983 setlocale(LC_NUMERIC, "C");
1984 #endif
1985 return rc;
1986 }
1987 static bool wxLocale_Init2(wxLocale *self,int language=wxLANGUAGE_DEFAULT,int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING){
1988 bool rc = self->Init(language, flags);
1989 // Python before 2.4 needs to have LC_NUMERIC set to "C" in order
1990 // for the floating point conversions and such to work right.
1991 #if PY_VERSION_HEX < 0x02040000
1992 setlocale(LC_NUMERIC, "C");
1993 #endif
1994 return rc;
1995 }
1996
1997 #include "wx/wxPython/pydrawxxx.h"
1998
1999 static wxColour wxDC_GetPixel(wxDC *self,int x,int y){
2000 wxColour col;
2001 self->GetPixel(x, y, &col);
2002 return col;
2003 }
2004 static wxColour wxDC_GetPixelPoint(wxDC *self,wxPoint const &pt){
2005 wxColour col;
2006 self->GetPixel(pt, &col);
2007 return col;
2008 }
2009
2010 SWIGINTERN int
2011 SWIG_AsVal_double(PyObject *obj, double* val)
2012 {
2013 if (PyNumber_Check(obj)) {
2014 if (val) *val = PyFloat_AsDouble(obj);
2015 return 1;
2016 }
2017 else {
2018 SWIG_type_error("number", obj);
2019 }
2020 return 0;
2021 }
2022
2023
2024 SWIGINTERNSHORT double
2025 SWIG_As_double(PyObject* obj)
2026 {
2027 double v;
2028 if (!SWIG_AsVal_double(obj, &v)) {
2029 /*
2030 this is needed to make valgrind/purify happier.
2031 */
2032 memset((void*)&v, 0, sizeof(double));
2033 }
2034 return v;
2035 }
2036
2037
2038 SWIGINTERNSHORT int
2039 SWIG_Check_double(PyObject* obj)
2040 {
2041 return SWIG_AsVal_double(obj, (double*)0);
2042 }
2043
2044 static wxRect wxDC_DrawImageLabel(wxDC *self,wxString const &text,wxBitmap const &image,wxRect const &rect,int alignment=wxALIGN_LEFT|wxALIGN_TOP,int indexAccel=-1){
2045 wxRect rv;
2046 self->DrawLabel(text, image, rect, alignment, indexAccel, &rv);
2047 return rv;
2048 }
2049
2050 static wxRect wxDC_GetClippingRect(wxDC *self){
2051 wxRect rect;
2052 self->GetClippingBox(rect);
2053 return rect;
2054 }
2055 static wxArrayInt wxDC_GetPartialTextExtents(wxDC *self,wxString const &text){
2056 wxArrayInt widths;
2057 self->GetPartialTextExtents(text, widths);
2058 return widths;
2059 }
2060
2061 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2062 #define SWIG_From_double PyFloat_FromDouble
2063 /*@@*/
2064
2065
2066 static void wxDC_SetLogicalOriginPoint(wxDC *self,wxPoint const &point){
2067 self->SetLogicalOrigin(point.x, point.y);
2068 }
2069 static void wxDC_SetDeviceOriginPoint(wxDC *self,wxPoint const &point){
2070 self->SetDeviceOrigin(point.x, point.y);
2071 }
2072 static void wxDC_CalcBoundingBoxPoint(wxDC *self,wxPoint const &point){
2073 self->CalcBoundingBox(point.x, point.y);
2074 }
2075 static PyObject *wxDC__DrawPointList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2076 return wxPyDrawXXXList(*self, wxPyDrawXXXPoint, pyCoords, pyPens, pyBrushes);
2077 }
2078 static PyObject *wxDC__DrawLineList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2079 return wxPyDrawXXXList(*self, wxPyDrawXXXLine, pyCoords, pyPens, pyBrushes);
2080 }
2081 static PyObject *wxDC__DrawRectangleList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2082 return wxPyDrawXXXList(*self, wxPyDrawXXXRectangle, pyCoords, pyPens, pyBrushes);
2083 }
2084 static PyObject *wxDC__DrawEllipseList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2085 return wxPyDrawXXXList(*self, wxPyDrawXXXEllipse, pyCoords, pyPens, pyBrushes);
2086 }
2087 static PyObject *wxDC__DrawPolygonList(wxDC *self,PyObject *pyCoords,PyObject *pyPens,PyObject *pyBrushes){
2088 return wxPyDrawXXXList(*self, wxPyDrawXXXPolygon, pyCoords, pyPens, pyBrushes);
2089 }
2090 static PyObject *wxDC__DrawTextList(wxDC *self,PyObject *textList,PyObject *pyPoints,PyObject *foregroundList,PyObject *backgroundList){
2091 return wxPyDrawTextList(*self, textList, pyPoints, foregroundList, backgroundList);
2092 }
2093
2094 static void wxDC_GetBoundingBox(wxDC* dc, int* x1, int* y1, int* x2, int* y2) {
2095 *x1 = dc->MinX();
2096 *y1 = dc->MinY();
2097 *x2 = dc->MaxX();
2098 *y2 = dc->MaxY();
2099 }
2100
2101
2102 #include <wx/dcbuffer.h>
2103
2104
2105 #include <wx/dcps.h>
2106
2107
2108 class wxMetaFile : public wxObject {
2109 public:
2110 wxMetaFile(const wxString&)
2111 { wxPyRaiseNotImplemented(); }
2112 };
2113
2114 class wxMetaFileDC : public wxClientDC {
2115 public:
2116 wxMetaFileDC(const wxString&, int, int, const wxString&)
2117 { wxPyRaiseNotImplemented(); }
2118 };
2119
2120
2121
2122 class wxPrinterDC : public wxClientDC {
2123 public:
2124 wxPrinterDC(const wxPrintData&)
2125 { wxPyRaiseNotImplemented(); }
2126
2127 };
2128
2129
2130
2131 static void wxColourDatabase_Append(wxColourDatabase *self,wxString const &name,int red,int green,int blue){
2132 self->AddColour(name, wxColour(red, green, blue));
2133 }
2134
2135 #include <wx/effects.h>
2136
2137 #ifdef __cplusplus
2138 extern "C" {
2139 #endif
2140 static PyObject *_wrap_new_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2141 PyObject *resultobj;
2142 wxGDIObject *result;
2143 char *kwnames[] = {
2144 NULL
2145 };
2146
2147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GDIObject",kwnames)) goto fail;
2148 {
2149 if (!wxPyCheckForApp()) SWIG_fail;
2150 PyThreadState* __tstate = wxPyBeginAllowThreads();
2151 result = (wxGDIObject *)new wxGDIObject();
2152
2153 wxPyEndAllowThreads(__tstate);
2154 if (PyErr_Occurred()) SWIG_fail;
2155 }
2156 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGDIObject, 1);
2157 return resultobj;
2158 fail:
2159 return NULL;
2160 }
2161
2162
2163 static PyObject *_wrap_delete_GDIObject(PyObject *, PyObject *args, PyObject *kwargs) {
2164 PyObject *resultobj;
2165 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2166 PyObject * obj0 = 0 ;
2167 char *kwnames[] = {
2168 (char *) "self", NULL
2169 };
2170
2171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GDIObject",kwnames,&obj0)) goto fail;
2172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2173 if (SWIG_arg_fail(1)) SWIG_fail;
2174 {
2175 PyThreadState* __tstate = wxPyBeginAllowThreads();
2176 delete arg1;
2177
2178 wxPyEndAllowThreads(__tstate);
2179 if (PyErr_Occurred()) SWIG_fail;
2180 }
2181 Py_INCREF(Py_None); resultobj = Py_None;
2182 return resultobj;
2183 fail:
2184 return NULL;
2185 }
2186
2187
2188 static PyObject *_wrap_GDIObject_GetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2189 PyObject *resultobj;
2190 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2191 bool result;
2192 PyObject * obj0 = 0 ;
2193 char *kwnames[] = {
2194 (char *) "self", NULL
2195 };
2196
2197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_GetVisible",kwnames,&obj0)) goto fail;
2198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2199 if (SWIG_arg_fail(1)) SWIG_fail;
2200 {
2201 PyThreadState* __tstate = wxPyBeginAllowThreads();
2202 result = (bool)(arg1)->GetVisible();
2203
2204 wxPyEndAllowThreads(__tstate);
2205 if (PyErr_Occurred()) SWIG_fail;
2206 }
2207 {
2208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2209 }
2210 return resultobj;
2211 fail:
2212 return NULL;
2213 }
2214
2215
2216 static PyObject *_wrap_GDIObject_SetVisible(PyObject *, PyObject *args, PyObject *kwargs) {
2217 PyObject *resultobj;
2218 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2219 bool arg2 ;
2220 PyObject * obj0 = 0 ;
2221 PyObject * obj1 = 0 ;
2222 char *kwnames[] = {
2223 (char *) "self",(char *) "visible", NULL
2224 };
2225
2226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GDIObject_SetVisible",kwnames,&obj0,&obj1)) goto fail;
2227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2228 if (SWIG_arg_fail(1)) SWIG_fail;
2229 {
2230 arg2 = (bool)(SWIG_As_bool(obj1));
2231 if (SWIG_arg_fail(2)) SWIG_fail;
2232 }
2233 {
2234 PyThreadState* __tstate = wxPyBeginAllowThreads();
2235 (arg1)->SetVisible(arg2);
2236
2237 wxPyEndAllowThreads(__tstate);
2238 if (PyErr_Occurred()) SWIG_fail;
2239 }
2240 Py_INCREF(Py_None); resultobj = Py_None;
2241 return resultobj;
2242 fail:
2243 return NULL;
2244 }
2245
2246
2247 static PyObject *_wrap_GDIObject_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
2248 PyObject *resultobj;
2249 wxGDIObject *arg1 = (wxGDIObject *) 0 ;
2250 bool result;
2251 PyObject * obj0 = 0 ;
2252 char *kwnames[] = {
2253 (char *) "self", NULL
2254 };
2255
2256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GDIObject_IsNull",kwnames,&obj0)) goto fail;
2257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGDIObject, SWIG_POINTER_EXCEPTION | 0);
2258 if (SWIG_arg_fail(1)) SWIG_fail;
2259 {
2260 PyThreadState* __tstate = wxPyBeginAllowThreads();
2261 result = (bool)(arg1)->IsNull();
2262
2263 wxPyEndAllowThreads(__tstate);
2264 if (PyErr_Occurred()) SWIG_fail;
2265 }
2266 {
2267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2268 }
2269 return resultobj;
2270 fail:
2271 return NULL;
2272 }
2273
2274
2275 static PyObject * GDIObject_swigregister(PyObject *, PyObject *args) {
2276 PyObject *obj;
2277 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2278 SWIG_TypeClientData(SWIGTYPE_p_wxGDIObject, obj);
2279 Py_INCREF(obj);
2280 return Py_BuildValue((char *)"");
2281 }
2282 static PyObject *_wrap_new_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2283 PyObject *resultobj;
2284 byte arg1 = (byte) 0 ;
2285 byte arg2 = (byte) 0 ;
2286 byte arg3 = (byte) 0 ;
2287 wxColour *result;
2288 PyObject * obj0 = 0 ;
2289 PyObject * obj1 = 0 ;
2290 PyObject * obj2 = 0 ;
2291 char *kwnames[] = {
2292 (char *) "red",(char *) "green",(char *) "blue", NULL
2293 };
2294
2295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Colour",kwnames,&obj0,&obj1,&obj2)) goto fail;
2296 if (obj0) {
2297 {
2298 arg1 = (byte)(SWIG_As_unsigned_SS_char(obj0));
2299 if (SWIG_arg_fail(1)) SWIG_fail;
2300 }
2301 }
2302 if (obj1) {
2303 {
2304 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2305 if (SWIG_arg_fail(2)) SWIG_fail;
2306 }
2307 }
2308 if (obj2) {
2309 {
2310 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2311 if (SWIG_arg_fail(3)) SWIG_fail;
2312 }
2313 }
2314 {
2315 PyThreadState* __tstate = wxPyBeginAllowThreads();
2316 result = (wxColour *)new wxColour(arg1,arg2,arg3);
2317
2318 wxPyEndAllowThreads(__tstate);
2319 if (PyErr_Occurred()) SWIG_fail;
2320 }
2321 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2322 return resultobj;
2323 fail:
2324 return NULL;
2325 }
2326
2327
2328 static PyObject *_wrap_new_NamedColour(PyObject *, PyObject *args, PyObject *kwargs) {
2329 PyObject *resultobj;
2330 wxString *arg1 = 0 ;
2331 wxColour *result;
2332 bool temp1 = false ;
2333 PyObject * obj0 = 0 ;
2334 char *kwnames[] = {
2335 (char *) "colorName", NULL
2336 };
2337
2338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_NamedColour",kwnames,&obj0)) goto fail;
2339 {
2340 arg1 = wxString_in_helper(obj0);
2341 if (arg1 == NULL) SWIG_fail;
2342 temp1 = true;
2343 }
2344 {
2345 if (!wxPyCheckForApp()) SWIG_fail;
2346 PyThreadState* __tstate = wxPyBeginAllowThreads();
2347 result = (wxColour *)new wxColour((wxString const &)*arg1);
2348
2349 wxPyEndAllowThreads(__tstate);
2350 if (PyErr_Occurred()) SWIG_fail;
2351 }
2352 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2353 {
2354 if (temp1)
2355 delete arg1;
2356 }
2357 return resultobj;
2358 fail:
2359 {
2360 if (temp1)
2361 delete arg1;
2362 }
2363 return NULL;
2364 }
2365
2366
2367 static PyObject *_wrap_new_ColourRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2368 PyObject *resultobj;
2369 unsigned long arg1 ;
2370 wxColour *result;
2371 PyObject * obj0 = 0 ;
2372 char *kwnames[] = {
2373 (char *) "colRGB", NULL
2374 };
2375
2376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ColourRGB",kwnames,&obj0)) goto fail;
2377 {
2378 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
2379 if (SWIG_arg_fail(1)) SWIG_fail;
2380 }
2381 {
2382 PyThreadState* __tstate = wxPyBeginAllowThreads();
2383 result = (wxColour *)new wxColour(arg1);
2384
2385 wxPyEndAllowThreads(__tstate);
2386 if (PyErr_Occurred()) SWIG_fail;
2387 }
2388 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 1);
2389 return resultobj;
2390 fail:
2391 return NULL;
2392 }
2393
2394
2395 static PyObject *_wrap_delete_Colour(PyObject *, PyObject *args, PyObject *kwargs) {
2396 PyObject *resultobj;
2397 wxColour *arg1 = (wxColour *) 0 ;
2398 PyObject * obj0 = 0 ;
2399 char *kwnames[] = {
2400 (char *) "self", NULL
2401 };
2402
2403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Colour",kwnames,&obj0)) goto fail;
2404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2405 if (SWIG_arg_fail(1)) SWIG_fail;
2406 {
2407 PyThreadState* __tstate = wxPyBeginAllowThreads();
2408 delete arg1;
2409
2410 wxPyEndAllowThreads(__tstate);
2411 if (PyErr_Occurred()) SWIG_fail;
2412 }
2413 Py_INCREF(Py_None); resultobj = Py_None;
2414 return resultobj;
2415 fail:
2416 return NULL;
2417 }
2418
2419
2420 static PyObject *_wrap_Colour_Red(PyObject *, PyObject *args, PyObject *kwargs) {
2421 PyObject *resultobj;
2422 wxColour *arg1 = (wxColour *) 0 ;
2423 byte result;
2424 PyObject * obj0 = 0 ;
2425 char *kwnames[] = {
2426 (char *) "self", NULL
2427 };
2428
2429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Red",kwnames,&obj0)) goto fail;
2430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2431 if (SWIG_arg_fail(1)) SWIG_fail;
2432 {
2433 PyThreadState* __tstate = wxPyBeginAllowThreads();
2434 result = (byte)(arg1)->Red();
2435
2436 wxPyEndAllowThreads(__tstate);
2437 if (PyErr_Occurred()) SWIG_fail;
2438 }
2439 {
2440 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2441 }
2442 return resultobj;
2443 fail:
2444 return NULL;
2445 }
2446
2447
2448 static PyObject *_wrap_Colour_Green(PyObject *, PyObject *args, PyObject *kwargs) {
2449 PyObject *resultobj;
2450 wxColour *arg1 = (wxColour *) 0 ;
2451 byte result;
2452 PyObject * obj0 = 0 ;
2453 char *kwnames[] = {
2454 (char *) "self", NULL
2455 };
2456
2457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Green",kwnames,&obj0)) goto fail;
2458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2459 if (SWIG_arg_fail(1)) SWIG_fail;
2460 {
2461 PyThreadState* __tstate = wxPyBeginAllowThreads();
2462 result = (byte)(arg1)->Green();
2463
2464 wxPyEndAllowThreads(__tstate);
2465 if (PyErr_Occurred()) SWIG_fail;
2466 }
2467 {
2468 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2469 }
2470 return resultobj;
2471 fail:
2472 return NULL;
2473 }
2474
2475
2476 static PyObject *_wrap_Colour_Blue(PyObject *, PyObject *args, PyObject *kwargs) {
2477 PyObject *resultobj;
2478 wxColour *arg1 = (wxColour *) 0 ;
2479 byte result;
2480 PyObject * obj0 = 0 ;
2481 char *kwnames[] = {
2482 (char *) "self", NULL
2483 };
2484
2485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Blue",kwnames,&obj0)) goto fail;
2486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2487 if (SWIG_arg_fail(1)) SWIG_fail;
2488 {
2489 PyThreadState* __tstate = wxPyBeginAllowThreads();
2490 result = (byte)(arg1)->Blue();
2491
2492 wxPyEndAllowThreads(__tstate);
2493 if (PyErr_Occurred()) SWIG_fail;
2494 }
2495 {
2496 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
2497 }
2498 return resultobj;
2499 fail:
2500 return NULL;
2501 }
2502
2503
2504 static PyObject *_wrap_Colour_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
2505 PyObject *resultobj;
2506 wxColour *arg1 = (wxColour *) 0 ;
2507 bool result;
2508 PyObject * obj0 = 0 ;
2509 char *kwnames[] = {
2510 (char *) "self", NULL
2511 };
2512
2513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Ok",kwnames,&obj0)) goto fail;
2514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2515 if (SWIG_arg_fail(1)) SWIG_fail;
2516 {
2517 PyThreadState* __tstate = wxPyBeginAllowThreads();
2518 result = (bool)(arg1)->Ok();
2519
2520 wxPyEndAllowThreads(__tstate);
2521 if (PyErr_Occurred()) SWIG_fail;
2522 }
2523 {
2524 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2525 }
2526 return resultobj;
2527 fail:
2528 return NULL;
2529 }
2530
2531
2532 static PyObject *_wrap_Colour_Set(PyObject *, PyObject *args, PyObject *kwargs) {
2533 PyObject *resultobj;
2534 wxColour *arg1 = (wxColour *) 0 ;
2535 byte arg2 ;
2536 byte arg3 ;
2537 byte arg4 ;
2538 PyObject * obj0 = 0 ;
2539 PyObject * obj1 = 0 ;
2540 PyObject * obj2 = 0 ;
2541 PyObject * obj3 = 0 ;
2542 char *kwnames[] = {
2543 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2544 };
2545
2546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Colour_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2548 if (SWIG_arg_fail(1)) SWIG_fail;
2549 {
2550 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2551 if (SWIG_arg_fail(2)) SWIG_fail;
2552 }
2553 {
2554 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2555 if (SWIG_arg_fail(3)) SWIG_fail;
2556 }
2557 {
2558 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2559 if (SWIG_arg_fail(4)) SWIG_fail;
2560 }
2561 {
2562 PyThreadState* __tstate = wxPyBeginAllowThreads();
2563 (arg1)->Set(arg2,arg3,arg4);
2564
2565 wxPyEndAllowThreads(__tstate);
2566 if (PyErr_Occurred()) SWIG_fail;
2567 }
2568 Py_INCREF(Py_None); resultobj = Py_None;
2569 return resultobj;
2570 fail:
2571 return NULL;
2572 }
2573
2574
2575 static PyObject *_wrap_Colour_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2576 PyObject *resultobj;
2577 wxColour *arg1 = (wxColour *) 0 ;
2578 unsigned long arg2 ;
2579 PyObject * obj0 = 0 ;
2580 PyObject * obj1 = 0 ;
2581 char *kwnames[] = {
2582 (char *) "self",(char *) "colRGB", NULL
2583 };
2584
2585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetRGB",kwnames,&obj0,&obj1)) goto fail;
2586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2587 if (SWIG_arg_fail(1)) SWIG_fail;
2588 {
2589 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
2590 if (SWIG_arg_fail(2)) SWIG_fail;
2591 }
2592 {
2593 PyThreadState* __tstate = wxPyBeginAllowThreads();
2594 (arg1)->Set(arg2);
2595
2596 wxPyEndAllowThreads(__tstate);
2597 if (PyErr_Occurred()) SWIG_fail;
2598 }
2599 Py_INCREF(Py_None); resultobj = Py_None;
2600 return resultobj;
2601 fail:
2602 return NULL;
2603 }
2604
2605
2606 static PyObject *_wrap_Colour_SetFromName(PyObject *, PyObject *args, PyObject *kwargs) {
2607 PyObject *resultobj;
2608 wxColour *arg1 = (wxColour *) 0 ;
2609 wxString *arg2 = 0 ;
2610 bool temp2 = false ;
2611 PyObject * obj0 = 0 ;
2612 PyObject * obj1 = 0 ;
2613 char *kwnames[] = {
2614 (char *) "self",(char *) "colourName", NULL
2615 };
2616
2617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour_SetFromName",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 = wxString_in_helper(obj1);
2622 if (arg2 == NULL) SWIG_fail;
2623 temp2 = true;
2624 }
2625 {
2626 PyThreadState* __tstate = wxPyBeginAllowThreads();
2627 (arg1)->InitFromName((wxString const &)*arg2);
2628
2629 wxPyEndAllowThreads(__tstate);
2630 if (PyErr_Occurred()) SWIG_fail;
2631 }
2632 Py_INCREF(Py_None); resultobj = Py_None;
2633 {
2634 if (temp2)
2635 delete arg2;
2636 }
2637 return resultobj;
2638 fail:
2639 {
2640 if (temp2)
2641 delete arg2;
2642 }
2643 return NULL;
2644 }
2645
2646
2647 static PyObject *_wrap_Colour_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2648 PyObject *resultobj;
2649 wxColour *arg1 = (wxColour *) 0 ;
2650 long result;
2651 PyObject * obj0 = 0 ;
2652 char *kwnames[] = {
2653 (char *) "self", NULL
2654 };
2655
2656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetPixel",kwnames,&obj0)) goto fail;
2657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2658 if (SWIG_arg_fail(1)) SWIG_fail;
2659 {
2660 PyThreadState* __tstate = wxPyBeginAllowThreads();
2661 result = (long)((wxColour const *)arg1)->GetPixel();
2662
2663 wxPyEndAllowThreads(__tstate);
2664 if (PyErr_Occurred()) SWIG_fail;
2665 }
2666 {
2667 resultobj = SWIG_From_long((long)(result));
2668 }
2669 return resultobj;
2670 fail:
2671 return NULL;
2672 }
2673
2674
2675 static PyObject *_wrap_Colour___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
2676 PyObject *resultobj;
2677 wxColour *arg1 = (wxColour *) 0 ;
2678 wxColour *arg2 = 0 ;
2679 bool result;
2680 wxColour temp2 ;
2681 PyObject * obj0 = 0 ;
2682 PyObject * obj1 = 0 ;
2683 char *kwnames[] = {
2684 (char *) "self",(char *) "colour", NULL
2685 };
2686
2687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___eq__",kwnames,&obj0,&obj1)) goto fail;
2688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2689 if (SWIG_arg_fail(1)) SWIG_fail;
2690 {
2691 arg2 = &temp2;
2692 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2693 }
2694 {
2695 PyThreadState* __tstate = wxPyBeginAllowThreads();
2696 result = (bool)((wxColour const *)arg1)->operator ==((wxColour const &)*arg2);
2697
2698 wxPyEndAllowThreads(__tstate);
2699 if (PyErr_Occurred()) SWIG_fail;
2700 }
2701 {
2702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2703 }
2704 return resultobj;
2705 fail:
2706 return NULL;
2707 }
2708
2709
2710 static PyObject *_wrap_Colour___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
2711 PyObject *resultobj;
2712 wxColour *arg1 = (wxColour *) 0 ;
2713 wxColour *arg2 = 0 ;
2714 bool result;
2715 wxColour temp2 ;
2716 PyObject * obj0 = 0 ;
2717 PyObject * obj1 = 0 ;
2718 char *kwnames[] = {
2719 (char *) "self",(char *) "colour", NULL
2720 };
2721
2722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Colour___ne__",kwnames,&obj0,&obj1)) goto fail;
2723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2724 if (SWIG_arg_fail(1)) SWIG_fail;
2725 {
2726 arg2 = &temp2;
2727 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
2728 }
2729 {
2730 PyThreadState* __tstate = wxPyBeginAllowThreads();
2731 result = (bool)((wxColour const *)arg1)->operator !=((wxColour const &)*arg2);
2732
2733 wxPyEndAllowThreads(__tstate);
2734 if (PyErr_Occurred()) SWIG_fail;
2735 }
2736 {
2737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2738 }
2739 return resultobj;
2740 fail:
2741 return NULL;
2742 }
2743
2744
2745 static PyObject *_wrap_Colour_Get(PyObject *, PyObject *args, PyObject *kwargs) {
2746 PyObject *resultobj;
2747 wxColour *arg1 = (wxColour *) 0 ;
2748 PyObject *result;
2749 PyObject * obj0 = 0 ;
2750 char *kwnames[] = {
2751 (char *) "self", NULL
2752 };
2753
2754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_Get",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
2759 result = (PyObject *)wxColour_Get(arg1);
2760
2761 wxPyEndAllowThreads(__tstate);
2762 if (PyErr_Occurred()) SWIG_fail;
2763 }
2764 resultobj = result;
2765 return resultobj;
2766 fail:
2767 return NULL;
2768 }
2769
2770
2771 static PyObject *_wrap_Colour_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2772 PyObject *resultobj;
2773 wxColour *arg1 = (wxColour *) 0 ;
2774 unsigned long result;
2775 PyObject * obj0 = 0 ;
2776 char *kwnames[] = {
2777 (char *) "self", NULL
2778 };
2779
2780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Colour_GetRGB",kwnames,&obj0)) goto fail;
2781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
2782 if (SWIG_arg_fail(1)) SWIG_fail;
2783 {
2784 PyThreadState* __tstate = wxPyBeginAllowThreads();
2785 result = (unsigned long)wxColour_GetRGB(arg1);
2786
2787 wxPyEndAllowThreads(__tstate);
2788 if (PyErr_Occurred()) SWIG_fail;
2789 }
2790 {
2791 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
2792 }
2793 return resultobj;
2794 fail:
2795 return NULL;
2796 }
2797
2798
2799 static PyObject * Colour_swigregister(PyObject *, PyObject *args) {
2800 PyObject *obj;
2801 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
2802 SWIG_TypeClientData(SWIGTYPE_p_wxColour, obj);
2803 Py_INCREF(obj);
2804 return Py_BuildValue((char *)"");
2805 }
2806 static PyObject *_wrap_new_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2807 PyObject *resultobj;
2808 int arg1 ;
2809 unsigned char *arg2 = (unsigned char *) 0 ;
2810 unsigned char *arg3 = (unsigned char *) 0 ;
2811 unsigned char *arg4 = (unsigned char *) 0 ;
2812 wxPalette *result;
2813 PyObject * obj0 = 0 ;
2814 PyObject * obj1 = 0 ;
2815 PyObject * obj2 = 0 ;
2816 PyObject * obj3 = 0 ;
2817 char *kwnames[] = {
2818 (char *) "n",(char *) "red",(char *) "green",(char *) "blue", NULL
2819 };
2820
2821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_Palette",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
2822 {
2823 arg1 = (int)(SWIG_As_int(obj0));
2824 if (SWIG_arg_fail(1)) SWIG_fail;
2825 }
2826 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2827 if (SWIG_arg_fail(2)) SWIG_fail;
2828 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2829 if (SWIG_arg_fail(3)) SWIG_fail;
2830 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
2831 if (SWIG_arg_fail(4)) SWIG_fail;
2832 {
2833 if (!wxPyCheckForApp()) SWIG_fail;
2834 PyThreadState* __tstate = wxPyBeginAllowThreads();
2835 result = (wxPalette *)new wxPalette(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
2836
2837 wxPyEndAllowThreads(__tstate);
2838 if (PyErr_Occurred()) SWIG_fail;
2839 }
2840 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 1);
2841 return resultobj;
2842 fail:
2843 return NULL;
2844 }
2845
2846
2847 static PyObject *_wrap_delete_Palette(PyObject *, PyObject *args, PyObject *kwargs) {
2848 PyObject *resultobj;
2849 wxPalette *arg1 = (wxPalette *) 0 ;
2850 PyObject * obj0 = 0 ;
2851 char *kwnames[] = {
2852 (char *) "self", NULL
2853 };
2854
2855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Palette",kwnames,&obj0)) goto fail;
2856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2857 if (SWIG_arg_fail(1)) SWIG_fail;
2858 {
2859 PyThreadState* __tstate = wxPyBeginAllowThreads();
2860 delete arg1;
2861
2862 wxPyEndAllowThreads(__tstate);
2863 if (PyErr_Occurred()) SWIG_fail;
2864 }
2865 Py_INCREF(Py_None); resultobj = Py_None;
2866 return resultobj;
2867 fail:
2868 return NULL;
2869 }
2870
2871
2872 static PyObject *_wrap_Palette_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
2873 PyObject *resultobj;
2874 wxPalette *arg1 = (wxPalette *) 0 ;
2875 byte arg2 ;
2876 byte arg3 ;
2877 byte arg4 ;
2878 int result;
2879 PyObject * obj0 = 0 ;
2880 PyObject * obj1 = 0 ;
2881 PyObject * obj2 = 0 ;
2882 PyObject * obj3 = 0 ;
2883 char *kwnames[] = {
2884 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
2885 };
2886
2887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Palette_GetPixel",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
2892 if (SWIG_arg_fail(2)) SWIG_fail;
2893 }
2894 {
2895 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
2896 if (SWIG_arg_fail(3)) SWIG_fail;
2897 }
2898 {
2899 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
2900 if (SWIG_arg_fail(4)) SWIG_fail;
2901 }
2902 {
2903 PyThreadState* __tstate = wxPyBeginAllowThreads();
2904 result = (int)(arg1)->GetPixel(arg2,arg3,arg4);
2905
2906 wxPyEndAllowThreads(__tstate);
2907 if (PyErr_Occurred()) SWIG_fail;
2908 }
2909 {
2910 resultobj = SWIG_From_int((int)(result));
2911 }
2912 return resultobj;
2913 fail:
2914 return NULL;
2915 }
2916
2917
2918 static PyObject *_wrap_Palette_GetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
2919 PyObject *resultobj;
2920 wxPalette *arg1 = (wxPalette *) 0 ;
2921 int arg2 ;
2922 byte *arg3 = (byte *) 0 ;
2923 byte *arg4 = (byte *) 0 ;
2924 byte *arg5 = (byte *) 0 ;
2925 bool result;
2926 byte temp3 ;
2927 int res3 = 0 ;
2928 byte temp4 ;
2929 int res4 = 0 ;
2930 byte temp5 ;
2931 int res5 = 0 ;
2932 PyObject * obj0 = 0 ;
2933 PyObject * obj1 = 0 ;
2934 char *kwnames[] = {
2935 (char *) "self",(char *) "pixel", NULL
2936 };
2937
2938 arg3 = &temp3; res3 = SWIG_NEWOBJ;
2939 arg4 = &temp4; res4 = SWIG_NEWOBJ;
2940 arg5 = &temp5; res5 = SWIG_NEWOBJ;
2941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Palette_GetRGB",kwnames,&obj0,&obj1)) goto fail;
2942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2943 if (SWIG_arg_fail(1)) SWIG_fail;
2944 {
2945 arg2 = (int)(SWIG_As_int(obj1));
2946 if (SWIG_arg_fail(2)) SWIG_fail;
2947 }
2948 {
2949 PyThreadState* __tstate = wxPyBeginAllowThreads();
2950 result = (bool)(arg1)->GetRGB(arg2,arg3,arg4,arg5);
2951
2952 wxPyEndAllowThreads(__tstate);
2953 if (PyErr_Occurred()) SWIG_fail;
2954 }
2955 {
2956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2957 }
2958 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
2959 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
2960 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
2961 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
2962 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
2963 SWIG_From_unsigned_SS_char((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_unsigned_char, 0)));
2964 return resultobj;
2965 fail:
2966 return NULL;
2967 }
2968
2969
2970 static PyObject *_wrap_Palette_GetColoursCount(PyObject *, PyObject *args, PyObject *kwargs) {
2971 PyObject *resultobj;
2972 wxPalette *arg1 = (wxPalette *) 0 ;
2973 int result;
2974 PyObject * obj0 = 0 ;
2975 char *kwnames[] = {
2976 (char *) "self", NULL
2977 };
2978
2979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_GetColoursCount",kwnames,&obj0)) goto fail;
2980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
2981 if (SWIG_arg_fail(1)) SWIG_fail;
2982 {
2983 PyThreadState* __tstate = wxPyBeginAllowThreads();
2984 result = (int)((wxPalette const *)arg1)->GetColoursCount();
2985
2986 wxPyEndAllowThreads(__tstate);
2987 if (PyErr_Occurred()) SWIG_fail;
2988 }
2989 {
2990 resultobj = SWIG_From_int((int)(result));
2991 }
2992 return resultobj;
2993 fail:
2994 return NULL;
2995 }
2996
2997
2998 static PyObject *_wrap_Palette_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
2999 PyObject *resultobj;
3000 wxPalette *arg1 = (wxPalette *) 0 ;
3001 bool result;
3002 PyObject * obj0 = 0 ;
3003 char *kwnames[] = {
3004 (char *) "self", NULL
3005 };
3006
3007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Palette_Ok",kwnames,&obj0)) goto fail;
3008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
3009 if (SWIG_arg_fail(1)) SWIG_fail;
3010 {
3011 PyThreadState* __tstate = wxPyBeginAllowThreads();
3012 result = (bool)(arg1)->Ok();
3013
3014 wxPyEndAllowThreads(__tstate);
3015 if (PyErr_Occurred()) SWIG_fail;
3016 }
3017 {
3018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3019 }
3020 return resultobj;
3021 fail:
3022 return NULL;
3023 }
3024
3025
3026 static PyObject * Palette_swigregister(PyObject *, PyObject *args) {
3027 PyObject *obj;
3028 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3029 SWIG_TypeClientData(SWIGTYPE_p_wxPalette, obj);
3030 Py_INCREF(obj);
3031 return Py_BuildValue((char *)"");
3032 }
3033 static PyObject *_wrap_new_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3034 PyObject *resultobj;
3035 wxColour *arg1 = 0 ;
3036 int arg2 = (int) 1 ;
3037 int arg3 = (int) wxSOLID ;
3038 wxPen *result;
3039 wxColour temp1 ;
3040 PyObject * obj0 = 0 ;
3041 PyObject * obj1 = 0 ;
3042 PyObject * obj2 = 0 ;
3043 char *kwnames[] = {
3044 (char *) "colour",(char *) "width",(char *) "style", NULL
3045 };
3046
3047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Pen",kwnames,&obj0,&obj1,&obj2)) goto fail;
3048 {
3049 arg1 = &temp1;
3050 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3051 }
3052 if (obj1) {
3053 {
3054 arg2 = (int)(SWIG_As_int(obj1));
3055 if (SWIG_arg_fail(2)) SWIG_fail;
3056 }
3057 }
3058 if (obj2) {
3059 {
3060 arg3 = (int)(SWIG_As_int(obj2));
3061 if (SWIG_arg_fail(3)) SWIG_fail;
3062 }
3063 }
3064 {
3065 if (!wxPyCheckForApp()) SWIG_fail;
3066 PyThreadState* __tstate = wxPyBeginAllowThreads();
3067 result = (wxPen *)new wxPen(*arg1,arg2,arg3);
3068
3069 wxPyEndAllowThreads(__tstate);
3070 if (PyErr_Occurred()) SWIG_fail;
3071 }
3072 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 1);
3073 return resultobj;
3074 fail:
3075 return NULL;
3076 }
3077
3078
3079 static PyObject *_wrap_delete_Pen(PyObject *, PyObject *args, PyObject *kwargs) {
3080 PyObject *resultobj;
3081 wxPen *arg1 = (wxPen *) 0 ;
3082 PyObject * obj0 = 0 ;
3083 char *kwnames[] = {
3084 (char *) "self", NULL
3085 };
3086
3087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Pen",kwnames,&obj0)) goto fail;
3088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3089 if (SWIG_arg_fail(1)) SWIG_fail;
3090 {
3091 PyThreadState* __tstate = wxPyBeginAllowThreads();
3092 delete arg1;
3093
3094 wxPyEndAllowThreads(__tstate);
3095 if (PyErr_Occurred()) SWIG_fail;
3096 }
3097 Py_INCREF(Py_None); resultobj = Py_None;
3098 return resultobj;
3099 fail:
3100 return NULL;
3101 }
3102
3103
3104 static PyObject *_wrap_Pen_GetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3105 PyObject *resultobj;
3106 wxPen *arg1 = (wxPen *) 0 ;
3107 int result;
3108 PyObject * obj0 = 0 ;
3109 char *kwnames[] = {
3110 (char *) "self", NULL
3111 };
3112
3113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetCap",kwnames,&obj0)) goto fail;
3114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3115 if (SWIG_arg_fail(1)) SWIG_fail;
3116 {
3117 PyThreadState* __tstate = wxPyBeginAllowThreads();
3118 result = (int)(arg1)->GetCap();
3119
3120 wxPyEndAllowThreads(__tstate);
3121 if (PyErr_Occurred()) SWIG_fail;
3122 }
3123 {
3124 resultobj = SWIG_From_int((int)(result));
3125 }
3126 return resultobj;
3127 fail:
3128 return NULL;
3129 }
3130
3131
3132 static PyObject *_wrap_Pen_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3133 PyObject *resultobj;
3134 wxPen *arg1 = (wxPen *) 0 ;
3135 wxColour result;
3136 PyObject * obj0 = 0 ;
3137 char *kwnames[] = {
3138 (char *) "self", NULL
3139 };
3140
3141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetColour",kwnames,&obj0)) goto fail;
3142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3143 if (SWIG_arg_fail(1)) SWIG_fail;
3144 {
3145 PyThreadState* __tstate = wxPyBeginAllowThreads();
3146 result = (arg1)->GetColour();
3147
3148 wxPyEndAllowThreads(__tstate);
3149 if (PyErr_Occurred()) SWIG_fail;
3150 }
3151 {
3152 wxColour * resultptr;
3153 resultptr = new wxColour((wxColour &)(result));
3154 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3155 }
3156 return resultobj;
3157 fail:
3158 return NULL;
3159 }
3160
3161
3162 static PyObject *_wrap_Pen_GetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3163 PyObject *resultobj;
3164 wxPen *arg1 = (wxPen *) 0 ;
3165 int result;
3166 PyObject * obj0 = 0 ;
3167 char *kwnames[] = {
3168 (char *) "self", NULL
3169 };
3170
3171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetJoin",kwnames,&obj0)) goto fail;
3172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3173 if (SWIG_arg_fail(1)) SWIG_fail;
3174 {
3175 PyThreadState* __tstate = wxPyBeginAllowThreads();
3176 result = (int)(arg1)->GetJoin();
3177
3178 wxPyEndAllowThreads(__tstate);
3179 if (PyErr_Occurred()) SWIG_fail;
3180 }
3181 {
3182 resultobj = SWIG_From_int((int)(result));
3183 }
3184 return resultobj;
3185 fail:
3186 return NULL;
3187 }
3188
3189
3190 static PyObject *_wrap_Pen_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3191 PyObject *resultobj;
3192 wxPen *arg1 = (wxPen *) 0 ;
3193 int result;
3194 PyObject * obj0 = 0 ;
3195 char *kwnames[] = {
3196 (char *) "self", NULL
3197 };
3198
3199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetStyle",kwnames,&obj0)) goto fail;
3200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3201 if (SWIG_arg_fail(1)) SWIG_fail;
3202 {
3203 PyThreadState* __tstate = wxPyBeginAllowThreads();
3204 result = (int)(arg1)->GetStyle();
3205
3206 wxPyEndAllowThreads(__tstate);
3207 if (PyErr_Occurred()) SWIG_fail;
3208 }
3209 {
3210 resultobj = SWIG_From_int((int)(result));
3211 }
3212 return resultobj;
3213 fail:
3214 return NULL;
3215 }
3216
3217
3218 static PyObject *_wrap_Pen_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3219 PyObject *resultobj;
3220 wxPen *arg1 = (wxPen *) 0 ;
3221 int result;
3222 PyObject * obj0 = 0 ;
3223 char *kwnames[] = {
3224 (char *) "self", NULL
3225 };
3226
3227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetWidth",kwnames,&obj0)) goto fail;
3228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3229 if (SWIG_arg_fail(1)) SWIG_fail;
3230 {
3231 PyThreadState* __tstate = wxPyBeginAllowThreads();
3232 result = (int)(arg1)->GetWidth();
3233
3234 wxPyEndAllowThreads(__tstate);
3235 if (PyErr_Occurred()) SWIG_fail;
3236 }
3237 {
3238 resultobj = SWIG_From_int((int)(result));
3239 }
3240 return resultobj;
3241 fail:
3242 return NULL;
3243 }
3244
3245
3246 static PyObject *_wrap_Pen_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3247 PyObject *resultobj;
3248 wxPen *arg1 = (wxPen *) 0 ;
3249 bool result;
3250 PyObject * obj0 = 0 ;
3251 char *kwnames[] = {
3252 (char *) "self", NULL
3253 };
3254
3255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_Ok",kwnames,&obj0)) goto fail;
3256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3257 if (SWIG_arg_fail(1)) SWIG_fail;
3258 {
3259 PyThreadState* __tstate = wxPyBeginAllowThreads();
3260 result = (bool)(arg1)->Ok();
3261
3262 wxPyEndAllowThreads(__tstate);
3263 if (PyErr_Occurred()) SWIG_fail;
3264 }
3265 {
3266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3267 }
3268 return resultobj;
3269 fail:
3270 return NULL;
3271 }
3272
3273
3274 static PyObject *_wrap_Pen_SetCap(PyObject *, PyObject *args, PyObject *kwargs) {
3275 PyObject *resultobj;
3276 wxPen *arg1 = (wxPen *) 0 ;
3277 int arg2 ;
3278 PyObject * obj0 = 0 ;
3279 PyObject * obj1 = 0 ;
3280 char *kwnames[] = {
3281 (char *) "self",(char *) "cap_style", NULL
3282 };
3283
3284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetCap",kwnames,&obj0,&obj1)) goto fail;
3285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3286 if (SWIG_arg_fail(1)) SWIG_fail;
3287 {
3288 arg2 = (int)(SWIG_As_int(obj1));
3289 if (SWIG_arg_fail(2)) SWIG_fail;
3290 }
3291 {
3292 PyThreadState* __tstate = wxPyBeginAllowThreads();
3293 (arg1)->SetCap(arg2);
3294
3295 wxPyEndAllowThreads(__tstate);
3296 if (PyErr_Occurred()) SWIG_fail;
3297 }
3298 Py_INCREF(Py_None); resultobj = Py_None;
3299 return resultobj;
3300 fail:
3301 return NULL;
3302 }
3303
3304
3305 static PyObject *_wrap_Pen_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3306 PyObject *resultobj;
3307 wxPen *arg1 = (wxPen *) 0 ;
3308 wxColour *arg2 = 0 ;
3309 wxColour temp2 ;
3310 PyObject * obj0 = 0 ;
3311 PyObject * obj1 = 0 ;
3312 char *kwnames[] = {
3313 (char *) "self",(char *) "colour", NULL
3314 };
3315
3316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetColour",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 = &temp2;
3321 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3322 }
3323 {
3324 PyThreadState* __tstate = wxPyBeginAllowThreads();
3325 (arg1)->SetColour(*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_SetJoin(PyObject *, PyObject *args, PyObject *kwargs) {
3338 PyObject *resultobj;
3339 wxPen *arg1 = (wxPen *) 0 ;
3340 int arg2 ;
3341 PyObject * obj0 = 0 ;
3342 PyObject * obj1 = 0 ;
3343 char *kwnames[] = {
3344 (char *) "self",(char *) "join_style", NULL
3345 };
3346
3347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetJoin",kwnames,&obj0,&obj1)) goto fail;
3348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3349 if (SWIG_arg_fail(1)) SWIG_fail;
3350 {
3351 arg2 = (int)(SWIG_As_int(obj1));
3352 if (SWIG_arg_fail(2)) SWIG_fail;
3353 }
3354 {
3355 PyThreadState* __tstate = wxPyBeginAllowThreads();
3356 (arg1)->SetJoin(arg2);
3357
3358 wxPyEndAllowThreads(__tstate);
3359 if (PyErr_Occurred()) SWIG_fail;
3360 }
3361 Py_INCREF(Py_None); resultobj = Py_None;
3362 return resultobj;
3363 fail:
3364 return NULL;
3365 }
3366
3367
3368 static PyObject *_wrap_Pen_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3369 PyObject *resultobj;
3370 wxPen *arg1 = (wxPen *) 0 ;
3371 int arg2 ;
3372 PyObject * obj0 = 0 ;
3373 PyObject * obj1 = 0 ;
3374 char *kwnames[] = {
3375 (char *) "self",(char *) "style", NULL
3376 };
3377
3378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3380 if (SWIG_arg_fail(1)) SWIG_fail;
3381 {
3382 arg2 = (int)(SWIG_As_int(obj1));
3383 if (SWIG_arg_fail(2)) SWIG_fail;
3384 }
3385 {
3386 PyThreadState* __tstate = wxPyBeginAllowThreads();
3387 (arg1)->SetStyle(arg2);
3388
3389 wxPyEndAllowThreads(__tstate);
3390 if (PyErr_Occurred()) SWIG_fail;
3391 }
3392 Py_INCREF(Py_None); resultobj = Py_None;
3393 return resultobj;
3394 fail:
3395 return NULL;
3396 }
3397
3398
3399 static PyObject *_wrap_Pen_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3400 PyObject *resultobj;
3401 wxPen *arg1 = (wxPen *) 0 ;
3402 int arg2 ;
3403 PyObject * obj0 = 0 ;
3404 PyObject * obj1 = 0 ;
3405 char *kwnames[] = {
3406 (char *) "self",(char *) "width", NULL
3407 };
3408
3409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3411 if (SWIG_arg_fail(1)) SWIG_fail;
3412 {
3413 arg2 = (int)(SWIG_As_int(obj1));
3414 if (SWIG_arg_fail(2)) SWIG_fail;
3415 }
3416 {
3417 PyThreadState* __tstate = wxPyBeginAllowThreads();
3418 (arg1)->SetWidth(arg2);
3419
3420 wxPyEndAllowThreads(__tstate);
3421 if (PyErr_Occurred()) SWIG_fail;
3422 }
3423 Py_INCREF(Py_None); resultobj = Py_None;
3424 return resultobj;
3425 fail:
3426 return NULL;
3427 }
3428
3429
3430 static PyObject *_wrap_Pen_SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3431 PyObject *resultobj;
3432 wxPen *arg1 = (wxPen *) 0 ;
3433 int arg2 ;
3434 wxDash *arg3 = (wxDash *) 0 ;
3435 PyObject * obj0 = 0 ;
3436 PyObject * obj1 = 0 ;
3437 char *kwnames[] = {
3438 (char *) "self",(char *) "dashes", NULL
3439 };
3440
3441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen_SetDashes",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 = PyList_Size(obj1);
3446 arg3 = (wxDash*)byte_LIST_helper(obj1);
3447 if (arg3 == NULL) SWIG_fail;
3448 }
3449 {
3450 PyThreadState* __tstate = wxPyBeginAllowThreads();
3451 (arg1)->SetDashes(arg2,arg3);
3452
3453 wxPyEndAllowThreads(__tstate);
3454 if (PyErr_Occurred()) SWIG_fail;
3455 }
3456 Py_INCREF(Py_None); resultobj = Py_None;
3457 {
3458 if (arg3) delete [] arg3;
3459 }
3460 return resultobj;
3461 fail:
3462 {
3463 if (arg3) delete [] arg3;
3464 }
3465 return NULL;
3466 }
3467
3468
3469 static PyObject *_wrap_Pen_GetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3470 PyObject *resultobj;
3471 wxPen *arg1 = (wxPen *) 0 ;
3472 PyObject *result;
3473 PyObject * obj0 = 0 ;
3474 char *kwnames[] = {
3475 (char *) "self", NULL
3476 };
3477
3478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetDashes",kwnames,&obj0)) goto fail;
3479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3480 if (SWIG_arg_fail(1)) SWIG_fail;
3481 {
3482 PyThreadState* __tstate = wxPyBeginAllowThreads();
3483 result = (PyObject *)wxPen_GetDashes(arg1);
3484
3485 wxPyEndAllowThreads(__tstate);
3486 if (PyErr_Occurred()) SWIG_fail;
3487 }
3488 resultobj = result;
3489 return resultobj;
3490 fail:
3491 return NULL;
3492 }
3493
3494
3495 static PyObject *_wrap_Pen__SetDashes(PyObject *, PyObject *args, PyObject *kwargs) {
3496 PyObject *resultobj;
3497 wxPen *arg1 = (wxPen *) 0 ;
3498 PyObject *arg2 = (PyObject *) 0 ;
3499 PyObject *arg3 = (PyObject *) 0 ;
3500 PyObject * obj0 = 0 ;
3501 PyObject * obj1 = 0 ;
3502 PyObject * obj2 = 0 ;
3503 char *kwnames[] = {
3504 (char *) "self",(char *) "_self",(char *) "pyDashes", NULL
3505 };
3506
3507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Pen__SetDashes",kwnames,&obj0,&obj1,&obj2)) goto fail;
3508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3509 if (SWIG_arg_fail(1)) SWIG_fail;
3510 arg2 = obj1;
3511 arg3 = obj2;
3512 {
3513 PyThreadState* __tstate = wxPyBeginAllowThreads();
3514 wxPen__SetDashes(arg1,arg2,arg3);
3515
3516 wxPyEndAllowThreads(__tstate);
3517 if (PyErr_Occurred()) SWIG_fail;
3518 }
3519 Py_INCREF(Py_None); resultobj = Py_None;
3520 return resultobj;
3521 fail:
3522 return NULL;
3523 }
3524
3525
3526 static PyObject *_wrap_Pen_GetDashCount(PyObject *, PyObject *args, PyObject *kwargs) {
3527 PyObject *resultobj;
3528 wxPen *arg1 = (wxPen *) 0 ;
3529 int result;
3530 PyObject * obj0 = 0 ;
3531 char *kwnames[] = {
3532 (char *) "self", NULL
3533 };
3534
3535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Pen_GetDashCount",kwnames,&obj0)) goto fail;
3536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3537 if (SWIG_arg_fail(1)) SWIG_fail;
3538 {
3539 PyThreadState* __tstate = wxPyBeginAllowThreads();
3540 result = (int)((wxPen const *)arg1)->GetDashCount();
3541
3542 wxPyEndAllowThreads(__tstate);
3543 if (PyErr_Occurred()) SWIG_fail;
3544 }
3545 {
3546 resultobj = SWIG_From_int((int)(result));
3547 }
3548 return resultobj;
3549 fail:
3550 return NULL;
3551 }
3552
3553
3554 static PyObject *_wrap_Pen___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3555 PyObject *resultobj;
3556 wxPen *arg1 = (wxPen *) 0 ;
3557 wxPen *arg2 = (wxPen *) 0 ;
3558 bool result;
3559 PyObject * obj0 = 0 ;
3560 PyObject * obj1 = 0 ;
3561 char *kwnames[] = {
3562 (char *) "self",(char *) "other", NULL
3563 };
3564
3565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___eq__",kwnames,&obj0,&obj1)) goto fail;
3566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3567 if (SWIG_arg_fail(1)) SWIG_fail;
3568 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3569 if (SWIG_arg_fail(2)) SWIG_fail;
3570 {
3571 PyThreadState* __tstate = wxPyBeginAllowThreads();
3572 result = (bool)wxPen___eq__(arg1,(wxPen const *)arg2);
3573
3574 wxPyEndAllowThreads(__tstate);
3575 if (PyErr_Occurred()) SWIG_fail;
3576 }
3577 {
3578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3579 }
3580 return resultobj;
3581 fail:
3582 return NULL;
3583 }
3584
3585
3586 static PyObject *_wrap_Pen___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3587 PyObject *resultobj;
3588 wxPen *arg1 = (wxPen *) 0 ;
3589 wxPen *arg2 = (wxPen *) 0 ;
3590 bool result;
3591 PyObject * obj0 = 0 ;
3592 PyObject * obj1 = 0 ;
3593 char *kwnames[] = {
3594 (char *) "self",(char *) "other", NULL
3595 };
3596
3597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Pen___ne__",kwnames,&obj0,&obj1)) goto fail;
3598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3599 if (SWIG_arg_fail(1)) SWIG_fail;
3600 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
3601 if (SWIG_arg_fail(2)) SWIG_fail;
3602 {
3603 PyThreadState* __tstate = wxPyBeginAllowThreads();
3604 result = (bool)wxPen___ne__(arg1,(wxPen const *)arg2);
3605
3606 wxPyEndAllowThreads(__tstate);
3607 if (PyErr_Occurred()) SWIG_fail;
3608 }
3609 {
3610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3611 }
3612 return resultobj;
3613 fail:
3614 return NULL;
3615 }
3616
3617
3618 static PyObject * Pen_swigregister(PyObject *, PyObject *args) {
3619 PyObject *obj;
3620 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3621 SWIG_TypeClientData(SWIGTYPE_p_wxPen, obj);
3622 Py_INCREF(obj);
3623 return Py_BuildValue((char *)"");
3624 }
3625 static PyObject *_wrap_new_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3626 PyObject *resultobj;
3627 wxColour *arg1 = 0 ;
3628 int arg2 = (int) wxSOLID ;
3629 wxBrush *result;
3630 wxColour temp1 ;
3631 PyObject * obj0 = 0 ;
3632 PyObject * obj1 = 0 ;
3633 char *kwnames[] = {
3634 (char *) "colour",(char *) "style", NULL
3635 };
3636
3637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Brush",kwnames,&obj0,&obj1)) goto fail;
3638 {
3639 arg1 = &temp1;
3640 if ( ! wxColour_helper(obj0, &arg1)) SWIG_fail;
3641 }
3642 if (obj1) {
3643 {
3644 arg2 = (int)(SWIG_As_int(obj1));
3645 if (SWIG_arg_fail(2)) SWIG_fail;
3646 }
3647 }
3648 {
3649 if (!wxPyCheckForApp()) SWIG_fail;
3650 PyThreadState* __tstate = wxPyBeginAllowThreads();
3651 result = (wxBrush *)new wxBrush((wxColour const &)*arg1,arg2);
3652
3653 wxPyEndAllowThreads(__tstate);
3654 if (PyErr_Occurred()) SWIG_fail;
3655 }
3656 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 1);
3657 return resultobj;
3658 fail:
3659 return NULL;
3660 }
3661
3662
3663 static PyObject *_wrap_delete_Brush(PyObject *, PyObject *args, PyObject *kwargs) {
3664 PyObject *resultobj;
3665 wxBrush *arg1 = (wxBrush *) 0 ;
3666 PyObject * obj0 = 0 ;
3667 char *kwnames[] = {
3668 (char *) "self", NULL
3669 };
3670
3671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Brush",kwnames,&obj0)) goto fail;
3672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3673 if (SWIG_arg_fail(1)) SWIG_fail;
3674 {
3675 PyThreadState* __tstate = wxPyBeginAllowThreads();
3676 delete arg1;
3677
3678 wxPyEndAllowThreads(__tstate);
3679 if (PyErr_Occurred()) SWIG_fail;
3680 }
3681 Py_INCREF(Py_None); resultobj = Py_None;
3682 return resultobj;
3683 fail:
3684 return NULL;
3685 }
3686
3687
3688 static PyObject *_wrap_Brush_SetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3689 PyObject *resultobj;
3690 wxBrush *arg1 = (wxBrush *) 0 ;
3691 wxColour *arg2 = 0 ;
3692 wxColour temp2 ;
3693 PyObject * obj0 = 0 ;
3694 PyObject * obj1 = 0 ;
3695 char *kwnames[] = {
3696 (char *) "self",(char *) "col", NULL
3697 };
3698
3699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetColour",kwnames,&obj0,&obj1)) goto fail;
3700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3701 if (SWIG_arg_fail(1)) SWIG_fail;
3702 {
3703 arg2 = &temp2;
3704 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
3705 }
3706 {
3707 PyThreadState* __tstate = wxPyBeginAllowThreads();
3708 (arg1)->SetColour((wxColour const &)*arg2);
3709
3710 wxPyEndAllowThreads(__tstate);
3711 if (PyErr_Occurred()) SWIG_fail;
3712 }
3713 Py_INCREF(Py_None); resultobj = Py_None;
3714 return resultobj;
3715 fail:
3716 return NULL;
3717 }
3718
3719
3720 static PyObject *_wrap_Brush_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3721 PyObject *resultobj;
3722 wxBrush *arg1 = (wxBrush *) 0 ;
3723 int arg2 ;
3724 PyObject * obj0 = 0 ;
3725 PyObject * obj1 = 0 ;
3726 char *kwnames[] = {
3727 (char *) "self",(char *) "style", NULL
3728 };
3729
3730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStyle",kwnames,&obj0,&obj1)) goto fail;
3731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3732 if (SWIG_arg_fail(1)) SWIG_fail;
3733 {
3734 arg2 = (int)(SWIG_As_int(obj1));
3735 if (SWIG_arg_fail(2)) SWIG_fail;
3736 }
3737 {
3738 PyThreadState* __tstate = wxPyBeginAllowThreads();
3739 (arg1)->SetStyle(arg2);
3740
3741 wxPyEndAllowThreads(__tstate);
3742 if (PyErr_Occurred()) SWIG_fail;
3743 }
3744 Py_INCREF(Py_None); resultobj = Py_None;
3745 return resultobj;
3746 fail:
3747 return NULL;
3748 }
3749
3750
3751 static PyObject *_wrap_Brush_SetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3752 PyObject *resultobj;
3753 wxBrush *arg1 = (wxBrush *) 0 ;
3754 wxBitmap *arg2 = 0 ;
3755 PyObject * obj0 = 0 ;
3756 PyObject * obj1 = 0 ;
3757 char *kwnames[] = {
3758 (char *) "self",(char *) "stipple", NULL
3759 };
3760
3761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Brush_SetStipple",kwnames,&obj0,&obj1)) goto fail;
3762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3763 if (SWIG_arg_fail(1)) SWIG_fail;
3764 {
3765 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3766 if (SWIG_arg_fail(2)) SWIG_fail;
3767 if (arg2 == NULL) {
3768 SWIG_null_ref("wxBitmap");
3769 }
3770 if (SWIG_arg_fail(2)) SWIG_fail;
3771 }
3772 {
3773 PyThreadState* __tstate = wxPyBeginAllowThreads();
3774 (arg1)->SetStipple((wxBitmap const &)*arg2);
3775
3776 wxPyEndAllowThreads(__tstate);
3777 if (PyErr_Occurred()) SWIG_fail;
3778 }
3779 Py_INCREF(Py_None); resultobj = Py_None;
3780 return resultobj;
3781 fail:
3782 return NULL;
3783 }
3784
3785
3786 static PyObject *_wrap_Brush_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3787 PyObject *resultobj;
3788 wxBrush *arg1 = (wxBrush *) 0 ;
3789 wxColour result;
3790 PyObject * obj0 = 0 ;
3791 char *kwnames[] = {
3792 (char *) "self", NULL
3793 };
3794
3795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetColour",kwnames,&obj0)) goto fail;
3796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3797 if (SWIG_arg_fail(1)) SWIG_fail;
3798 {
3799 PyThreadState* __tstate = wxPyBeginAllowThreads();
3800 result = ((wxBrush const *)arg1)->GetColour();
3801
3802 wxPyEndAllowThreads(__tstate);
3803 if (PyErr_Occurred()) SWIG_fail;
3804 }
3805 {
3806 wxColour * resultptr;
3807 resultptr = new wxColour((wxColour &)(result));
3808 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3809 }
3810 return resultobj;
3811 fail:
3812 return NULL;
3813 }
3814
3815
3816 static PyObject *_wrap_Brush_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
3817 PyObject *resultobj;
3818 wxBrush *arg1 = (wxBrush *) 0 ;
3819 int result;
3820 PyObject * obj0 = 0 ;
3821 char *kwnames[] = {
3822 (char *) "self", NULL
3823 };
3824
3825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStyle",kwnames,&obj0)) goto fail;
3826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3827 if (SWIG_arg_fail(1)) SWIG_fail;
3828 {
3829 PyThreadState* __tstate = wxPyBeginAllowThreads();
3830 result = (int)((wxBrush const *)arg1)->GetStyle();
3831
3832 wxPyEndAllowThreads(__tstate);
3833 if (PyErr_Occurred()) SWIG_fail;
3834 }
3835 {
3836 resultobj = SWIG_From_int((int)(result));
3837 }
3838 return resultobj;
3839 fail:
3840 return NULL;
3841 }
3842
3843
3844 static PyObject *_wrap_Brush_GetStipple(PyObject *, PyObject *args, PyObject *kwargs) {
3845 PyObject *resultobj;
3846 wxBrush *arg1 = (wxBrush *) 0 ;
3847 wxBitmap *result;
3848 PyObject * obj0 = 0 ;
3849 char *kwnames[] = {
3850 (char *) "self", NULL
3851 };
3852
3853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_GetStipple",kwnames,&obj0)) goto fail;
3854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3855 if (SWIG_arg_fail(1)) SWIG_fail;
3856 {
3857 PyThreadState* __tstate = wxPyBeginAllowThreads();
3858 result = (wxBitmap *)((wxBrush const *)arg1)->GetStipple();
3859
3860 wxPyEndAllowThreads(__tstate);
3861 if (PyErr_Occurred()) SWIG_fail;
3862 }
3863 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 0);
3864 return resultobj;
3865 fail:
3866 return NULL;
3867 }
3868
3869
3870 static PyObject *_wrap_Brush_IsHatch(PyObject *, PyObject *args, PyObject *kwargs) {
3871 PyObject *resultobj;
3872 wxBrush *arg1 = (wxBrush *) 0 ;
3873 bool result;
3874 PyObject * obj0 = 0 ;
3875 char *kwnames[] = {
3876 (char *) "self", NULL
3877 };
3878
3879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_IsHatch",kwnames,&obj0)) goto fail;
3880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3881 if (SWIG_arg_fail(1)) SWIG_fail;
3882 {
3883 PyThreadState* __tstate = wxPyBeginAllowThreads();
3884 result = (bool)((wxBrush const *)arg1)->IsHatch();
3885
3886 wxPyEndAllowThreads(__tstate);
3887 if (PyErr_Occurred()) SWIG_fail;
3888 }
3889 {
3890 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3891 }
3892 return resultobj;
3893 fail:
3894 return NULL;
3895 }
3896
3897
3898 static PyObject *_wrap_Brush_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
3899 PyObject *resultobj;
3900 wxBrush *arg1 = (wxBrush *) 0 ;
3901 bool result;
3902 PyObject * obj0 = 0 ;
3903 char *kwnames[] = {
3904 (char *) "self", NULL
3905 };
3906
3907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Brush_Ok",kwnames,&obj0)) goto fail;
3908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
3909 if (SWIG_arg_fail(1)) SWIG_fail;
3910 {
3911 PyThreadState* __tstate = wxPyBeginAllowThreads();
3912 result = (bool)(arg1)->Ok();
3913
3914 wxPyEndAllowThreads(__tstate);
3915 if (PyErr_Occurred()) SWIG_fail;
3916 }
3917 {
3918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3919 }
3920 return resultobj;
3921 fail:
3922 return NULL;
3923 }
3924
3925
3926 static PyObject * Brush_swigregister(PyObject *, PyObject *args) {
3927 PyObject *obj;
3928 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3929 SWIG_TypeClientData(SWIGTYPE_p_wxBrush, obj);
3930 Py_INCREF(obj);
3931 return Py_BuildValue((char *)"");
3932 }
3933 static PyObject *_wrap_new_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
3934 PyObject *resultobj;
3935 wxString *arg1 = 0 ;
3936 wxBitmapType arg2 = (wxBitmapType) wxBITMAP_TYPE_ANY ;
3937 wxBitmap *result;
3938 bool temp1 = false ;
3939 PyObject * obj0 = 0 ;
3940 PyObject * obj1 = 0 ;
3941 char *kwnames[] = {
3942 (char *) "name",(char *) "type", NULL
3943 };
3944
3945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Bitmap",kwnames,&obj0,&obj1)) goto fail;
3946 {
3947 arg1 = wxString_in_helper(obj0);
3948 if (arg1 == NULL) SWIG_fail;
3949 temp1 = true;
3950 }
3951 if (obj1) {
3952 {
3953 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
3954 if (SWIG_arg_fail(2)) SWIG_fail;
3955 }
3956 }
3957 {
3958 if (!wxPyCheckForApp()) SWIG_fail;
3959 PyThreadState* __tstate = wxPyBeginAllowThreads();
3960 result = (wxBitmap *)new wxBitmap((wxString const &)*arg1,(wxBitmapType )arg2);
3961
3962 wxPyEndAllowThreads(__tstate);
3963 if (PyErr_Occurred()) SWIG_fail;
3964 }
3965 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
3966 {
3967 if (temp1)
3968 delete arg1;
3969 }
3970 return resultobj;
3971 fail:
3972 {
3973 if (temp1)
3974 delete arg1;
3975 }
3976 return NULL;
3977 }
3978
3979
3980 static PyObject *_wrap_delete_Bitmap(PyObject *, PyObject *args, PyObject *kwargs) {
3981 PyObject *resultobj;
3982 wxBitmap *arg1 = (wxBitmap *) 0 ;
3983 PyObject * obj0 = 0 ;
3984 char *kwnames[] = {
3985 (char *) "self", NULL
3986 };
3987
3988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Bitmap",kwnames,&obj0)) goto fail;
3989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
3990 if (SWIG_arg_fail(1)) SWIG_fail;
3991 {
3992 PyThreadState* __tstate = wxPyBeginAllowThreads();
3993 delete arg1;
3994
3995 wxPyEndAllowThreads(__tstate);
3996 if (PyErr_Occurred()) SWIG_fail;
3997 }
3998 Py_INCREF(Py_None); resultobj = Py_None;
3999 return resultobj;
4000 fail:
4001 return NULL;
4002 }
4003
4004
4005 static PyObject *_wrap_new_EmptyBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4006 PyObject *resultobj;
4007 int arg1 ;
4008 int arg2 ;
4009 int arg3 = (int) -1 ;
4010 wxBitmap *result;
4011 PyObject * obj0 = 0 ;
4012 PyObject * obj1 = 0 ;
4013 PyObject * obj2 = 0 ;
4014 char *kwnames[] = {
4015 (char *) "width",(char *) "height",(char *) "depth", NULL
4016 };
4017
4018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_EmptyBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
4019 {
4020 arg1 = (int)(SWIG_As_int(obj0));
4021 if (SWIG_arg_fail(1)) SWIG_fail;
4022 }
4023 {
4024 arg2 = (int)(SWIG_As_int(obj1));
4025 if (SWIG_arg_fail(2)) SWIG_fail;
4026 }
4027 if (obj2) {
4028 {
4029 arg3 = (int)(SWIG_As_int(obj2));
4030 if (SWIG_arg_fail(3)) SWIG_fail;
4031 }
4032 }
4033 {
4034 if (!wxPyCheckForApp()) SWIG_fail;
4035 PyThreadState* __tstate = wxPyBeginAllowThreads();
4036 result = (wxBitmap *)new wxBitmap(arg1,arg2,arg3);
4037
4038 wxPyEndAllowThreads(__tstate);
4039 if (PyErr_Occurred()) SWIG_fail;
4040 }
4041 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4042 return resultobj;
4043 fail:
4044 return NULL;
4045 }
4046
4047
4048 static PyObject *_wrap_new_BitmapFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4049 PyObject *resultobj;
4050 wxIcon *arg1 = 0 ;
4051 wxBitmap *result;
4052 PyObject * obj0 = 0 ;
4053 char *kwnames[] = {
4054 (char *) "icon", NULL
4055 };
4056
4057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromIcon",kwnames,&obj0)) goto fail;
4058 {
4059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4060 if (SWIG_arg_fail(1)) SWIG_fail;
4061 if (arg1 == NULL) {
4062 SWIG_null_ref("wxIcon");
4063 }
4064 if (SWIG_arg_fail(1)) SWIG_fail;
4065 }
4066 {
4067 if (!wxPyCheckForApp()) SWIG_fail;
4068 PyThreadState* __tstate = wxPyBeginAllowThreads();
4069 result = (wxBitmap *)new wxBitmap((wxIcon const &)*arg1);
4070
4071 wxPyEndAllowThreads(__tstate);
4072 if (PyErr_Occurred()) SWIG_fail;
4073 }
4074 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4075 return resultobj;
4076 fail:
4077 return NULL;
4078 }
4079
4080
4081 static PyObject *_wrap_new_BitmapFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
4082 PyObject *resultobj;
4083 wxImage *arg1 = 0 ;
4084 int arg2 = (int) -1 ;
4085 wxBitmap *result;
4086 PyObject * obj0 = 0 ;
4087 PyObject * obj1 = 0 ;
4088 char *kwnames[] = {
4089 (char *) "image",(char *) "depth", NULL
4090 };
4091
4092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BitmapFromImage",kwnames,&obj0,&obj1)) goto fail;
4093 {
4094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
4095 if (SWIG_arg_fail(1)) SWIG_fail;
4096 if (arg1 == NULL) {
4097 SWIG_null_ref("wxImage");
4098 }
4099 if (SWIG_arg_fail(1)) SWIG_fail;
4100 }
4101 if (obj1) {
4102 {
4103 arg2 = (int)(SWIG_As_int(obj1));
4104 if (SWIG_arg_fail(2)) SWIG_fail;
4105 }
4106 }
4107 {
4108 if (!wxPyCheckForApp()) SWIG_fail;
4109 PyThreadState* __tstate = wxPyBeginAllowThreads();
4110 result = (wxBitmap *)new wxBitmap((wxImage const &)*arg1,arg2);
4111
4112 wxPyEndAllowThreads(__tstate);
4113 if (PyErr_Occurred()) SWIG_fail;
4114 }
4115 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4116 return resultobj;
4117 fail:
4118 return NULL;
4119 }
4120
4121
4122 static PyObject *_wrap_new_BitmapFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
4123 PyObject *resultobj;
4124 PyObject *arg1 = (PyObject *) 0 ;
4125 wxBitmap *result;
4126 PyObject * obj0 = 0 ;
4127 char *kwnames[] = {
4128 (char *) "listOfStrings", NULL
4129 };
4130
4131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BitmapFromXPMData",kwnames,&obj0)) goto fail;
4132 arg1 = obj0;
4133 {
4134 if (!wxPyCheckForApp()) SWIG_fail;
4135 PyThreadState* __tstate = wxPyBeginAllowThreads();
4136 result = (wxBitmap *)new_wxBitmap(arg1);
4137
4138 wxPyEndAllowThreads(__tstate);
4139 if (PyErr_Occurred()) SWIG_fail;
4140 }
4141 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4142 return resultobj;
4143 fail:
4144 return NULL;
4145 }
4146
4147
4148 static PyObject *_wrap_new_BitmapFromBits(PyObject *, PyObject *args, PyObject *kwargs) {
4149 PyObject *resultobj;
4150 PyObject *arg1 = (PyObject *) 0 ;
4151 int arg2 ;
4152 int arg3 ;
4153 int arg4 = (int) 1 ;
4154 wxBitmap *result;
4155 PyObject * obj0 = 0 ;
4156 PyObject * obj1 = 0 ;
4157 PyObject * obj2 = 0 ;
4158 PyObject * obj3 = 0 ;
4159 char *kwnames[] = {
4160 (char *) "bits",(char *) "width",(char *) "height",(char *) "depth", NULL
4161 };
4162
4163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:new_BitmapFromBits",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4164 arg1 = obj0;
4165 {
4166 arg2 = (int)(SWIG_As_int(obj1));
4167 if (SWIG_arg_fail(2)) SWIG_fail;
4168 }
4169 {
4170 arg3 = (int)(SWIG_As_int(obj2));
4171 if (SWIG_arg_fail(3)) SWIG_fail;
4172 }
4173 if (obj3) {
4174 {
4175 arg4 = (int)(SWIG_As_int(obj3));
4176 if (SWIG_arg_fail(4)) SWIG_fail;
4177 }
4178 }
4179 {
4180 if (!wxPyCheckForApp()) SWIG_fail;
4181 PyThreadState* __tstate = wxPyBeginAllowThreads();
4182 result = (wxBitmap *)new_wxBitmap(arg1,arg2,arg3,arg4);
4183
4184 wxPyEndAllowThreads(__tstate);
4185 if (PyErr_Occurred()) SWIG_fail;
4186 }
4187 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmap, 1);
4188 return resultobj;
4189 fail:
4190 return NULL;
4191 }
4192
4193
4194 static PyObject *_wrap_Bitmap_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
4195 PyObject *resultobj;
4196 wxBitmap *arg1 = (wxBitmap *) 0 ;
4197 bool result;
4198 PyObject * obj0 = 0 ;
4199 char *kwnames[] = {
4200 (char *) "self", NULL
4201 };
4202
4203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_Ok",kwnames,&obj0)) goto fail;
4204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4205 if (SWIG_arg_fail(1)) SWIG_fail;
4206 {
4207 PyThreadState* __tstate = wxPyBeginAllowThreads();
4208 result = (bool)(arg1)->Ok();
4209
4210 wxPyEndAllowThreads(__tstate);
4211 if (PyErr_Occurred()) SWIG_fail;
4212 }
4213 {
4214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4215 }
4216 return resultobj;
4217 fail:
4218 return NULL;
4219 }
4220
4221
4222 static PyObject *_wrap_Bitmap_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4223 PyObject *resultobj;
4224 wxBitmap *arg1 = (wxBitmap *) 0 ;
4225 int result;
4226 PyObject * obj0 = 0 ;
4227 char *kwnames[] = {
4228 (char *) "self", NULL
4229 };
4230
4231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetWidth",kwnames,&obj0)) goto fail;
4232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4233 if (SWIG_arg_fail(1)) SWIG_fail;
4234 {
4235 PyThreadState* __tstate = wxPyBeginAllowThreads();
4236 result = (int)(arg1)->GetWidth();
4237
4238 wxPyEndAllowThreads(__tstate);
4239 if (PyErr_Occurred()) SWIG_fail;
4240 }
4241 {
4242 resultobj = SWIG_From_int((int)(result));
4243 }
4244 return resultobj;
4245 fail:
4246 return NULL;
4247 }
4248
4249
4250 static PyObject *_wrap_Bitmap_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4251 PyObject *resultobj;
4252 wxBitmap *arg1 = (wxBitmap *) 0 ;
4253 int result;
4254 PyObject * obj0 = 0 ;
4255 char *kwnames[] = {
4256 (char *) "self", NULL
4257 };
4258
4259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetHeight",kwnames,&obj0)) goto fail;
4260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4261 if (SWIG_arg_fail(1)) SWIG_fail;
4262 {
4263 PyThreadState* __tstate = wxPyBeginAllowThreads();
4264 result = (int)(arg1)->GetHeight();
4265
4266 wxPyEndAllowThreads(__tstate);
4267 if (PyErr_Occurred()) SWIG_fail;
4268 }
4269 {
4270 resultobj = SWIG_From_int((int)(result));
4271 }
4272 return resultobj;
4273 fail:
4274 return NULL;
4275 }
4276
4277
4278 static PyObject *_wrap_Bitmap_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4279 PyObject *resultobj;
4280 wxBitmap *arg1 = (wxBitmap *) 0 ;
4281 int result;
4282 PyObject * obj0 = 0 ;
4283 char *kwnames[] = {
4284 (char *) "self", NULL
4285 };
4286
4287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetDepth",kwnames,&obj0)) goto fail;
4288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4289 if (SWIG_arg_fail(1)) SWIG_fail;
4290 {
4291 PyThreadState* __tstate = wxPyBeginAllowThreads();
4292 result = (int)(arg1)->GetDepth();
4293
4294 wxPyEndAllowThreads(__tstate);
4295 if (PyErr_Occurred()) SWIG_fail;
4296 }
4297 {
4298 resultobj = SWIG_From_int((int)(result));
4299 }
4300 return resultobj;
4301 fail:
4302 return NULL;
4303 }
4304
4305
4306 static PyObject *_wrap_Bitmap_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4307 PyObject *resultobj;
4308 wxBitmap *arg1 = (wxBitmap *) 0 ;
4309 wxSize result;
4310 PyObject * obj0 = 0 ;
4311 char *kwnames[] = {
4312 (char *) "self", NULL
4313 };
4314
4315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetSize",kwnames,&obj0)) goto fail;
4316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4317 if (SWIG_arg_fail(1)) SWIG_fail;
4318 {
4319 PyThreadState* __tstate = wxPyBeginAllowThreads();
4320 result = wxBitmap_GetSize(arg1);
4321
4322 wxPyEndAllowThreads(__tstate);
4323 if (PyErr_Occurred()) SWIG_fail;
4324 }
4325 {
4326 wxSize * resultptr;
4327 resultptr = new wxSize((wxSize &)(result));
4328 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
4329 }
4330 return resultobj;
4331 fail:
4332 return NULL;
4333 }
4334
4335
4336 static PyObject *_wrap_Bitmap_ConvertToImage(PyObject *, PyObject *args, PyObject *kwargs) {
4337 PyObject *resultobj;
4338 wxBitmap *arg1 = (wxBitmap *) 0 ;
4339 SwigValueWrapper<wxImage > result;
4340 PyObject * obj0 = 0 ;
4341 char *kwnames[] = {
4342 (char *) "self", NULL
4343 };
4344
4345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_ConvertToImage",kwnames,&obj0)) goto fail;
4346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4347 if (SWIG_arg_fail(1)) SWIG_fail;
4348 {
4349 PyThreadState* __tstate = wxPyBeginAllowThreads();
4350 result = ((wxBitmap const *)arg1)->ConvertToImage();
4351
4352 wxPyEndAllowThreads(__tstate);
4353 if (PyErr_Occurred()) SWIG_fail;
4354 }
4355 {
4356 wxImage * resultptr;
4357 resultptr = new wxImage((wxImage &)(result));
4358 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
4359 }
4360 return resultobj;
4361 fail:
4362 return NULL;
4363 }
4364
4365
4366 static PyObject *_wrap_Bitmap_GetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4367 PyObject *resultobj;
4368 wxBitmap *arg1 = (wxBitmap *) 0 ;
4369 wxMask *result;
4370 PyObject * obj0 = 0 ;
4371 char *kwnames[] = {
4372 (char *) "self", NULL
4373 };
4374
4375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetMask",kwnames,&obj0)) goto fail;
4376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4377 if (SWIG_arg_fail(1)) SWIG_fail;
4378 {
4379 PyThreadState* __tstate = wxPyBeginAllowThreads();
4380 result = (wxMask *)((wxBitmap const *)arg1)->GetMask();
4381
4382 wxPyEndAllowThreads(__tstate);
4383 if (PyErr_Occurred()) SWIG_fail;
4384 }
4385 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 0);
4386 return resultobj;
4387 fail:
4388 return NULL;
4389 }
4390
4391
4392 static PyObject *_wrap_Bitmap_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
4393 PyObject *resultobj;
4394 wxBitmap *arg1 = (wxBitmap *) 0 ;
4395 wxMask *arg2 = (wxMask *) 0 ;
4396 PyObject * obj0 = 0 ;
4397 PyObject * obj1 = 0 ;
4398 char *kwnames[] = {
4399 (char *) "self",(char *) "mask", NULL
4400 };
4401
4402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMask",kwnames,&obj0,&obj1)) goto fail;
4403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4404 if (SWIG_arg_fail(1)) SWIG_fail;
4405 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMask, SWIG_POINTER_EXCEPTION | 0);
4406 if (SWIG_arg_fail(2)) SWIG_fail;
4407 {
4408 PyThreadState* __tstate = wxPyBeginAllowThreads();
4409 (arg1)->SetMask(arg2);
4410
4411 wxPyEndAllowThreads(__tstate);
4412 if (PyErr_Occurred()) SWIG_fail;
4413 }
4414 Py_INCREF(Py_None); resultobj = Py_None;
4415 return resultobj;
4416 fail:
4417 return NULL;
4418 }
4419
4420
4421 static PyObject *_wrap_Bitmap_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
4422 PyObject *resultobj;
4423 wxBitmap *arg1 = (wxBitmap *) 0 ;
4424 wxColour *arg2 = 0 ;
4425 wxColour temp2 ;
4426 PyObject * obj0 = 0 ;
4427 PyObject * obj1 = 0 ;
4428 char *kwnames[] = {
4429 (char *) "self",(char *) "colour", NULL
4430 };
4431
4432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetMaskColour",kwnames,&obj0,&obj1)) goto fail;
4433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4434 if (SWIG_arg_fail(1)) SWIG_fail;
4435 {
4436 arg2 = &temp2;
4437 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4438 }
4439 {
4440 PyThreadState* __tstate = wxPyBeginAllowThreads();
4441 wxBitmap_SetMaskColour(arg1,(wxColour const &)*arg2);
4442
4443 wxPyEndAllowThreads(__tstate);
4444 if (PyErr_Occurred()) SWIG_fail;
4445 }
4446 Py_INCREF(Py_None); resultobj = Py_None;
4447 return resultobj;
4448 fail:
4449 return NULL;
4450 }
4451
4452
4453 static PyObject *_wrap_Bitmap_GetSubBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
4454 PyObject *resultobj;
4455 wxBitmap *arg1 = (wxBitmap *) 0 ;
4456 wxRect *arg2 = 0 ;
4457 SwigValueWrapper<wxBitmap > result;
4458 wxRect temp2 ;
4459 PyObject * obj0 = 0 ;
4460 PyObject * obj1 = 0 ;
4461 char *kwnames[] = {
4462 (char *) "self",(char *) "rect", NULL
4463 };
4464
4465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_GetSubBitmap",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 {
4469 arg2 = &temp2;
4470 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
4471 }
4472 {
4473 PyThreadState* __tstate = wxPyBeginAllowThreads();
4474 result = ((wxBitmap const *)arg1)->GetSubBitmap((wxRect const &)*arg2);
4475
4476 wxPyEndAllowThreads(__tstate);
4477 if (PyErr_Occurred()) SWIG_fail;
4478 }
4479 {
4480 wxBitmap * resultptr;
4481 resultptr = new wxBitmap((wxBitmap &)(result));
4482 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
4483 }
4484 return resultobj;
4485 fail:
4486 return NULL;
4487 }
4488
4489
4490 static PyObject *_wrap_Bitmap_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
4491 PyObject *resultobj;
4492 wxBitmap *arg1 = (wxBitmap *) 0 ;
4493 wxString *arg2 = 0 ;
4494 wxBitmapType arg3 ;
4495 wxPalette *arg4 = (wxPalette *) NULL ;
4496 bool result;
4497 bool temp2 = false ;
4498 PyObject * obj0 = 0 ;
4499 PyObject * obj1 = 0 ;
4500 PyObject * obj2 = 0 ;
4501 PyObject * obj3 = 0 ;
4502 char *kwnames[] = {
4503 (char *) "self",(char *) "name",(char *) "type",(char *) "palette", NULL
4504 };
4505
4506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Bitmap_SaveFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4508 if (SWIG_arg_fail(1)) SWIG_fail;
4509 {
4510 arg2 = wxString_in_helper(obj1);
4511 if (arg2 == NULL) SWIG_fail;
4512 temp2 = true;
4513 }
4514 {
4515 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4516 if (SWIG_arg_fail(3)) SWIG_fail;
4517 }
4518 if (obj3) {
4519 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
4520 if (SWIG_arg_fail(4)) SWIG_fail;
4521 }
4522 {
4523 PyThreadState* __tstate = wxPyBeginAllowThreads();
4524 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxBitmapType )arg3,arg4);
4525
4526 wxPyEndAllowThreads(__tstate);
4527 if (PyErr_Occurred()) SWIG_fail;
4528 }
4529 {
4530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4531 }
4532 {
4533 if (temp2)
4534 delete arg2;
4535 }
4536 return resultobj;
4537 fail:
4538 {
4539 if (temp2)
4540 delete arg2;
4541 }
4542 return NULL;
4543 }
4544
4545
4546 static PyObject *_wrap_Bitmap_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
4547 PyObject *resultobj;
4548 wxBitmap *arg1 = (wxBitmap *) 0 ;
4549 wxString *arg2 = 0 ;
4550 wxBitmapType arg3 ;
4551 bool result;
4552 bool temp2 = false ;
4553 PyObject * obj0 = 0 ;
4554 PyObject * obj1 = 0 ;
4555 PyObject * obj2 = 0 ;
4556 char *kwnames[] = {
4557 (char *) "self",(char *) "name",(char *) "type", NULL
4558 };
4559
4560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Bitmap_LoadFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
4561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4562 if (SWIG_arg_fail(1)) SWIG_fail;
4563 {
4564 arg2 = wxString_in_helper(obj1);
4565 if (arg2 == NULL) SWIG_fail;
4566 temp2 = true;
4567 }
4568 {
4569 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
4570 if (SWIG_arg_fail(3)) SWIG_fail;
4571 }
4572 {
4573 PyThreadState* __tstate = wxPyBeginAllowThreads();
4574 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxBitmapType )arg3);
4575
4576 wxPyEndAllowThreads(__tstate);
4577 if (PyErr_Occurred()) SWIG_fail;
4578 }
4579 {
4580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4581 }
4582 {
4583 if (temp2)
4584 delete arg2;
4585 }
4586 return resultobj;
4587 fail:
4588 {
4589 if (temp2)
4590 delete arg2;
4591 }
4592 return NULL;
4593 }
4594
4595
4596 static PyObject *_wrap_Bitmap_GetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
4597 PyObject *resultobj;
4598 wxBitmap *arg1 = (wxBitmap *) 0 ;
4599 wxPalette *result;
4600 PyObject * obj0 = 0 ;
4601 char *kwnames[] = {
4602 (char *) "self", NULL
4603 };
4604
4605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Bitmap_GetPalette",kwnames,&obj0)) goto fail;
4606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4607 if (SWIG_arg_fail(1)) SWIG_fail;
4608 {
4609 PyThreadState* __tstate = wxPyBeginAllowThreads();
4610 result = (wxPalette *)((wxBitmap const *)arg1)->GetPalette();
4611
4612 wxPyEndAllowThreads(__tstate);
4613 if (PyErr_Occurred()) SWIG_fail;
4614 }
4615 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPalette, 0);
4616 return resultobj;
4617 fail:
4618 return NULL;
4619 }
4620
4621
4622 static PyObject *_wrap_Bitmap_CopyFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4623 PyObject *resultobj;
4624 wxBitmap *arg1 = (wxBitmap *) 0 ;
4625 wxIcon *arg2 = 0 ;
4626 bool result;
4627 PyObject * obj0 = 0 ;
4628 PyObject * obj1 = 0 ;
4629 char *kwnames[] = {
4630 (char *) "self",(char *) "icon", NULL
4631 };
4632
4633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_CopyFromIcon",kwnames,&obj0,&obj1)) goto fail;
4634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4635 if (SWIG_arg_fail(1)) SWIG_fail;
4636 {
4637 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4638 if (SWIG_arg_fail(2)) SWIG_fail;
4639 if (arg2 == NULL) {
4640 SWIG_null_ref("wxIcon");
4641 }
4642 if (SWIG_arg_fail(2)) SWIG_fail;
4643 }
4644 {
4645 PyThreadState* __tstate = wxPyBeginAllowThreads();
4646 result = (bool)(arg1)->CopyFromIcon((wxIcon const &)*arg2);
4647
4648 wxPyEndAllowThreads(__tstate);
4649 if (PyErr_Occurred()) SWIG_fail;
4650 }
4651 {
4652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4653 }
4654 return resultobj;
4655 fail:
4656 return NULL;
4657 }
4658
4659
4660 static PyObject *_wrap_Bitmap_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
4661 PyObject *resultobj;
4662 wxBitmap *arg1 = (wxBitmap *) 0 ;
4663 int arg2 ;
4664 PyObject * obj0 = 0 ;
4665 PyObject * obj1 = 0 ;
4666 char *kwnames[] = {
4667 (char *) "self",(char *) "height", NULL
4668 };
4669
4670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetHeight",kwnames,&obj0,&obj1)) goto fail;
4671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4672 if (SWIG_arg_fail(1)) SWIG_fail;
4673 {
4674 arg2 = (int)(SWIG_As_int(obj1));
4675 if (SWIG_arg_fail(2)) SWIG_fail;
4676 }
4677 {
4678 PyThreadState* __tstate = wxPyBeginAllowThreads();
4679 (arg1)->SetHeight(arg2);
4680
4681 wxPyEndAllowThreads(__tstate);
4682 if (PyErr_Occurred()) SWIG_fail;
4683 }
4684 Py_INCREF(Py_None); resultobj = Py_None;
4685 return resultobj;
4686 fail:
4687 return NULL;
4688 }
4689
4690
4691 static PyObject *_wrap_Bitmap_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
4692 PyObject *resultobj;
4693 wxBitmap *arg1 = (wxBitmap *) 0 ;
4694 int arg2 ;
4695 PyObject * obj0 = 0 ;
4696 PyObject * obj1 = 0 ;
4697 char *kwnames[] = {
4698 (char *) "self",(char *) "width", NULL
4699 };
4700
4701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetWidth",kwnames,&obj0,&obj1)) goto fail;
4702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4703 if (SWIG_arg_fail(1)) SWIG_fail;
4704 {
4705 arg2 = (int)(SWIG_As_int(obj1));
4706 if (SWIG_arg_fail(2)) SWIG_fail;
4707 }
4708 {
4709 PyThreadState* __tstate = wxPyBeginAllowThreads();
4710 (arg1)->SetWidth(arg2);
4711
4712 wxPyEndAllowThreads(__tstate);
4713 if (PyErr_Occurred()) SWIG_fail;
4714 }
4715 Py_INCREF(Py_None); resultobj = Py_None;
4716 return resultobj;
4717 fail:
4718 return NULL;
4719 }
4720
4721
4722 static PyObject *_wrap_Bitmap_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
4723 PyObject *resultobj;
4724 wxBitmap *arg1 = (wxBitmap *) 0 ;
4725 int arg2 ;
4726 PyObject * obj0 = 0 ;
4727 PyObject * obj1 = 0 ;
4728 char *kwnames[] = {
4729 (char *) "self",(char *) "depth", NULL
4730 };
4731
4732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetDepth",kwnames,&obj0,&obj1)) goto fail;
4733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4734 if (SWIG_arg_fail(1)) SWIG_fail;
4735 {
4736 arg2 = (int)(SWIG_As_int(obj1));
4737 if (SWIG_arg_fail(2)) SWIG_fail;
4738 }
4739 {
4740 PyThreadState* __tstate = wxPyBeginAllowThreads();
4741 (arg1)->SetDepth(arg2);
4742
4743 wxPyEndAllowThreads(__tstate);
4744 if (PyErr_Occurred()) SWIG_fail;
4745 }
4746 Py_INCREF(Py_None); resultobj = Py_None;
4747 return resultobj;
4748 fail:
4749 return NULL;
4750 }
4751
4752
4753 static PyObject *_wrap_Bitmap_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
4754 PyObject *resultobj;
4755 wxBitmap *arg1 = (wxBitmap *) 0 ;
4756 wxSize *arg2 = 0 ;
4757 wxSize temp2 ;
4758 PyObject * obj0 = 0 ;
4759 PyObject * obj1 = 0 ;
4760 char *kwnames[] = {
4761 (char *) "self",(char *) "size", NULL
4762 };
4763
4764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap_SetSize",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 = &temp2;
4769 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4770 }
4771 {
4772 PyThreadState* __tstate = wxPyBeginAllowThreads();
4773 wxBitmap_SetSize(arg1,(wxSize const &)*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___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4786 PyObject *resultobj;
4787 wxBitmap *arg1 = (wxBitmap *) 0 ;
4788 wxBitmap *arg2 = (wxBitmap *) 0 ;
4789 bool result;
4790 PyObject * obj0 = 0 ;
4791 PyObject * obj1 = 0 ;
4792 char *kwnames[] = {
4793 (char *) "self",(char *) "other", NULL
4794 };
4795
4796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___eq__",kwnames,&obj0,&obj1)) goto fail;
4797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4798 if (SWIG_arg_fail(1)) SWIG_fail;
4799 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4800 if (SWIG_arg_fail(2)) SWIG_fail;
4801 {
4802 PyThreadState* __tstate = wxPyBeginAllowThreads();
4803 result = (bool)wxBitmap___eq__(arg1,(wxBitmap const *)arg2);
4804
4805 wxPyEndAllowThreads(__tstate);
4806 if (PyErr_Occurred()) SWIG_fail;
4807 }
4808 {
4809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4810 }
4811 return resultobj;
4812 fail:
4813 return NULL;
4814 }
4815
4816
4817 static PyObject *_wrap_Bitmap___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4818 PyObject *resultobj;
4819 wxBitmap *arg1 = (wxBitmap *) 0 ;
4820 wxBitmap *arg2 = (wxBitmap *) 0 ;
4821 bool result;
4822 PyObject * obj0 = 0 ;
4823 PyObject * obj1 = 0 ;
4824 char *kwnames[] = {
4825 (char *) "self",(char *) "other", NULL
4826 };
4827
4828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Bitmap___ne__",kwnames,&obj0,&obj1)) goto fail;
4829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4830 if (SWIG_arg_fail(1)) SWIG_fail;
4831 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4832 if (SWIG_arg_fail(2)) SWIG_fail;
4833 {
4834 PyThreadState* __tstate = wxPyBeginAllowThreads();
4835 result = (bool)wxBitmap___ne__(arg1,(wxBitmap const *)arg2);
4836
4837 wxPyEndAllowThreads(__tstate);
4838 if (PyErr_Occurred()) SWIG_fail;
4839 }
4840 {
4841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4842 }
4843 return resultobj;
4844 fail:
4845 return NULL;
4846 }
4847
4848
4849 static PyObject * Bitmap_swigregister(PyObject *, PyObject *args) {
4850 PyObject *obj;
4851 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4852 SWIG_TypeClientData(SWIGTYPE_p_wxBitmap, obj);
4853 Py_INCREF(obj);
4854 return Py_BuildValue((char *)"");
4855 }
4856 static PyObject *_wrap_new_Mask(PyObject *, PyObject *args, PyObject *kwargs) {
4857 PyObject *resultobj;
4858 wxBitmap *arg1 = 0 ;
4859 wxColour const &arg2_defvalue = wxNullColour ;
4860 wxColour *arg2 = (wxColour *) &arg2_defvalue ;
4861 wxMask *result;
4862 wxColour temp2 ;
4863 PyObject * obj0 = 0 ;
4864 PyObject * obj1 = 0 ;
4865 char *kwnames[] = {
4866 (char *) "bitmap",(char *) "colour", NULL
4867 };
4868
4869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_Mask",kwnames,&obj0,&obj1)) goto fail;
4870 {
4871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
4872 if (SWIG_arg_fail(1)) SWIG_fail;
4873 if (arg1 == NULL) {
4874 SWIG_null_ref("wxBitmap");
4875 }
4876 if (SWIG_arg_fail(1)) SWIG_fail;
4877 }
4878 if (obj1) {
4879 {
4880 arg2 = &temp2;
4881 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
4882 }
4883 }
4884 {
4885 if (!wxPyCheckForApp()) SWIG_fail;
4886 PyThreadState* __tstate = wxPyBeginAllowThreads();
4887 result = (wxMask *)new_wxMask((wxBitmap const &)*arg1,(wxColour const &)*arg2);
4888
4889 wxPyEndAllowThreads(__tstate);
4890 if (PyErr_Occurred()) SWIG_fail;
4891 }
4892 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMask, 1);
4893 return resultobj;
4894 fail:
4895 return NULL;
4896 }
4897
4898
4899 static PyObject * Mask_swigregister(PyObject *, PyObject *args) {
4900 PyObject *obj;
4901 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4902 SWIG_TypeClientData(SWIGTYPE_p_wxMask, obj);
4903 Py_INCREF(obj);
4904 return Py_BuildValue((char *)"");
4905 }
4906 static PyObject *_wrap_new_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
4907 PyObject *resultobj;
4908 wxString *arg1 = 0 ;
4909 wxBitmapType arg2 ;
4910 int arg3 = (int) -1 ;
4911 int arg4 = (int) -1 ;
4912 wxIcon *result;
4913 bool temp1 = false ;
4914 PyObject * obj0 = 0 ;
4915 PyObject * obj1 = 0 ;
4916 PyObject * obj2 = 0 ;
4917 PyObject * obj3 = 0 ;
4918 char *kwnames[] = {
4919 (char *) "name",(char *) "type",(char *) "desiredWidth",(char *) "desiredHeight", NULL
4920 };
4921
4922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Icon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4923 {
4924 arg1 = wxString_in_helper(obj0);
4925 if (arg1 == NULL) SWIG_fail;
4926 temp1 = true;
4927 }
4928 {
4929 arg2 = (wxBitmapType)(SWIG_As_int(obj1));
4930 if (SWIG_arg_fail(2)) SWIG_fail;
4931 }
4932 if (obj2) {
4933 {
4934 arg3 = (int)(SWIG_As_int(obj2));
4935 if (SWIG_arg_fail(3)) SWIG_fail;
4936 }
4937 }
4938 if (obj3) {
4939 {
4940 arg4 = (int)(SWIG_As_int(obj3));
4941 if (SWIG_arg_fail(4)) SWIG_fail;
4942 }
4943 }
4944 {
4945 if (!wxPyCheckForApp()) SWIG_fail;
4946 PyThreadState* __tstate = wxPyBeginAllowThreads();
4947 result = (wxIcon *)new wxIcon((wxString const &)*arg1,(wxBitmapType )arg2,arg3,arg4);
4948
4949 wxPyEndAllowThreads(__tstate);
4950 if (PyErr_Occurred()) SWIG_fail;
4951 }
4952 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
4953 {
4954 if (temp1)
4955 delete arg1;
4956 }
4957 return resultobj;
4958 fail:
4959 {
4960 if (temp1)
4961 delete arg1;
4962 }
4963 return NULL;
4964 }
4965
4966
4967 static PyObject *_wrap_delete_Icon(PyObject *, PyObject *args, PyObject *kwargs) {
4968 PyObject *resultobj;
4969 wxIcon *arg1 = (wxIcon *) 0 ;
4970 PyObject * obj0 = 0 ;
4971 char *kwnames[] = {
4972 (char *) "self", NULL
4973 };
4974
4975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Icon",kwnames,&obj0)) goto fail;
4976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
4977 if (SWIG_arg_fail(1)) SWIG_fail;
4978 {
4979 PyThreadState* __tstate = wxPyBeginAllowThreads();
4980 delete arg1;
4981
4982 wxPyEndAllowThreads(__tstate);
4983 if (PyErr_Occurred()) SWIG_fail;
4984 }
4985 Py_INCREF(Py_None); resultobj = Py_None;
4986 return resultobj;
4987 fail:
4988 return NULL;
4989 }
4990
4991
4992 static PyObject *_wrap_new_EmptyIcon(PyObject *, PyObject *args, PyObject *kwargs) {
4993 PyObject *resultobj;
4994 wxIcon *result;
4995 char *kwnames[] = {
4996 NULL
4997 };
4998
4999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EmptyIcon",kwnames)) goto fail;
5000 {
5001 if (!wxPyCheckForApp()) SWIG_fail;
5002 PyThreadState* __tstate = wxPyBeginAllowThreads();
5003 result = (wxIcon *)new wxIcon();
5004
5005 wxPyEndAllowThreads(__tstate);
5006 if (PyErr_Occurred()) SWIG_fail;
5007 }
5008 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5009 return resultobj;
5010 fail:
5011 return NULL;
5012 }
5013
5014
5015 static PyObject *_wrap_new_IconFromLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5016 PyObject *resultobj;
5017 wxIconLocation *arg1 = 0 ;
5018 wxIcon *result;
5019 PyObject * obj0 = 0 ;
5020 char *kwnames[] = {
5021 (char *) "loc", NULL
5022 };
5023
5024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromLocation",kwnames,&obj0)) goto fail;
5025 {
5026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5027 if (SWIG_arg_fail(1)) SWIG_fail;
5028 if (arg1 == NULL) {
5029 SWIG_null_ref("wxIconLocation");
5030 }
5031 if (SWIG_arg_fail(1)) SWIG_fail;
5032 }
5033 {
5034 if (!wxPyCheckForApp()) SWIG_fail;
5035 PyThreadState* __tstate = wxPyBeginAllowThreads();
5036 result = (wxIcon *)new wxIcon((wxIconLocation const &)*arg1);
5037
5038 wxPyEndAllowThreads(__tstate);
5039 if (PyErr_Occurred()) SWIG_fail;
5040 }
5041 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5042 return resultobj;
5043 fail:
5044 return NULL;
5045 }
5046
5047
5048 static PyObject *_wrap_new_IconFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5049 PyObject *resultobj;
5050 wxBitmap *arg1 = 0 ;
5051 wxIcon *result;
5052 PyObject * obj0 = 0 ;
5053 char *kwnames[] = {
5054 (char *) "bmp", NULL
5055 };
5056
5057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromBitmap",kwnames,&obj0)) goto fail;
5058 {
5059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5060 if (SWIG_arg_fail(1)) SWIG_fail;
5061 if (arg1 == NULL) {
5062 SWIG_null_ref("wxBitmap");
5063 }
5064 if (SWIG_arg_fail(1)) SWIG_fail;
5065 }
5066 {
5067 if (!wxPyCheckForApp()) SWIG_fail;
5068 PyThreadState* __tstate = wxPyBeginAllowThreads();
5069 result = (wxIcon *)new_wxIcon((wxBitmap const &)*arg1);
5070
5071 wxPyEndAllowThreads(__tstate);
5072 if (PyErr_Occurred()) SWIG_fail;
5073 }
5074 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5075 return resultobj;
5076 fail:
5077 return NULL;
5078 }
5079
5080
5081 static PyObject *_wrap_new_IconFromXPMData(PyObject *, PyObject *args, PyObject *kwargs) {
5082 PyObject *resultobj;
5083 PyObject *arg1 = (PyObject *) 0 ;
5084 wxIcon *result;
5085 PyObject * obj0 = 0 ;
5086 char *kwnames[] = {
5087 (char *) "listOfStrings", NULL
5088 };
5089
5090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconFromXPMData",kwnames,&obj0)) goto fail;
5091 arg1 = obj0;
5092 {
5093 if (!wxPyCheckForApp()) SWIG_fail;
5094 PyThreadState* __tstate = wxPyBeginAllowThreads();
5095 result = (wxIcon *)new_wxIcon(arg1);
5096
5097 wxPyEndAllowThreads(__tstate);
5098 if (PyErr_Occurred()) SWIG_fail;
5099 }
5100 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
5101 return resultobj;
5102 fail:
5103 return NULL;
5104 }
5105
5106
5107 static PyObject *_wrap_Icon_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
5108 PyObject *resultobj;
5109 wxIcon *arg1 = (wxIcon *) 0 ;
5110 wxString *arg2 = 0 ;
5111 wxBitmapType arg3 ;
5112 bool result;
5113 bool temp2 = false ;
5114 PyObject * obj0 = 0 ;
5115 PyObject * obj1 = 0 ;
5116 PyObject * obj2 = 0 ;
5117 char *kwnames[] = {
5118 (char *) "self",(char *) "name",(char *) "type", NULL
5119 };
5120
5121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Icon_LoadFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
5122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5123 if (SWIG_arg_fail(1)) SWIG_fail;
5124 {
5125 arg2 = wxString_in_helper(obj1);
5126 if (arg2 == NULL) SWIG_fail;
5127 temp2 = true;
5128 }
5129 {
5130 arg3 = (wxBitmapType)(SWIG_As_int(obj2));
5131 if (SWIG_arg_fail(3)) SWIG_fail;
5132 }
5133 {
5134 PyThreadState* __tstate = wxPyBeginAllowThreads();
5135 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxBitmapType )arg3);
5136
5137 wxPyEndAllowThreads(__tstate);
5138 if (PyErr_Occurred()) SWIG_fail;
5139 }
5140 {
5141 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5142 }
5143 {
5144 if (temp2)
5145 delete arg2;
5146 }
5147 return resultobj;
5148 fail:
5149 {
5150 if (temp2)
5151 delete arg2;
5152 }
5153 return NULL;
5154 }
5155
5156
5157 static PyObject *_wrap_Icon_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
5158 PyObject *resultobj;
5159 wxIcon *arg1 = (wxIcon *) 0 ;
5160 bool result;
5161 PyObject * obj0 = 0 ;
5162 char *kwnames[] = {
5163 (char *) "self", NULL
5164 };
5165
5166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_Ok",kwnames,&obj0)) goto fail;
5167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5168 if (SWIG_arg_fail(1)) SWIG_fail;
5169 {
5170 PyThreadState* __tstate = wxPyBeginAllowThreads();
5171 result = (bool)(arg1)->Ok();
5172
5173 wxPyEndAllowThreads(__tstate);
5174 if (PyErr_Occurred()) SWIG_fail;
5175 }
5176 {
5177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5178 }
5179 return resultobj;
5180 fail:
5181 return NULL;
5182 }
5183
5184
5185 static PyObject *_wrap_Icon_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5186 PyObject *resultobj;
5187 wxIcon *arg1 = (wxIcon *) 0 ;
5188 int result;
5189 PyObject * obj0 = 0 ;
5190 char *kwnames[] = {
5191 (char *) "self", NULL
5192 };
5193
5194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetWidth",kwnames,&obj0)) goto fail;
5195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5196 if (SWIG_arg_fail(1)) SWIG_fail;
5197 {
5198 PyThreadState* __tstate = wxPyBeginAllowThreads();
5199 result = (int)(arg1)->GetWidth();
5200
5201 wxPyEndAllowThreads(__tstate);
5202 if (PyErr_Occurred()) SWIG_fail;
5203 }
5204 {
5205 resultobj = SWIG_From_int((int)(result));
5206 }
5207 return resultobj;
5208 fail:
5209 return NULL;
5210 }
5211
5212
5213 static PyObject *_wrap_Icon_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5214 PyObject *resultobj;
5215 wxIcon *arg1 = (wxIcon *) 0 ;
5216 int result;
5217 PyObject * obj0 = 0 ;
5218 char *kwnames[] = {
5219 (char *) "self", NULL
5220 };
5221
5222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetHeight",kwnames,&obj0)) goto fail;
5223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5224 if (SWIG_arg_fail(1)) SWIG_fail;
5225 {
5226 PyThreadState* __tstate = wxPyBeginAllowThreads();
5227 result = (int)(arg1)->GetHeight();
5228
5229 wxPyEndAllowThreads(__tstate);
5230 if (PyErr_Occurred()) SWIG_fail;
5231 }
5232 {
5233 resultobj = SWIG_From_int((int)(result));
5234 }
5235 return resultobj;
5236 fail:
5237 return NULL;
5238 }
5239
5240
5241 static PyObject *_wrap_Icon_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5242 PyObject *resultobj;
5243 wxIcon *arg1 = (wxIcon *) 0 ;
5244 int result;
5245 PyObject * obj0 = 0 ;
5246 char *kwnames[] = {
5247 (char *) "self", NULL
5248 };
5249
5250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Icon_GetDepth",kwnames,&obj0)) goto fail;
5251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5252 if (SWIG_arg_fail(1)) SWIG_fail;
5253 {
5254 PyThreadState* __tstate = wxPyBeginAllowThreads();
5255 result = (int)(arg1)->GetDepth();
5256
5257 wxPyEndAllowThreads(__tstate);
5258 if (PyErr_Occurred()) SWIG_fail;
5259 }
5260 {
5261 resultobj = SWIG_From_int((int)(result));
5262 }
5263 return resultobj;
5264 fail:
5265 return NULL;
5266 }
5267
5268
5269 static PyObject *_wrap_Icon_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5270 PyObject *resultobj;
5271 wxIcon *arg1 = (wxIcon *) 0 ;
5272 int arg2 ;
5273 PyObject * obj0 = 0 ;
5274 PyObject * obj1 = 0 ;
5275 char *kwnames[] = {
5276 (char *) "self",(char *) "w", NULL
5277 };
5278
5279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5281 if (SWIG_arg_fail(1)) SWIG_fail;
5282 {
5283 arg2 = (int)(SWIG_As_int(obj1));
5284 if (SWIG_arg_fail(2)) SWIG_fail;
5285 }
5286 {
5287 PyThreadState* __tstate = wxPyBeginAllowThreads();
5288 (arg1)->SetWidth(arg2);
5289
5290 wxPyEndAllowThreads(__tstate);
5291 if (PyErr_Occurred()) SWIG_fail;
5292 }
5293 Py_INCREF(Py_None); resultobj = Py_None;
5294 return resultobj;
5295 fail:
5296 return NULL;
5297 }
5298
5299
5300 static PyObject *_wrap_Icon_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5301 PyObject *resultobj;
5302 wxIcon *arg1 = (wxIcon *) 0 ;
5303 int arg2 ;
5304 PyObject * obj0 = 0 ;
5305 PyObject * obj1 = 0 ;
5306 char *kwnames[] = {
5307 (char *) "self",(char *) "h", NULL
5308 };
5309
5310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5312 if (SWIG_arg_fail(1)) SWIG_fail;
5313 {
5314 arg2 = (int)(SWIG_As_int(obj1));
5315 if (SWIG_arg_fail(2)) SWIG_fail;
5316 }
5317 {
5318 PyThreadState* __tstate = wxPyBeginAllowThreads();
5319 (arg1)->SetHeight(arg2);
5320
5321 wxPyEndAllowThreads(__tstate);
5322 if (PyErr_Occurred()) SWIG_fail;
5323 }
5324 Py_INCREF(Py_None); resultobj = Py_None;
5325 return resultobj;
5326 fail:
5327 return NULL;
5328 }
5329
5330
5331 static PyObject *_wrap_Icon_SetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5332 PyObject *resultobj;
5333 wxIcon *arg1 = (wxIcon *) 0 ;
5334 int arg2 ;
5335 PyObject * obj0 = 0 ;
5336 PyObject * obj1 = 0 ;
5337 char *kwnames[] = {
5338 (char *) "self",(char *) "d", NULL
5339 };
5340
5341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_SetDepth",kwnames,&obj0,&obj1)) goto fail;
5342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5343 if (SWIG_arg_fail(1)) SWIG_fail;
5344 {
5345 arg2 = (int)(SWIG_As_int(obj1));
5346 if (SWIG_arg_fail(2)) SWIG_fail;
5347 }
5348 {
5349 PyThreadState* __tstate = wxPyBeginAllowThreads();
5350 (arg1)->SetDepth(arg2);
5351
5352 wxPyEndAllowThreads(__tstate);
5353 if (PyErr_Occurred()) SWIG_fail;
5354 }
5355 Py_INCREF(Py_None); resultobj = Py_None;
5356 return resultobj;
5357 fail:
5358 return NULL;
5359 }
5360
5361
5362 static PyObject *_wrap_Icon_CopyFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
5363 PyObject *resultobj;
5364 wxIcon *arg1 = (wxIcon *) 0 ;
5365 wxBitmap *arg2 = 0 ;
5366 PyObject * obj0 = 0 ;
5367 PyObject * obj1 = 0 ;
5368 char *kwnames[] = {
5369 (char *) "self",(char *) "bmp", NULL
5370 };
5371
5372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Icon_CopyFromBitmap",kwnames,&obj0,&obj1)) goto fail;
5373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5374 if (SWIG_arg_fail(1)) SWIG_fail;
5375 {
5376 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
5377 if (SWIG_arg_fail(2)) SWIG_fail;
5378 if (arg2 == NULL) {
5379 SWIG_null_ref("wxBitmap");
5380 }
5381 if (SWIG_arg_fail(2)) SWIG_fail;
5382 }
5383 {
5384 PyThreadState* __tstate = wxPyBeginAllowThreads();
5385 (arg1)->CopyFromBitmap((wxBitmap const &)*arg2);
5386
5387 wxPyEndAllowThreads(__tstate);
5388 if (PyErr_Occurred()) SWIG_fail;
5389 }
5390 Py_INCREF(Py_None); resultobj = Py_None;
5391 return resultobj;
5392 fail:
5393 return NULL;
5394 }
5395
5396
5397 static PyObject * Icon_swigregister(PyObject *, PyObject *args) {
5398 PyObject *obj;
5399 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5400 SWIG_TypeClientData(SWIGTYPE_p_wxIcon, obj);
5401 Py_INCREF(obj);
5402 return Py_BuildValue((char *)"");
5403 }
5404 static PyObject *_wrap_new_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5405 PyObject *resultobj;
5406 wxString *arg1 = (wxString *) &wxPyEmptyString ;
5407 int arg2 = (int) 0 ;
5408 wxIconLocation *result;
5409 bool temp1 = false ;
5410 PyObject * obj0 = 0 ;
5411 PyObject * obj1 = 0 ;
5412 char *kwnames[] = {
5413 (char *) "filename",(char *) "num", NULL
5414 };
5415
5416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconLocation",kwnames,&obj0,&obj1)) goto fail;
5417 if (obj0) {
5418 {
5419 arg1 = wxString_in_helper(obj0);
5420 if (arg1 == NULL) SWIG_fail;
5421 temp1 = true;
5422 }
5423 }
5424 if (obj1) {
5425 {
5426 arg2 = (int)(SWIG_As_int(obj1));
5427 if (SWIG_arg_fail(2)) SWIG_fail;
5428 }
5429 }
5430 {
5431 PyThreadState* __tstate = wxPyBeginAllowThreads();
5432 result = (wxIconLocation *)new_wxIconLocation((wxString const *)arg1,arg2);
5433
5434 wxPyEndAllowThreads(__tstate);
5435 if (PyErr_Occurred()) SWIG_fail;
5436 }
5437 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconLocation, 1);
5438 {
5439 if (temp1)
5440 delete arg1;
5441 }
5442 return resultobj;
5443 fail:
5444 {
5445 if (temp1)
5446 delete arg1;
5447 }
5448 return NULL;
5449 }
5450
5451
5452 static PyObject *_wrap_delete_IconLocation(PyObject *, PyObject *args, PyObject *kwargs) {
5453 PyObject *resultobj;
5454 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5455 PyObject * obj0 = 0 ;
5456 char *kwnames[] = {
5457 (char *) "self", NULL
5458 };
5459
5460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconLocation",kwnames,&obj0)) goto fail;
5461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5462 if (SWIG_arg_fail(1)) SWIG_fail;
5463 {
5464 PyThreadState* __tstate = wxPyBeginAllowThreads();
5465 delete arg1;
5466
5467 wxPyEndAllowThreads(__tstate);
5468 if (PyErr_Occurred()) SWIG_fail;
5469 }
5470 Py_INCREF(Py_None); resultobj = Py_None;
5471 return resultobj;
5472 fail:
5473 return NULL;
5474 }
5475
5476
5477 static PyObject *_wrap_IconLocation_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
5478 PyObject *resultobj;
5479 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5480 bool result;
5481 PyObject * obj0 = 0 ;
5482 char *kwnames[] = {
5483 (char *) "self", NULL
5484 };
5485
5486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_IsOk",kwnames,&obj0)) goto fail;
5487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5488 if (SWIG_arg_fail(1)) SWIG_fail;
5489 {
5490 PyThreadState* __tstate = wxPyBeginAllowThreads();
5491 result = (bool)((wxIconLocation const *)arg1)->IsOk();
5492
5493 wxPyEndAllowThreads(__tstate);
5494 if (PyErr_Occurred()) SWIG_fail;
5495 }
5496 {
5497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5498 }
5499 return resultobj;
5500 fail:
5501 return NULL;
5502 }
5503
5504
5505 static PyObject *_wrap_IconLocation_SetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5506 PyObject *resultobj;
5507 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5508 wxString *arg2 = 0 ;
5509 bool temp2 = false ;
5510 PyObject * obj0 = 0 ;
5511 PyObject * obj1 = 0 ;
5512 char *kwnames[] = {
5513 (char *) "self",(char *) "filename", NULL
5514 };
5515
5516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetFileName",kwnames,&obj0,&obj1)) goto fail;
5517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5518 if (SWIG_arg_fail(1)) SWIG_fail;
5519 {
5520 arg2 = wxString_in_helper(obj1);
5521 if (arg2 == NULL) SWIG_fail;
5522 temp2 = true;
5523 }
5524 {
5525 PyThreadState* __tstate = wxPyBeginAllowThreads();
5526 (arg1)->SetFileName((wxString const &)*arg2);
5527
5528 wxPyEndAllowThreads(__tstate);
5529 if (PyErr_Occurred()) SWIG_fail;
5530 }
5531 Py_INCREF(Py_None); resultobj = Py_None;
5532 {
5533 if (temp2)
5534 delete arg2;
5535 }
5536 return resultobj;
5537 fail:
5538 {
5539 if (temp2)
5540 delete arg2;
5541 }
5542 return NULL;
5543 }
5544
5545
5546 static PyObject *_wrap_IconLocation_GetFileName(PyObject *, PyObject *args, PyObject *kwargs) {
5547 PyObject *resultobj;
5548 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5549 wxString *result;
5550 PyObject * obj0 = 0 ;
5551 char *kwnames[] = {
5552 (char *) "self", NULL
5553 };
5554
5555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetFileName",kwnames,&obj0)) goto fail;
5556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5557 if (SWIG_arg_fail(1)) SWIG_fail;
5558 {
5559 PyThreadState* __tstate = wxPyBeginAllowThreads();
5560 {
5561 wxString const &_result_ref = ((wxIconLocation const *)arg1)->GetFileName();
5562 result = (wxString *) &_result_ref;
5563 }
5564
5565 wxPyEndAllowThreads(__tstate);
5566 if (PyErr_Occurred()) SWIG_fail;
5567 }
5568 {
5569 #if wxUSE_UNICODE
5570 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
5571 #else
5572 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
5573 #endif
5574 }
5575 return resultobj;
5576 fail:
5577 return NULL;
5578 }
5579
5580
5581 static PyObject *_wrap_IconLocation_SetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5582 PyObject *resultobj;
5583 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5584 int arg2 ;
5585 PyObject * obj0 = 0 ;
5586 PyObject * obj1 = 0 ;
5587 char *kwnames[] = {
5588 (char *) "self",(char *) "num", NULL
5589 };
5590
5591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconLocation_SetIndex",kwnames,&obj0,&obj1)) goto fail;
5592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5593 if (SWIG_arg_fail(1)) SWIG_fail;
5594 {
5595 arg2 = (int)(SWIG_As_int(obj1));
5596 if (SWIG_arg_fail(2)) SWIG_fail;
5597 }
5598 {
5599 PyThreadState* __tstate = wxPyBeginAllowThreads();
5600 wxIconLocation_SetIndex(arg1,arg2);
5601
5602 wxPyEndAllowThreads(__tstate);
5603 if (PyErr_Occurred()) SWIG_fail;
5604 }
5605 Py_INCREF(Py_None); resultobj = Py_None;
5606 return resultobj;
5607 fail:
5608 return NULL;
5609 }
5610
5611
5612 static PyObject *_wrap_IconLocation_GetIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5613 PyObject *resultobj;
5614 wxIconLocation *arg1 = (wxIconLocation *) 0 ;
5615 int result;
5616 PyObject * obj0 = 0 ;
5617 char *kwnames[] = {
5618 (char *) "self", NULL
5619 };
5620
5621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconLocation_GetIndex",kwnames,&obj0)) goto fail;
5622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconLocation, SWIG_POINTER_EXCEPTION | 0);
5623 if (SWIG_arg_fail(1)) SWIG_fail;
5624 {
5625 PyThreadState* __tstate = wxPyBeginAllowThreads();
5626 result = (int)wxIconLocation_GetIndex(arg1);
5627
5628 wxPyEndAllowThreads(__tstate);
5629 if (PyErr_Occurred()) SWIG_fail;
5630 }
5631 {
5632 resultobj = SWIG_From_int((int)(result));
5633 }
5634 return resultobj;
5635 fail:
5636 return NULL;
5637 }
5638
5639
5640 static PyObject * IconLocation_swigregister(PyObject *, PyObject *args) {
5641 PyObject *obj;
5642 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5643 SWIG_TypeClientData(SWIGTYPE_p_wxIconLocation, obj);
5644 Py_INCREF(obj);
5645 return Py_BuildValue((char *)"");
5646 }
5647 static PyObject *_wrap_new_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
5648 PyObject *resultobj;
5649 wxIconBundle *result;
5650 char *kwnames[] = {
5651 NULL
5652 };
5653
5654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IconBundle",kwnames)) goto fail;
5655 {
5656 PyThreadState* __tstate = wxPyBeginAllowThreads();
5657 result = (wxIconBundle *)new wxIconBundle();
5658
5659 wxPyEndAllowThreads(__tstate);
5660 if (PyErr_Occurred()) SWIG_fail;
5661 }
5662 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5663 return resultobj;
5664 fail:
5665 return NULL;
5666 }
5667
5668
5669 static PyObject *_wrap_new_IconBundleFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
5670 PyObject *resultobj;
5671 wxString *arg1 = 0 ;
5672 long arg2 ;
5673 wxIconBundle *result;
5674 bool temp1 = false ;
5675 PyObject * obj0 = 0 ;
5676 PyObject * obj1 = 0 ;
5677 char *kwnames[] = {
5678 (char *) "file",(char *) "type", NULL
5679 };
5680
5681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_IconBundleFromFile",kwnames,&obj0,&obj1)) goto fail;
5682 {
5683 arg1 = wxString_in_helper(obj0);
5684 if (arg1 == NULL) SWIG_fail;
5685 temp1 = true;
5686 }
5687 {
5688 arg2 = (long)(SWIG_As_long(obj1));
5689 if (SWIG_arg_fail(2)) SWIG_fail;
5690 }
5691 {
5692 PyThreadState* __tstate = wxPyBeginAllowThreads();
5693 result = (wxIconBundle *)new wxIconBundle((wxString const &)*arg1,arg2);
5694
5695 wxPyEndAllowThreads(__tstate);
5696 if (PyErr_Occurred()) SWIG_fail;
5697 }
5698 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5699 {
5700 if (temp1)
5701 delete arg1;
5702 }
5703 return resultobj;
5704 fail:
5705 {
5706 if (temp1)
5707 delete arg1;
5708 }
5709 return NULL;
5710 }
5711
5712
5713 static PyObject *_wrap_new_IconBundleFromIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5714 PyObject *resultobj;
5715 wxIcon *arg1 = 0 ;
5716 wxIconBundle *result;
5717 PyObject * obj0 = 0 ;
5718 char *kwnames[] = {
5719 (char *) "icon", NULL
5720 };
5721
5722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_IconBundleFromIcon",kwnames,&obj0)) goto fail;
5723 {
5724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5725 if (SWIG_arg_fail(1)) SWIG_fail;
5726 if (arg1 == NULL) {
5727 SWIG_null_ref("wxIcon");
5728 }
5729 if (SWIG_arg_fail(1)) SWIG_fail;
5730 }
5731 {
5732 PyThreadState* __tstate = wxPyBeginAllowThreads();
5733 result = (wxIconBundle *)new wxIconBundle((wxIcon const &)*arg1);
5734
5735 wxPyEndAllowThreads(__tstate);
5736 if (PyErr_Occurred()) SWIG_fail;
5737 }
5738 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconBundle, 1);
5739 return resultobj;
5740 fail:
5741 return NULL;
5742 }
5743
5744
5745 static PyObject *_wrap_delete_IconBundle(PyObject *, PyObject *args, PyObject *kwargs) {
5746 PyObject *resultobj;
5747 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5748 PyObject * obj0 = 0 ;
5749 char *kwnames[] = {
5750 (char *) "self", NULL
5751 };
5752
5753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_IconBundle",kwnames,&obj0)) goto fail;
5754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5755 if (SWIG_arg_fail(1)) SWIG_fail;
5756 {
5757 PyThreadState* __tstate = wxPyBeginAllowThreads();
5758 delete arg1;
5759
5760 wxPyEndAllowThreads(__tstate);
5761 if (PyErr_Occurred()) SWIG_fail;
5762 }
5763 Py_INCREF(Py_None); resultobj = Py_None;
5764 return resultobj;
5765 fail:
5766 return NULL;
5767 }
5768
5769
5770 static PyObject *_wrap_IconBundle_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5771 PyObject *resultobj;
5772 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5773 wxIcon *arg2 = 0 ;
5774 PyObject * obj0 = 0 ;
5775 PyObject * obj1 = 0 ;
5776 char *kwnames[] = {
5777 (char *) "self",(char *) "icon", NULL
5778 };
5779
5780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_AddIcon",kwnames,&obj0,&obj1)) goto fail;
5781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5782 if (SWIG_arg_fail(1)) SWIG_fail;
5783 {
5784 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
5785 if (SWIG_arg_fail(2)) SWIG_fail;
5786 if (arg2 == NULL) {
5787 SWIG_null_ref("wxIcon");
5788 }
5789 if (SWIG_arg_fail(2)) SWIG_fail;
5790 }
5791 {
5792 PyThreadState* __tstate = wxPyBeginAllowThreads();
5793 (arg1)->AddIcon((wxIcon const &)*arg2);
5794
5795 wxPyEndAllowThreads(__tstate);
5796 if (PyErr_Occurred()) SWIG_fail;
5797 }
5798 Py_INCREF(Py_None); resultobj = Py_None;
5799 return resultobj;
5800 fail:
5801 return NULL;
5802 }
5803
5804
5805 static PyObject *_wrap_IconBundle_AddIconFromFile(PyObject *, PyObject *args, PyObject *kwargs) {
5806 PyObject *resultobj;
5807 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5808 wxString *arg2 = 0 ;
5809 long arg3 ;
5810 bool temp2 = false ;
5811 PyObject * obj0 = 0 ;
5812 PyObject * obj1 = 0 ;
5813 PyObject * obj2 = 0 ;
5814 char *kwnames[] = {
5815 (char *) "self",(char *) "file",(char *) "type", NULL
5816 };
5817
5818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IconBundle_AddIconFromFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
5819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5820 if (SWIG_arg_fail(1)) SWIG_fail;
5821 {
5822 arg2 = wxString_in_helper(obj1);
5823 if (arg2 == NULL) SWIG_fail;
5824 temp2 = true;
5825 }
5826 {
5827 arg3 = (long)(SWIG_As_long(obj2));
5828 if (SWIG_arg_fail(3)) SWIG_fail;
5829 }
5830 {
5831 PyThreadState* __tstate = wxPyBeginAllowThreads();
5832 (arg1)->AddIcon((wxString const &)*arg2,arg3);
5833
5834 wxPyEndAllowThreads(__tstate);
5835 if (PyErr_Occurred()) SWIG_fail;
5836 }
5837 Py_INCREF(Py_None); resultobj = Py_None;
5838 {
5839 if (temp2)
5840 delete arg2;
5841 }
5842 return resultobj;
5843 fail:
5844 {
5845 if (temp2)
5846 delete arg2;
5847 }
5848 return NULL;
5849 }
5850
5851
5852 static PyObject *_wrap_IconBundle_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
5853 PyObject *resultobj;
5854 wxIconBundle *arg1 = (wxIconBundle *) 0 ;
5855 wxSize *arg2 = 0 ;
5856 wxIcon *result;
5857 wxSize temp2 ;
5858 PyObject * obj0 = 0 ;
5859 PyObject * obj1 = 0 ;
5860 char *kwnames[] = {
5861 (char *) "self",(char *) "size", NULL
5862 };
5863
5864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IconBundle_GetIcon",kwnames,&obj0,&obj1)) goto fail;
5865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconBundle, SWIG_POINTER_EXCEPTION | 0);
5866 if (SWIG_arg_fail(1)) SWIG_fail;
5867 {
5868 arg2 = &temp2;
5869 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5870 }
5871 {
5872 PyThreadState* __tstate = wxPyBeginAllowThreads();
5873 {
5874 wxIcon const &_result_ref = ((wxIconBundle const *)arg1)->GetIcon((wxSize const &)*arg2);
5875 result = (wxIcon *) &_result_ref;
5876 }
5877
5878 wxPyEndAllowThreads(__tstate);
5879 if (PyErr_Occurred()) SWIG_fail;
5880 }
5881 {
5882 wxIcon* resultptr = new wxIcon(*result);
5883 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxIcon, 1);
5884 }
5885 return resultobj;
5886 fail:
5887 return NULL;
5888 }
5889
5890
5891 static PyObject * IconBundle_swigregister(PyObject *, PyObject *args) {
5892 PyObject *obj;
5893 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5894 SWIG_TypeClientData(SWIGTYPE_p_wxIconBundle, obj);
5895 Py_INCREF(obj);
5896 return Py_BuildValue((char *)"");
5897 }
5898 static PyObject *_wrap_new_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
5899 PyObject *resultobj;
5900 wxString *arg1 = (wxString *) 0 ;
5901 long arg2 ;
5902 int arg3 = (int) 0 ;
5903 int arg4 = (int) 0 ;
5904 wxCursor *result;
5905 bool temp1 = false ;
5906 PyObject * obj0 = 0 ;
5907 PyObject * obj1 = 0 ;
5908 PyObject * obj2 = 0 ;
5909 PyObject * obj3 = 0 ;
5910 char *kwnames[] = {
5911 (char *) "cursorName",(char *) "type",(char *) "hotSpotX",(char *) "hotSpotY", NULL
5912 };
5913
5914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_Cursor",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5915 {
5916 arg1 = wxString_in_helper(obj0);
5917 if (arg1 == NULL) SWIG_fail;
5918 temp1 = true;
5919 }
5920 {
5921 arg2 = (long)(SWIG_As_long(obj1));
5922 if (SWIG_arg_fail(2)) SWIG_fail;
5923 }
5924 if (obj2) {
5925 {
5926 arg3 = (int)(SWIG_As_int(obj2));
5927 if (SWIG_arg_fail(3)) SWIG_fail;
5928 }
5929 }
5930 if (obj3) {
5931 {
5932 arg4 = (int)(SWIG_As_int(obj3));
5933 if (SWIG_arg_fail(4)) SWIG_fail;
5934 }
5935 }
5936 {
5937 if (!wxPyCheckForApp()) SWIG_fail;
5938 PyThreadState* __tstate = wxPyBeginAllowThreads();
5939 result = (wxCursor *)new_wxCursor((wxString const *)arg1,arg2,arg3,arg4);
5940
5941 wxPyEndAllowThreads(__tstate);
5942 if (PyErr_Occurred()) SWIG_fail;
5943 }
5944 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
5945 {
5946 if (temp1)
5947 delete arg1;
5948 }
5949 return resultobj;
5950 fail:
5951 {
5952 if (temp1)
5953 delete arg1;
5954 }
5955 return NULL;
5956 }
5957
5958
5959 static PyObject *_wrap_delete_Cursor(PyObject *, PyObject *args, PyObject *kwargs) {
5960 PyObject *resultobj;
5961 wxCursor *arg1 = (wxCursor *) 0 ;
5962 PyObject * obj0 = 0 ;
5963 char *kwnames[] = {
5964 (char *) "self", NULL
5965 };
5966
5967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Cursor",kwnames,&obj0)) goto fail;
5968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5969 if (SWIG_arg_fail(1)) SWIG_fail;
5970 {
5971 PyThreadState* __tstate = wxPyBeginAllowThreads();
5972 delete arg1;
5973
5974 wxPyEndAllowThreads(__tstate);
5975 if (PyErr_Occurred()) SWIG_fail;
5976 }
5977 Py_INCREF(Py_None); resultobj = Py_None;
5978 return resultobj;
5979 fail:
5980 return NULL;
5981 }
5982
5983
5984 static PyObject *_wrap_new_StockCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5985 PyObject *resultobj;
5986 int arg1 ;
5987 wxCursor *result;
5988 PyObject * obj0 = 0 ;
5989 char *kwnames[] = {
5990 (char *) "id", NULL
5991 };
5992
5993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_StockCursor",kwnames,&obj0)) goto fail;
5994 {
5995 arg1 = (int)(SWIG_As_int(obj0));
5996 if (SWIG_arg_fail(1)) SWIG_fail;
5997 }
5998 {
5999 if (!wxPyCheckForApp()) SWIG_fail;
6000 PyThreadState* __tstate = wxPyBeginAllowThreads();
6001 result = (wxCursor *)new wxCursor(arg1);
6002
6003 wxPyEndAllowThreads(__tstate);
6004 if (PyErr_Occurred()) SWIG_fail;
6005 }
6006 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6007 return resultobj;
6008 fail:
6009 return NULL;
6010 }
6011
6012
6013 static PyObject *_wrap_new_CursorFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
6014 PyObject *resultobj;
6015 wxImage *arg1 = 0 ;
6016 wxCursor *result;
6017 PyObject * obj0 = 0 ;
6018 char *kwnames[] = {
6019 (char *) "image", NULL
6020 };
6021
6022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CursorFromImage",kwnames,&obj0)) goto fail;
6023 {
6024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
6025 if (SWIG_arg_fail(1)) SWIG_fail;
6026 if (arg1 == NULL) {
6027 SWIG_null_ref("wxImage");
6028 }
6029 if (SWIG_arg_fail(1)) SWIG_fail;
6030 }
6031 {
6032 if (!wxPyCheckForApp()) SWIG_fail;
6033 PyThreadState* __tstate = wxPyBeginAllowThreads();
6034 result = (wxCursor *)new wxCursor((wxImage const &)*arg1);
6035
6036 wxPyEndAllowThreads(__tstate);
6037 if (PyErr_Occurred()) SWIG_fail;
6038 }
6039 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCursor, 1);
6040 return resultobj;
6041 fail:
6042 return NULL;
6043 }
6044
6045
6046 static PyObject *_wrap_Cursor_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
6047 PyObject *resultobj;
6048 wxCursor *arg1 = (wxCursor *) 0 ;
6049 bool result;
6050 PyObject * obj0 = 0 ;
6051 char *kwnames[] = {
6052 (char *) "self", NULL
6053 };
6054
6055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Cursor_Ok",kwnames,&obj0)) goto fail;
6056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6057 if (SWIG_arg_fail(1)) SWIG_fail;
6058 {
6059 PyThreadState* __tstate = wxPyBeginAllowThreads();
6060 result = (bool)(arg1)->Ok();
6061
6062 wxPyEndAllowThreads(__tstate);
6063 if (PyErr_Occurred()) SWIG_fail;
6064 }
6065 {
6066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6067 }
6068 return resultobj;
6069 fail:
6070 return NULL;
6071 }
6072
6073
6074 static PyObject * Cursor_swigregister(PyObject *, PyObject *args) {
6075 PyObject *obj;
6076 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6077 SWIG_TypeClientData(SWIGTYPE_p_wxCursor, obj);
6078 Py_INCREF(obj);
6079 return Py_BuildValue((char *)"");
6080 }
6081 static PyObject *_wrap_new_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6082 PyObject *resultobj;
6083 int arg1 = (int) 0 ;
6084 int arg2 = (int) 0 ;
6085 int arg3 = (int) 0 ;
6086 int arg4 = (int) 0 ;
6087 wxRegion *result;
6088 PyObject * obj0 = 0 ;
6089 PyObject * obj1 = 0 ;
6090 PyObject * obj2 = 0 ;
6091 PyObject * obj3 = 0 ;
6092 char *kwnames[] = {
6093 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6094 };
6095
6096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Region",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6097 if (obj0) {
6098 {
6099 arg1 = (int)(SWIG_As_int(obj0));
6100 if (SWIG_arg_fail(1)) SWIG_fail;
6101 }
6102 }
6103 if (obj1) {
6104 {
6105 arg2 = (int)(SWIG_As_int(obj1));
6106 if (SWIG_arg_fail(2)) SWIG_fail;
6107 }
6108 }
6109 if (obj2) {
6110 {
6111 arg3 = (int)(SWIG_As_int(obj2));
6112 if (SWIG_arg_fail(3)) SWIG_fail;
6113 }
6114 }
6115 if (obj3) {
6116 {
6117 arg4 = (int)(SWIG_As_int(obj3));
6118 if (SWIG_arg_fail(4)) SWIG_fail;
6119 }
6120 }
6121 {
6122 if (!wxPyCheckForApp()) SWIG_fail;
6123 PyThreadState* __tstate = wxPyBeginAllowThreads();
6124 result = (wxRegion *)new wxRegion(arg1,arg2,arg3,arg4);
6125
6126 wxPyEndAllowThreads(__tstate);
6127 if (PyErr_Occurred()) SWIG_fail;
6128 }
6129 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6130 return resultobj;
6131 fail:
6132 return NULL;
6133 }
6134
6135
6136 static PyObject *_wrap_new_RegionFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
6137 PyObject *resultobj;
6138 wxBitmap *arg1 = 0 ;
6139 wxRegion *result;
6140 PyObject * obj0 = 0 ;
6141 char *kwnames[] = {
6142 (char *) "bmp", NULL
6143 };
6144
6145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionFromBitmap",kwnames,&obj0)) goto fail;
6146 {
6147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6148 if (SWIG_arg_fail(1)) SWIG_fail;
6149 if (arg1 == NULL) {
6150 SWIG_null_ref("wxBitmap");
6151 }
6152 if (SWIG_arg_fail(1)) SWIG_fail;
6153 }
6154 {
6155 if (!wxPyCheckForApp()) SWIG_fail;
6156 PyThreadState* __tstate = wxPyBeginAllowThreads();
6157 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1);
6158
6159 wxPyEndAllowThreads(__tstate);
6160 if (PyErr_Occurred()) SWIG_fail;
6161 }
6162 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6163 return resultobj;
6164 fail:
6165 return NULL;
6166 }
6167
6168
6169 static PyObject *_wrap_new_RegionFromBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
6170 PyObject *resultobj;
6171 wxBitmap *arg1 = 0 ;
6172 wxColour *arg2 = 0 ;
6173 int arg3 = (int) 0 ;
6174 wxRegion *result;
6175 wxColour temp2 ;
6176 PyObject * obj0 = 0 ;
6177 PyObject * obj1 = 0 ;
6178 PyObject * obj2 = 0 ;
6179 char *kwnames[] = {
6180 (char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
6181 };
6182
6183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_RegionFromBitmapColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
6184 {
6185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
6186 if (SWIG_arg_fail(1)) SWIG_fail;
6187 if (arg1 == NULL) {
6188 SWIG_null_ref("wxBitmap");
6189 }
6190 if (SWIG_arg_fail(1)) SWIG_fail;
6191 }
6192 {
6193 arg2 = &temp2;
6194 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
6195 }
6196 if (obj2) {
6197 {
6198 arg3 = (int)(SWIG_As_int(obj2));
6199 if (SWIG_arg_fail(3)) SWIG_fail;
6200 }
6201 }
6202 {
6203 if (!wxPyCheckForApp()) SWIG_fail;
6204 PyThreadState* __tstate = wxPyBeginAllowThreads();
6205 result = (wxRegion *)new wxRegion((wxBitmap const &)*arg1,(wxColour const &)*arg2,arg3);
6206
6207 wxPyEndAllowThreads(__tstate);
6208 if (PyErr_Occurred()) SWIG_fail;
6209 }
6210 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6211 return resultobj;
6212 fail:
6213 return NULL;
6214 }
6215
6216
6217 static PyObject *_wrap_new_RegionFromPoints(PyObject *, PyObject *args, PyObject *kwargs) {
6218 PyObject *resultobj;
6219 int arg1 ;
6220 wxPoint *arg2 = (wxPoint *) 0 ;
6221 int arg3 = (int) wxWINDING_RULE ;
6222 wxRegion *result;
6223 PyObject * obj0 = 0 ;
6224 PyObject * obj1 = 0 ;
6225 char *kwnames[] = {
6226 (char *) "points",(char *) "fillStyle", NULL
6227 };
6228
6229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_RegionFromPoints",kwnames,&obj0,&obj1)) goto fail;
6230 {
6231 arg2 = wxPoint_LIST_helper(obj0, &arg1);
6232 if (arg2 == NULL) SWIG_fail;
6233 }
6234 if (obj1) {
6235 {
6236 arg3 = (int)(SWIG_As_int(obj1));
6237 if (SWIG_arg_fail(3)) SWIG_fail;
6238 }
6239 }
6240 {
6241 if (!wxPyCheckForApp()) SWIG_fail;
6242 PyThreadState* __tstate = wxPyBeginAllowThreads();
6243 result = (wxRegion *)new wxRegion(arg1,arg2,arg3);
6244
6245 wxPyEndAllowThreads(__tstate);
6246 if (PyErr_Occurred()) SWIG_fail;
6247 }
6248 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 1);
6249 {
6250 if (arg2) delete [] arg2;
6251 }
6252 return resultobj;
6253 fail:
6254 {
6255 if (arg2) delete [] arg2;
6256 }
6257 return NULL;
6258 }
6259
6260
6261 static PyObject *_wrap_delete_Region(PyObject *, PyObject *args, PyObject *kwargs) {
6262 PyObject *resultobj;
6263 wxRegion *arg1 = (wxRegion *) 0 ;
6264 PyObject * obj0 = 0 ;
6265 char *kwnames[] = {
6266 (char *) "self", NULL
6267 };
6268
6269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Region",kwnames,&obj0)) goto fail;
6270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6271 if (SWIG_arg_fail(1)) SWIG_fail;
6272 {
6273 PyThreadState* __tstate = wxPyBeginAllowThreads();
6274 delete arg1;
6275
6276 wxPyEndAllowThreads(__tstate);
6277 if (PyErr_Occurred()) SWIG_fail;
6278 }
6279 Py_INCREF(Py_None); resultobj = Py_None;
6280 return resultobj;
6281 fail:
6282 return NULL;
6283 }
6284
6285
6286 static PyObject *_wrap_Region_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
6287 PyObject *resultobj;
6288 wxRegion *arg1 = (wxRegion *) 0 ;
6289 PyObject * obj0 = 0 ;
6290 char *kwnames[] = {
6291 (char *) "self", NULL
6292 };
6293
6294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_Clear",kwnames,&obj0)) goto fail;
6295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6296 if (SWIG_arg_fail(1)) SWIG_fail;
6297 {
6298 PyThreadState* __tstate = wxPyBeginAllowThreads();
6299 (arg1)->Clear();
6300
6301 wxPyEndAllowThreads(__tstate);
6302 if (PyErr_Occurred()) SWIG_fail;
6303 }
6304 Py_INCREF(Py_None); resultobj = Py_None;
6305 return resultobj;
6306 fail:
6307 return NULL;
6308 }
6309
6310
6311 static PyObject *_wrap_Region_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
6312 PyObject *resultobj;
6313 wxRegion *arg1 = (wxRegion *) 0 ;
6314 int arg2 ;
6315 int arg3 ;
6316 bool result;
6317 PyObject * obj0 = 0 ;
6318 PyObject * obj1 = 0 ;
6319 PyObject * obj2 = 0 ;
6320 char *kwnames[] = {
6321 (char *) "self",(char *) "x",(char *) "y", NULL
6322 };
6323
6324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Offset",kwnames,&obj0,&obj1,&obj2)) goto fail;
6325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6326 if (SWIG_arg_fail(1)) SWIG_fail;
6327 {
6328 arg2 = (int)(SWIG_As_int(obj1));
6329 if (SWIG_arg_fail(2)) SWIG_fail;
6330 }
6331 {
6332 arg3 = (int)(SWIG_As_int(obj2));
6333 if (SWIG_arg_fail(3)) SWIG_fail;
6334 }
6335 {
6336 PyThreadState* __tstate = wxPyBeginAllowThreads();
6337 result = (bool)(arg1)->Offset(arg2,arg3);
6338
6339 wxPyEndAllowThreads(__tstate);
6340 if (PyErr_Occurred()) SWIG_fail;
6341 }
6342 {
6343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6344 }
6345 return resultobj;
6346 fail:
6347 return NULL;
6348 }
6349
6350
6351 static PyObject *_wrap_Region_Contains(PyObject *, PyObject *args, PyObject *kwargs) {
6352 PyObject *resultobj;
6353 wxRegion *arg1 = (wxRegion *) 0 ;
6354 int arg2 ;
6355 int arg3 ;
6356 wxRegionContain result;
6357 PyObject * obj0 = 0 ;
6358 PyObject * obj1 = 0 ;
6359 PyObject * obj2 = 0 ;
6360 char *kwnames[] = {
6361 (char *) "self",(char *) "x",(char *) "y", NULL
6362 };
6363
6364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Region_Contains",kwnames,&obj0,&obj1,&obj2)) goto fail;
6365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6366 if (SWIG_arg_fail(1)) SWIG_fail;
6367 {
6368 arg2 = (int)(SWIG_As_int(obj1));
6369 if (SWIG_arg_fail(2)) SWIG_fail;
6370 }
6371 {
6372 arg3 = (int)(SWIG_As_int(obj2));
6373 if (SWIG_arg_fail(3)) SWIG_fail;
6374 }
6375 {
6376 PyThreadState* __tstate = wxPyBeginAllowThreads();
6377 result = (wxRegionContain)(arg1)->Contains(arg2,arg3);
6378
6379 wxPyEndAllowThreads(__tstate);
6380 if (PyErr_Occurred()) SWIG_fail;
6381 }
6382 resultobj = SWIG_From_int((result));
6383 return resultobj;
6384 fail:
6385 return NULL;
6386 }
6387
6388
6389 static PyObject *_wrap_Region_ContainsPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6390 PyObject *resultobj;
6391 wxRegion *arg1 = (wxRegion *) 0 ;
6392 wxPoint *arg2 = 0 ;
6393 wxRegionContain result;
6394 wxPoint temp2 ;
6395 PyObject * obj0 = 0 ;
6396 PyObject * obj1 = 0 ;
6397 char *kwnames[] = {
6398 (char *) "self",(char *) "pt", NULL
6399 };
6400
6401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsPoint",kwnames,&obj0,&obj1)) goto fail;
6402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6403 if (SWIG_arg_fail(1)) SWIG_fail;
6404 {
6405 arg2 = &temp2;
6406 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6407 }
6408 {
6409 PyThreadState* __tstate = wxPyBeginAllowThreads();
6410 result = (wxRegionContain)(arg1)->Contains((wxPoint const &)*arg2);
6411
6412 wxPyEndAllowThreads(__tstate);
6413 if (PyErr_Occurred()) SWIG_fail;
6414 }
6415 resultobj = SWIG_From_int((result));
6416 return resultobj;
6417 fail:
6418 return NULL;
6419 }
6420
6421
6422 static PyObject *_wrap_Region_ContainsRect(PyObject *, PyObject *args, PyObject *kwargs) {
6423 PyObject *resultobj;
6424 wxRegion *arg1 = (wxRegion *) 0 ;
6425 wxRect *arg2 = 0 ;
6426 wxRegionContain result;
6427 wxRect temp2 ;
6428 PyObject * obj0 = 0 ;
6429 PyObject * obj1 = 0 ;
6430 char *kwnames[] = {
6431 (char *) "self",(char *) "rect", NULL
6432 };
6433
6434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_ContainsRect",kwnames,&obj0,&obj1)) goto fail;
6435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6436 if (SWIG_arg_fail(1)) SWIG_fail;
6437 {
6438 arg2 = &temp2;
6439 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6440 }
6441 {
6442 PyThreadState* __tstate = wxPyBeginAllowThreads();
6443 result = (wxRegionContain)(arg1)->Contains((wxRect const &)*arg2);
6444
6445 wxPyEndAllowThreads(__tstate);
6446 if (PyErr_Occurred()) SWIG_fail;
6447 }
6448 resultobj = SWIG_From_int((result));
6449 return resultobj;
6450 fail:
6451 return NULL;
6452 }
6453
6454
6455 static PyObject *_wrap_Region_ContainsRectDim(PyObject *, PyObject *args, PyObject *kwargs) {
6456 PyObject *resultobj;
6457 wxRegion *arg1 = (wxRegion *) 0 ;
6458 int arg2 ;
6459 int arg3 ;
6460 int arg4 ;
6461 int arg5 ;
6462 wxRegionContain result;
6463 PyObject * obj0 = 0 ;
6464 PyObject * obj1 = 0 ;
6465 PyObject * obj2 = 0 ;
6466 PyObject * obj3 = 0 ;
6467 PyObject * obj4 = 0 ;
6468 char *kwnames[] = {
6469 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
6470 };
6471
6472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_ContainsRectDim",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6474 if (SWIG_arg_fail(1)) SWIG_fail;
6475 {
6476 arg2 = (int)(SWIG_As_int(obj1));
6477 if (SWIG_arg_fail(2)) SWIG_fail;
6478 }
6479 {
6480 arg3 = (int)(SWIG_As_int(obj2));
6481 if (SWIG_arg_fail(3)) SWIG_fail;
6482 }
6483 {
6484 arg4 = (int)(SWIG_As_int(obj3));
6485 if (SWIG_arg_fail(4)) SWIG_fail;
6486 }
6487 {
6488 arg5 = (int)(SWIG_As_int(obj4));
6489 if (SWIG_arg_fail(5)) SWIG_fail;
6490 }
6491 {
6492 PyThreadState* __tstate = wxPyBeginAllowThreads();
6493 result = (wxRegionContain)(arg1)->Contains(arg2,arg3,arg4,arg5);
6494
6495 wxPyEndAllowThreads(__tstate);
6496 if (PyErr_Occurred()) SWIG_fail;
6497 }
6498 resultobj = SWIG_From_int((result));
6499 return resultobj;
6500 fail:
6501 return NULL;
6502 }
6503
6504
6505 static PyObject *_wrap_Region_GetBox(PyObject *, PyObject *args, PyObject *kwargs) {
6506 PyObject *resultobj;
6507 wxRegion *arg1 = (wxRegion *) 0 ;
6508 wxRect result;
6509 PyObject * obj0 = 0 ;
6510 char *kwnames[] = {
6511 (char *) "self", NULL
6512 };
6513
6514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_GetBox",kwnames,&obj0)) goto fail;
6515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6516 if (SWIG_arg_fail(1)) SWIG_fail;
6517 {
6518 PyThreadState* __tstate = wxPyBeginAllowThreads();
6519 result = (arg1)->GetBox();
6520
6521 wxPyEndAllowThreads(__tstate);
6522 if (PyErr_Occurred()) SWIG_fail;
6523 }
6524 {
6525 wxRect * resultptr;
6526 resultptr = new wxRect((wxRect &)(result));
6527 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6528 }
6529 return resultobj;
6530 fail:
6531 return NULL;
6532 }
6533
6534
6535 static PyObject *_wrap_Region_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
6536 PyObject *resultobj;
6537 wxRegion *arg1 = (wxRegion *) 0 ;
6538 int arg2 ;
6539 int arg3 ;
6540 int arg4 ;
6541 int arg5 ;
6542 bool result;
6543 PyObject * obj0 = 0 ;
6544 PyObject * obj1 = 0 ;
6545 PyObject * obj2 = 0 ;
6546 PyObject * obj3 = 0 ;
6547 PyObject * obj4 = 0 ;
6548 char *kwnames[] = {
6549 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6550 };
6551
6552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Intersect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6554 if (SWIG_arg_fail(1)) SWIG_fail;
6555 {
6556 arg2 = (int)(SWIG_As_int(obj1));
6557 if (SWIG_arg_fail(2)) SWIG_fail;
6558 }
6559 {
6560 arg3 = (int)(SWIG_As_int(obj2));
6561 if (SWIG_arg_fail(3)) SWIG_fail;
6562 }
6563 {
6564 arg4 = (int)(SWIG_As_int(obj3));
6565 if (SWIG_arg_fail(4)) SWIG_fail;
6566 }
6567 {
6568 arg5 = (int)(SWIG_As_int(obj4));
6569 if (SWIG_arg_fail(5)) SWIG_fail;
6570 }
6571 {
6572 PyThreadState* __tstate = wxPyBeginAllowThreads();
6573 result = (bool)(arg1)->Intersect(arg2,arg3,arg4,arg5);
6574
6575 wxPyEndAllowThreads(__tstate);
6576 if (PyErr_Occurred()) SWIG_fail;
6577 }
6578 {
6579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6580 }
6581 return resultobj;
6582 fail:
6583 return NULL;
6584 }
6585
6586
6587 static PyObject *_wrap_Region_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6588 PyObject *resultobj;
6589 wxRegion *arg1 = (wxRegion *) 0 ;
6590 wxRect *arg2 = 0 ;
6591 bool result;
6592 wxRect temp2 ;
6593 PyObject * obj0 = 0 ;
6594 PyObject * obj1 = 0 ;
6595 char *kwnames[] = {
6596 (char *) "self",(char *) "rect", NULL
6597 };
6598
6599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6601 if (SWIG_arg_fail(1)) SWIG_fail;
6602 {
6603 arg2 = &temp2;
6604 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6605 }
6606 {
6607 PyThreadState* __tstate = wxPyBeginAllowThreads();
6608 result = (bool)(arg1)->Intersect((wxRect const &)*arg2);
6609
6610 wxPyEndAllowThreads(__tstate);
6611 if (PyErr_Occurred()) SWIG_fail;
6612 }
6613 {
6614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6615 }
6616 return resultobj;
6617 fail:
6618 return NULL;
6619 }
6620
6621
6622 static PyObject *_wrap_Region_IntersectRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6623 PyObject *resultobj;
6624 wxRegion *arg1 = (wxRegion *) 0 ;
6625 wxRegion *arg2 = 0 ;
6626 bool result;
6627 PyObject * obj0 = 0 ;
6628 PyObject * obj1 = 0 ;
6629 char *kwnames[] = {
6630 (char *) "self",(char *) "region", NULL
6631 };
6632
6633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_IntersectRegion",kwnames,&obj0,&obj1)) goto fail;
6634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6635 if (SWIG_arg_fail(1)) SWIG_fail;
6636 {
6637 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6638 if (SWIG_arg_fail(2)) SWIG_fail;
6639 if (arg2 == NULL) {
6640 SWIG_null_ref("wxRegion");
6641 }
6642 if (SWIG_arg_fail(2)) SWIG_fail;
6643 }
6644 {
6645 PyThreadState* __tstate = wxPyBeginAllowThreads();
6646 result = (bool)(arg1)->Intersect((wxRegion const &)*arg2);
6647
6648 wxPyEndAllowThreads(__tstate);
6649 if (PyErr_Occurred()) SWIG_fail;
6650 }
6651 {
6652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6653 }
6654 return resultobj;
6655 fail:
6656 return NULL;
6657 }
6658
6659
6660 static PyObject *_wrap_Region_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
6661 PyObject *resultobj;
6662 wxRegion *arg1 = (wxRegion *) 0 ;
6663 bool result;
6664 PyObject * obj0 = 0 ;
6665 char *kwnames[] = {
6666 (char *) "self", NULL
6667 };
6668
6669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_IsEmpty",kwnames,&obj0)) goto fail;
6670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6671 if (SWIG_arg_fail(1)) SWIG_fail;
6672 {
6673 PyThreadState* __tstate = wxPyBeginAllowThreads();
6674 result = (bool)(arg1)->IsEmpty();
6675
6676 wxPyEndAllowThreads(__tstate);
6677 if (PyErr_Occurred()) SWIG_fail;
6678 }
6679 {
6680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6681 }
6682 return resultobj;
6683 fail:
6684 return NULL;
6685 }
6686
6687
6688 static PyObject *_wrap_Region_Union(PyObject *, PyObject *args, PyObject *kwargs) {
6689 PyObject *resultobj;
6690 wxRegion *arg1 = (wxRegion *) 0 ;
6691 int arg2 ;
6692 int arg3 ;
6693 int arg4 ;
6694 int arg5 ;
6695 bool result;
6696 PyObject * obj0 = 0 ;
6697 PyObject * obj1 = 0 ;
6698 PyObject * obj2 = 0 ;
6699 PyObject * obj3 = 0 ;
6700 PyObject * obj4 = 0 ;
6701 char *kwnames[] = {
6702 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6703 };
6704
6705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Union",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6707 if (SWIG_arg_fail(1)) SWIG_fail;
6708 {
6709 arg2 = (int)(SWIG_As_int(obj1));
6710 if (SWIG_arg_fail(2)) SWIG_fail;
6711 }
6712 {
6713 arg3 = (int)(SWIG_As_int(obj2));
6714 if (SWIG_arg_fail(3)) SWIG_fail;
6715 }
6716 {
6717 arg4 = (int)(SWIG_As_int(obj3));
6718 if (SWIG_arg_fail(4)) SWIG_fail;
6719 }
6720 {
6721 arg5 = (int)(SWIG_As_int(obj4));
6722 if (SWIG_arg_fail(5)) SWIG_fail;
6723 }
6724 {
6725 PyThreadState* __tstate = wxPyBeginAllowThreads();
6726 result = (bool)(arg1)->Union(arg2,arg3,arg4,arg5);
6727
6728 wxPyEndAllowThreads(__tstate);
6729 if (PyErr_Occurred()) SWIG_fail;
6730 }
6731 {
6732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6733 }
6734 return resultobj;
6735 fail:
6736 return NULL;
6737 }
6738
6739
6740 static PyObject *_wrap_Region_UnionRect(PyObject *, PyObject *args, PyObject *kwargs) {
6741 PyObject *resultobj;
6742 wxRegion *arg1 = (wxRegion *) 0 ;
6743 wxRect *arg2 = 0 ;
6744 bool result;
6745 wxRect temp2 ;
6746 PyObject * obj0 = 0 ;
6747 PyObject * obj1 = 0 ;
6748 char *kwnames[] = {
6749 (char *) "self",(char *) "rect", NULL
6750 };
6751
6752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRect",kwnames,&obj0,&obj1)) goto fail;
6753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6754 if (SWIG_arg_fail(1)) SWIG_fail;
6755 {
6756 arg2 = &temp2;
6757 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6758 }
6759 {
6760 PyThreadState* __tstate = wxPyBeginAllowThreads();
6761 result = (bool)(arg1)->Union((wxRect const &)*arg2);
6762
6763 wxPyEndAllowThreads(__tstate);
6764 if (PyErr_Occurred()) SWIG_fail;
6765 }
6766 {
6767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6768 }
6769 return resultobj;
6770 fail:
6771 return NULL;
6772 }
6773
6774
6775 static PyObject *_wrap_Region_UnionRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6776 PyObject *resultobj;
6777 wxRegion *arg1 = (wxRegion *) 0 ;
6778 wxRegion *arg2 = 0 ;
6779 bool result;
6780 PyObject * obj0 = 0 ;
6781 PyObject * obj1 = 0 ;
6782 char *kwnames[] = {
6783 (char *) "self",(char *) "region", NULL
6784 };
6785
6786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionRegion",kwnames,&obj0,&obj1)) goto fail;
6787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6788 if (SWIG_arg_fail(1)) SWIG_fail;
6789 {
6790 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6791 if (SWIG_arg_fail(2)) SWIG_fail;
6792 if (arg2 == NULL) {
6793 SWIG_null_ref("wxRegion");
6794 }
6795 if (SWIG_arg_fail(2)) SWIG_fail;
6796 }
6797 {
6798 PyThreadState* __tstate = wxPyBeginAllowThreads();
6799 result = (bool)(arg1)->Union((wxRegion const &)*arg2);
6800
6801 wxPyEndAllowThreads(__tstate);
6802 if (PyErr_Occurred()) SWIG_fail;
6803 }
6804 {
6805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6806 }
6807 return resultobj;
6808 fail:
6809 return NULL;
6810 }
6811
6812
6813 static PyObject *_wrap_Region_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
6814 PyObject *resultobj;
6815 wxRegion *arg1 = (wxRegion *) 0 ;
6816 int arg2 ;
6817 int arg3 ;
6818 int arg4 ;
6819 int arg5 ;
6820 bool result;
6821 PyObject * obj0 = 0 ;
6822 PyObject * obj1 = 0 ;
6823 PyObject * obj2 = 0 ;
6824 PyObject * obj3 = 0 ;
6825 PyObject * obj4 = 0 ;
6826 char *kwnames[] = {
6827 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6828 };
6829
6830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Subtract",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6832 if (SWIG_arg_fail(1)) SWIG_fail;
6833 {
6834 arg2 = (int)(SWIG_As_int(obj1));
6835 if (SWIG_arg_fail(2)) SWIG_fail;
6836 }
6837 {
6838 arg3 = (int)(SWIG_As_int(obj2));
6839 if (SWIG_arg_fail(3)) SWIG_fail;
6840 }
6841 {
6842 arg4 = (int)(SWIG_As_int(obj3));
6843 if (SWIG_arg_fail(4)) SWIG_fail;
6844 }
6845 {
6846 arg5 = (int)(SWIG_As_int(obj4));
6847 if (SWIG_arg_fail(5)) SWIG_fail;
6848 }
6849 {
6850 PyThreadState* __tstate = wxPyBeginAllowThreads();
6851 result = (bool)(arg1)->Subtract(arg2,arg3,arg4,arg5);
6852
6853 wxPyEndAllowThreads(__tstate);
6854 if (PyErr_Occurred()) SWIG_fail;
6855 }
6856 {
6857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6858 }
6859 return resultobj;
6860 fail:
6861 return NULL;
6862 }
6863
6864
6865 static PyObject *_wrap_Region_SubtractRect(PyObject *, PyObject *args, PyObject *kwargs) {
6866 PyObject *resultobj;
6867 wxRegion *arg1 = (wxRegion *) 0 ;
6868 wxRect *arg2 = 0 ;
6869 bool result;
6870 wxRect temp2 ;
6871 PyObject * obj0 = 0 ;
6872 PyObject * obj1 = 0 ;
6873 char *kwnames[] = {
6874 (char *) "self",(char *) "rect", NULL
6875 };
6876
6877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRect",kwnames,&obj0,&obj1)) goto fail;
6878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6879 if (SWIG_arg_fail(1)) SWIG_fail;
6880 {
6881 arg2 = &temp2;
6882 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6883 }
6884 {
6885 PyThreadState* __tstate = wxPyBeginAllowThreads();
6886 result = (bool)(arg1)->Subtract((wxRect const &)*arg2);
6887
6888 wxPyEndAllowThreads(__tstate);
6889 if (PyErr_Occurred()) SWIG_fail;
6890 }
6891 {
6892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6893 }
6894 return resultobj;
6895 fail:
6896 return NULL;
6897 }
6898
6899
6900 static PyObject *_wrap_Region_SubtractRegion(PyObject *, PyObject *args, PyObject *kwargs) {
6901 PyObject *resultobj;
6902 wxRegion *arg1 = (wxRegion *) 0 ;
6903 wxRegion *arg2 = 0 ;
6904 bool result;
6905 PyObject * obj0 = 0 ;
6906 PyObject * obj1 = 0 ;
6907 char *kwnames[] = {
6908 (char *) "self",(char *) "region", NULL
6909 };
6910
6911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_SubtractRegion",kwnames,&obj0,&obj1)) goto fail;
6912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6913 if (SWIG_arg_fail(1)) SWIG_fail;
6914 {
6915 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6916 if (SWIG_arg_fail(2)) SWIG_fail;
6917 if (arg2 == NULL) {
6918 SWIG_null_ref("wxRegion");
6919 }
6920 if (SWIG_arg_fail(2)) SWIG_fail;
6921 }
6922 {
6923 PyThreadState* __tstate = wxPyBeginAllowThreads();
6924 result = (bool)(arg1)->Subtract((wxRegion const &)*arg2);
6925
6926 wxPyEndAllowThreads(__tstate);
6927 if (PyErr_Occurred()) SWIG_fail;
6928 }
6929 {
6930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6931 }
6932 return resultobj;
6933 fail:
6934 return NULL;
6935 }
6936
6937
6938 static PyObject *_wrap_Region_Xor(PyObject *, PyObject *args, PyObject *kwargs) {
6939 PyObject *resultobj;
6940 wxRegion *arg1 = (wxRegion *) 0 ;
6941 int arg2 ;
6942 int arg3 ;
6943 int arg4 ;
6944 int arg5 ;
6945 bool result;
6946 PyObject * obj0 = 0 ;
6947 PyObject * obj1 = 0 ;
6948 PyObject * obj2 = 0 ;
6949 PyObject * obj3 = 0 ;
6950 PyObject * obj4 = 0 ;
6951 char *kwnames[] = {
6952 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6953 };
6954
6955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Region_Xor",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
6957 if (SWIG_arg_fail(1)) SWIG_fail;
6958 {
6959 arg2 = (int)(SWIG_As_int(obj1));
6960 if (SWIG_arg_fail(2)) SWIG_fail;
6961 }
6962 {
6963 arg3 = (int)(SWIG_As_int(obj2));
6964 if (SWIG_arg_fail(3)) SWIG_fail;
6965 }
6966 {
6967 arg4 = (int)(SWIG_As_int(obj3));
6968 if (SWIG_arg_fail(4)) SWIG_fail;
6969 }
6970 {
6971 arg5 = (int)(SWIG_As_int(obj4));
6972 if (SWIG_arg_fail(5)) SWIG_fail;
6973 }
6974 {
6975 PyThreadState* __tstate = wxPyBeginAllowThreads();
6976 result = (bool)(arg1)->Xor(arg2,arg3,arg4,arg5);
6977
6978 wxPyEndAllowThreads(__tstate);
6979 if (PyErr_Occurred()) SWIG_fail;
6980 }
6981 {
6982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6983 }
6984 return resultobj;
6985 fail:
6986 return NULL;
6987 }
6988
6989
6990 static PyObject *_wrap_Region_XorRect(PyObject *, PyObject *args, PyObject *kwargs) {
6991 PyObject *resultobj;
6992 wxRegion *arg1 = (wxRegion *) 0 ;
6993 wxRect *arg2 = 0 ;
6994 bool result;
6995 wxRect temp2 ;
6996 PyObject * obj0 = 0 ;
6997 PyObject * obj1 = 0 ;
6998 char *kwnames[] = {
6999 (char *) "self",(char *) "rect", NULL
7000 };
7001
7002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRect",kwnames,&obj0,&obj1)) goto fail;
7003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7004 if (SWIG_arg_fail(1)) SWIG_fail;
7005 {
7006 arg2 = &temp2;
7007 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7008 }
7009 {
7010 PyThreadState* __tstate = wxPyBeginAllowThreads();
7011 result = (bool)(arg1)->Xor((wxRect const &)*arg2);
7012
7013 wxPyEndAllowThreads(__tstate);
7014 if (PyErr_Occurred()) SWIG_fail;
7015 }
7016 {
7017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7018 }
7019 return resultobj;
7020 fail:
7021 return NULL;
7022 }
7023
7024
7025 static PyObject *_wrap_Region_XorRegion(PyObject *, PyObject *args, PyObject *kwargs) {
7026 PyObject *resultobj;
7027 wxRegion *arg1 = (wxRegion *) 0 ;
7028 wxRegion *arg2 = 0 ;
7029 bool result;
7030 PyObject * obj0 = 0 ;
7031 PyObject * obj1 = 0 ;
7032 char *kwnames[] = {
7033 (char *) "self",(char *) "region", NULL
7034 };
7035
7036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_XorRegion",kwnames,&obj0,&obj1)) goto fail;
7037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7038 if (SWIG_arg_fail(1)) SWIG_fail;
7039 {
7040 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7041 if (SWIG_arg_fail(2)) SWIG_fail;
7042 if (arg2 == NULL) {
7043 SWIG_null_ref("wxRegion");
7044 }
7045 if (SWIG_arg_fail(2)) SWIG_fail;
7046 }
7047 {
7048 PyThreadState* __tstate = wxPyBeginAllowThreads();
7049 result = (bool)(arg1)->Xor((wxRegion const &)*arg2);
7050
7051 wxPyEndAllowThreads(__tstate);
7052 if (PyErr_Occurred()) SWIG_fail;
7053 }
7054 {
7055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7056 }
7057 return resultobj;
7058 fail:
7059 return NULL;
7060 }
7061
7062
7063 static PyObject *_wrap_Region_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7064 PyObject *resultobj;
7065 wxRegion *arg1 = (wxRegion *) 0 ;
7066 SwigValueWrapper<wxBitmap > result;
7067 PyObject * obj0 = 0 ;
7068 char *kwnames[] = {
7069 (char *) "self", NULL
7070 };
7071
7072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Region_ConvertToBitmap",kwnames,&obj0)) goto fail;
7073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7074 if (SWIG_arg_fail(1)) SWIG_fail;
7075 {
7076 PyThreadState* __tstate = wxPyBeginAllowThreads();
7077 result = (arg1)->ConvertToBitmap();
7078
7079 wxPyEndAllowThreads(__tstate);
7080 if (PyErr_Occurred()) SWIG_fail;
7081 }
7082 {
7083 wxBitmap * resultptr;
7084 resultptr = new wxBitmap((wxBitmap &)(result));
7085 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
7086 }
7087 return resultobj;
7088 fail:
7089 return NULL;
7090 }
7091
7092
7093 static PyObject *_wrap_Region_UnionBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
7094 PyObject *resultobj;
7095 wxRegion *arg1 = (wxRegion *) 0 ;
7096 wxBitmap *arg2 = 0 ;
7097 bool result;
7098 PyObject * obj0 = 0 ;
7099 PyObject * obj1 = 0 ;
7100 char *kwnames[] = {
7101 (char *) "self",(char *) "bmp", NULL
7102 };
7103
7104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Region_UnionBitmap",kwnames,&obj0,&obj1)) goto fail;
7105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7106 if (SWIG_arg_fail(1)) SWIG_fail;
7107 {
7108 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7109 if (SWIG_arg_fail(2)) SWIG_fail;
7110 if (arg2 == NULL) {
7111 SWIG_null_ref("wxBitmap");
7112 }
7113 if (SWIG_arg_fail(2)) SWIG_fail;
7114 }
7115 {
7116 PyThreadState* __tstate = wxPyBeginAllowThreads();
7117 result = (bool)(arg1)->Union((wxBitmap const &)*arg2);
7118
7119 wxPyEndAllowThreads(__tstate);
7120 if (PyErr_Occurred()) SWIG_fail;
7121 }
7122 {
7123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7124 }
7125 return resultobj;
7126 fail:
7127 return NULL;
7128 }
7129
7130
7131 static PyObject *_wrap_Region_UnionBitmapColour(PyObject *, PyObject *args, PyObject *kwargs) {
7132 PyObject *resultobj;
7133 wxRegion *arg1 = (wxRegion *) 0 ;
7134 wxBitmap *arg2 = 0 ;
7135 wxColour *arg3 = 0 ;
7136 int arg4 = (int) 0 ;
7137 bool result;
7138 wxColour temp3 ;
7139 PyObject * obj0 = 0 ;
7140 PyObject * obj1 = 0 ;
7141 PyObject * obj2 = 0 ;
7142 PyObject * obj3 = 0 ;
7143 char *kwnames[] = {
7144 (char *) "self",(char *) "bmp",(char *) "transColour",(char *) "tolerance", NULL
7145 };
7146
7147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Region_UnionBitmapColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
7148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7149 if (SWIG_arg_fail(1)) SWIG_fail;
7150 {
7151 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
7152 if (SWIG_arg_fail(2)) SWIG_fail;
7153 if (arg2 == NULL) {
7154 SWIG_null_ref("wxBitmap");
7155 }
7156 if (SWIG_arg_fail(2)) SWIG_fail;
7157 }
7158 {
7159 arg3 = &temp3;
7160 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
7161 }
7162 if (obj3) {
7163 {
7164 arg4 = (int)(SWIG_As_int(obj3));
7165 if (SWIG_arg_fail(4)) SWIG_fail;
7166 }
7167 }
7168 {
7169 PyThreadState* __tstate = wxPyBeginAllowThreads();
7170 result = (bool)(arg1)->Union((wxBitmap const &)*arg2,(wxColour const &)*arg3,arg4);
7171
7172 wxPyEndAllowThreads(__tstate);
7173 if (PyErr_Occurred()) SWIG_fail;
7174 }
7175 {
7176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7177 }
7178 return resultobj;
7179 fail:
7180 return NULL;
7181 }
7182
7183
7184 static PyObject * Region_swigregister(PyObject *, PyObject *args) {
7185 PyObject *obj;
7186 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7187 SWIG_TypeClientData(SWIGTYPE_p_wxRegion, obj);
7188 Py_INCREF(obj);
7189 return Py_BuildValue((char *)"");
7190 }
7191 static PyObject *_wrap_new_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7192 PyObject *resultobj;
7193 wxRegion *arg1 = 0 ;
7194 wxRegionIterator *result;
7195 PyObject * obj0 = 0 ;
7196 char *kwnames[] = {
7197 (char *) "region", NULL
7198 };
7199
7200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RegionIterator",kwnames,&obj0)) goto fail;
7201 {
7202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
7203 if (SWIG_arg_fail(1)) SWIG_fail;
7204 if (arg1 == NULL) {
7205 SWIG_null_ref("wxRegion");
7206 }
7207 if (SWIG_arg_fail(1)) SWIG_fail;
7208 }
7209 {
7210 if (!wxPyCheckForApp()) SWIG_fail;
7211 PyThreadState* __tstate = wxPyBeginAllowThreads();
7212 result = (wxRegionIterator *)new wxRegionIterator((wxRegion const &)*arg1);
7213
7214 wxPyEndAllowThreads(__tstate);
7215 if (PyErr_Occurred()) SWIG_fail;
7216 }
7217 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegionIterator, 1);
7218 return resultobj;
7219 fail:
7220 return NULL;
7221 }
7222
7223
7224 static PyObject *_wrap_delete_RegionIterator(PyObject *, PyObject *args, PyObject *kwargs) {
7225 PyObject *resultobj;
7226 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7227 PyObject * obj0 = 0 ;
7228 char *kwnames[] = {
7229 (char *) "self", NULL
7230 };
7231
7232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RegionIterator",kwnames,&obj0)) goto fail;
7233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7234 if (SWIG_arg_fail(1)) SWIG_fail;
7235 {
7236 PyThreadState* __tstate = wxPyBeginAllowThreads();
7237 delete arg1;
7238
7239 wxPyEndAllowThreads(__tstate);
7240 if (PyErr_Occurred()) SWIG_fail;
7241 }
7242 Py_INCREF(Py_None); resultobj = Py_None;
7243 return resultobj;
7244 fail:
7245 return NULL;
7246 }
7247
7248
7249 static PyObject *_wrap_RegionIterator_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
7250 PyObject *resultobj;
7251 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7252 int result;
7253 PyObject * obj0 = 0 ;
7254 char *kwnames[] = {
7255 (char *) "self", NULL
7256 };
7257
7258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetX",kwnames,&obj0)) goto fail;
7259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7260 if (SWIG_arg_fail(1)) SWIG_fail;
7261 {
7262 PyThreadState* __tstate = wxPyBeginAllowThreads();
7263 result = (int)(arg1)->GetX();
7264
7265 wxPyEndAllowThreads(__tstate);
7266 if (PyErr_Occurred()) SWIG_fail;
7267 }
7268 {
7269 resultobj = SWIG_From_int((int)(result));
7270 }
7271 return resultobj;
7272 fail:
7273 return NULL;
7274 }
7275
7276
7277 static PyObject *_wrap_RegionIterator_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
7278 PyObject *resultobj;
7279 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7280 int result;
7281 PyObject * obj0 = 0 ;
7282 char *kwnames[] = {
7283 (char *) "self", NULL
7284 };
7285
7286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetY",kwnames,&obj0)) goto fail;
7287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7288 if (SWIG_arg_fail(1)) SWIG_fail;
7289 {
7290 PyThreadState* __tstate = wxPyBeginAllowThreads();
7291 result = (int)(arg1)->GetY();
7292
7293 wxPyEndAllowThreads(__tstate);
7294 if (PyErr_Occurred()) SWIG_fail;
7295 }
7296 {
7297 resultobj = SWIG_From_int((int)(result));
7298 }
7299 return resultobj;
7300 fail:
7301 return NULL;
7302 }
7303
7304
7305 static PyObject *_wrap_RegionIterator_GetW(PyObject *, PyObject *args, PyObject *kwargs) {
7306 PyObject *resultobj;
7307 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7308 int result;
7309 PyObject * obj0 = 0 ;
7310 char *kwnames[] = {
7311 (char *) "self", NULL
7312 };
7313
7314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetW",kwnames,&obj0)) goto fail;
7315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7316 if (SWIG_arg_fail(1)) SWIG_fail;
7317 {
7318 PyThreadState* __tstate = wxPyBeginAllowThreads();
7319 result = (int)(arg1)->GetW();
7320
7321 wxPyEndAllowThreads(__tstate);
7322 if (PyErr_Occurred()) SWIG_fail;
7323 }
7324 {
7325 resultobj = SWIG_From_int((int)(result));
7326 }
7327 return resultobj;
7328 fail:
7329 return NULL;
7330 }
7331
7332
7333 static PyObject *_wrap_RegionIterator_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
7334 PyObject *resultobj;
7335 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7336 int result;
7337 PyObject * obj0 = 0 ;
7338 char *kwnames[] = {
7339 (char *) "self", NULL
7340 };
7341
7342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetWidth",kwnames,&obj0)) goto fail;
7343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7344 if (SWIG_arg_fail(1)) SWIG_fail;
7345 {
7346 PyThreadState* __tstate = wxPyBeginAllowThreads();
7347 result = (int)(arg1)->GetWidth();
7348
7349 wxPyEndAllowThreads(__tstate);
7350 if (PyErr_Occurred()) SWIG_fail;
7351 }
7352 {
7353 resultobj = SWIG_From_int((int)(result));
7354 }
7355 return resultobj;
7356 fail:
7357 return NULL;
7358 }
7359
7360
7361 static PyObject *_wrap_RegionIterator_GetH(PyObject *, PyObject *args, PyObject *kwargs) {
7362 PyObject *resultobj;
7363 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7364 int result;
7365 PyObject * obj0 = 0 ;
7366 char *kwnames[] = {
7367 (char *) "self", NULL
7368 };
7369
7370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetH",kwnames,&obj0)) goto fail;
7371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7372 if (SWIG_arg_fail(1)) SWIG_fail;
7373 {
7374 PyThreadState* __tstate = wxPyBeginAllowThreads();
7375 result = (int)(arg1)->GetH();
7376
7377 wxPyEndAllowThreads(__tstate);
7378 if (PyErr_Occurred()) SWIG_fail;
7379 }
7380 {
7381 resultobj = SWIG_From_int((int)(result));
7382 }
7383 return resultobj;
7384 fail:
7385 return NULL;
7386 }
7387
7388
7389 static PyObject *_wrap_RegionIterator_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
7390 PyObject *resultobj;
7391 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7392 int result;
7393 PyObject * obj0 = 0 ;
7394 char *kwnames[] = {
7395 (char *) "self", NULL
7396 };
7397
7398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetHeight",kwnames,&obj0)) goto fail;
7399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7400 if (SWIG_arg_fail(1)) SWIG_fail;
7401 {
7402 PyThreadState* __tstate = wxPyBeginAllowThreads();
7403 result = (int)(arg1)->GetHeight();
7404
7405 wxPyEndAllowThreads(__tstate);
7406 if (PyErr_Occurred()) SWIG_fail;
7407 }
7408 {
7409 resultobj = SWIG_From_int((int)(result));
7410 }
7411 return resultobj;
7412 fail:
7413 return NULL;
7414 }
7415
7416
7417 static PyObject *_wrap_RegionIterator_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
7418 PyObject *resultobj;
7419 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7420 wxRect result;
7421 PyObject * obj0 = 0 ;
7422 char *kwnames[] = {
7423 (char *) "self", NULL
7424 };
7425
7426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_GetRect",kwnames,&obj0)) goto fail;
7427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7428 if (SWIG_arg_fail(1)) SWIG_fail;
7429 {
7430 PyThreadState* __tstate = wxPyBeginAllowThreads();
7431 result = (arg1)->GetRect();
7432
7433 wxPyEndAllowThreads(__tstate);
7434 if (PyErr_Occurred()) SWIG_fail;
7435 }
7436 {
7437 wxRect * resultptr;
7438 resultptr = new wxRect((wxRect &)(result));
7439 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
7440 }
7441 return resultobj;
7442 fail:
7443 return NULL;
7444 }
7445
7446
7447 static PyObject *_wrap_RegionIterator_HaveRects(PyObject *, PyObject *args, PyObject *kwargs) {
7448 PyObject *resultobj;
7449 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7450 bool result;
7451 PyObject * obj0 = 0 ;
7452 char *kwnames[] = {
7453 (char *) "self", NULL
7454 };
7455
7456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_HaveRects",kwnames,&obj0)) goto fail;
7457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7458 if (SWIG_arg_fail(1)) SWIG_fail;
7459 {
7460 PyThreadState* __tstate = wxPyBeginAllowThreads();
7461 result = (bool)(arg1)->HaveRects();
7462
7463 wxPyEndAllowThreads(__tstate);
7464 if (PyErr_Occurred()) SWIG_fail;
7465 }
7466 {
7467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7468 }
7469 return resultobj;
7470 fail:
7471 return NULL;
7472 }
7473
7474
7475 static PyObject *_wrap_RegionIterator_Reset(PyObject *, PyObject *args, PyObject *kwargs) {
7476 PyObject *resultobj;
7477 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7478 PyObject * obj0 = 0 ;
7479 char *kwnames[] = {
7480 (char *) "self", NULL
7481 };
7482
7483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Reset",kwnames,&obj0)) goto fail;
7484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7485 if (SWIG_arg_fail(1)) SWIG_fail;
7486 {
7487 PyThreadState* __tstate = wxPyBeginAllowThreads();
7488 (arg1)->Reset();
7489
7490 wxPyEndAllowThreads(__tstate);
7491 if (PyErr_Occurred()) SWIG_fail;
7492 }
7493 Py_INCREF(Py_None); resultobj = Py_None;
7494 return resultobj;
7495 fail:
7496 return NULL;
7497 }
7498
7499
7500 static PyObject *_wrap_RegionIterator_Next(PyObject *, PyObject *args, PyObject *kwargs) {
7501 PyObject *resultobj;
7502 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7503 PyObject * obj0 = 0 ;
7504 char *kwnames[] = {
7505 (char *) "self", NULL
7506 };
7507
7508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator_Next",kwnames,&obj0)) goto fail;
7509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7510 if (SWIG_arg_fail(1)) SWIG_fail;
7511 {
7512 PyThreadState* __tstate = wxPyBeginAllowThreads();
7513 wxRegionIterator_Next(arg1);
7514
7515 wxPyEndAllowThreads(__tstate);
7516 if (PyErr_Occurred()) SWIG_fail;
7517 }
7518 Py_INCREF(Py_None); resultobj = Py_None;
7519 return resultobj;
7520 fail:
7521 return NULL;
7522 }
7523
7524
7525 static PyObject *_wrap_RegionIterator___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
7526 PyObject *resultobj;
7527 wxRegionIterator *arg1 = (wxRegionIterator *) 0 ;
7528 bool result;
7529 PyObject * obj0 = 0 ;
7530 char *kwnames[] = {
7531 (char *) "self", NULL
7532 };
7533
7534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegionIterator___nonzero__",kwnames,&obj0)) goto fail;
7535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRegionIterator, SWIG_POINTER_EXCEPTION | 0);
7536 if (SWIG_arg_fail(1)) SWIG_fail;
7537 {
7538 PyThreadState* __tstate = wxPyBeginAllowThreads();
7539 result = (bool)wxRegionIterator___nonzero__(arg1);
7540
7541 wxPyEndAllowThreads(__tstate);
7542 if (PyErr_Occurred()) SWIG_fail;
7543 }
7544 {
7545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7546 }
7547 return resultobj;
7548 fail:
7549 return NULL;
7550 }
7551
7552
7553 static PyObject * RegionIterator_swigregister(PyObject *, PyObject *args) {
7554 PyObject *obj;
7555 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7556 SWIG_TypeClientData(SWIGTYPE_p_wxRegionIterator, obj);
7557 Py_INCREF(obj);
7558 return Py_BuildValue((char *)"");
7559 }
7560 static PyObject *_wrap_new_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7561 PyObject *resultobj;
7562 wxNativeFontInfo *result;
7563 char *kwnames[] = {
7564 NULL
7565 };
7566
7567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeFontInfo",kwnames)) goto fail;
7568 {
7569 PyThreadState* __tstate = wxPyBeginAllowThreads();
7570 result = (wxNativeFontInfo *)new wxNativeFontInfo();
7571
7572 wxPyEndAllowThreads(__tstate);
7573 if (PyErr_Occurred()) SWIG_fail;
7574 }
7575 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 1);
7576 return resultobj;
7577 fail:
7578 return NULL;
7579 }
7580
7581
7582 static PyObject *_wrap_delete_NativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7583 PyObject *resultobj;
7584 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7585 PyObject * obj0 = 0 ;
7586 char *kwnames[] = {
7587 (char *) "self", NULL
7588 };
7589
7590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeFontInfo",kwnames,&obj0)) goto fail;
7591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7592 if (SWIG_arg_fail(1)) SWIG_fail;
7593 {
7594 PyThreadState* __tstate = wxPyBeginAllowThreads();
7595 delete arg1;
7596
7597 wxPyEndAllowThreads(__tstate);
7598 if (PyErr_Occurred()) SWIG_fail;
7599 }
7600 Py_INCREF(Py_None); resultobj = Py_None;
7601 return resultobj;
7602 fail:
7603 return NULL;
7604 }
7605
7606
7607 static PyObject *_wrap_NativeFontInfo_Init(PyObject *, PyObject *args, PyObject *kwargs) {
7608 PyObject *resultobj;
7609 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7610 PyObject * obj0 = 0 ;
7611 char *kwnames[] = {
7612 (char *) "self", NULL
7613 };
7614
7615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_Init",kwnames,&obj0)) goto fail;
7616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7617 if (SWIG_arg_fail(1)) SWIG_fail;
7618 {
7619 PyThreadState* __tstate = wxPyBeginAllowThreads();
7620 (arg1)->Init();
7621
7622 wxPyEndAllowThreads(__tstate);
7623 if (PyErr_Occurred()) SWIG_fail;
7624 }
7625 Py_INCREF(Py_None); resultobj = Py_None;
7626 return resultobj;
7627 fail:
7628 return NULL;
7629 }
7630
7631
7632 static PyObject *_wrap_NativeFontInfo_InitFromFont(PyObject *, PyObject *args, PyObject *kwargs) {
7633 PyObject *resultobj;
7634 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7635 wxFont *arg2 = 0 ;
7636 PyObject * obj0 = 0 ;
7637 PyObject * obj1 = 0 ;
7638 char *kwnames[] = {
7639 (char *) "self",(char *) "font", NULL
7640 };
7641
7642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_InitFromFont",kwnames,&obj0,&obj1)) goto fail;
7643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7644 if (SWIG_arg_fail(1)) SWIG_fail;
7645 {
7646 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
7647 if (SWIG_arg_fail(2)) SWIG_fail;
7648 if (arg2 == NULL) {
7649 SWIG_null_ref("wxFont");
7650 }
7651 if (SWIG_arg_fail(2)) SWIG_fail;
7652 }
7653 {
7654 PyThreadState* __tstate = wxPyBeginAllowThreads();
7655 (arg1)->InitFromFont((wxFont const &)*arg2);
7656
7657 wxPyEndAllowThreads(__tstate);
7658 if (PyErr_Occurred()) SWIG_fail;
7659 }
7660 Py_INCREF(Py_None); resultobj = Py_None;
7661 return resultobj;
7662 fail:
7663 return NULL;
7664 }
7665
7666
7667 static PyObject *_wrap_NativeFontInfo_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
7668 PyObject *resultobj;
7669 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7670 int result;
7671 PyObject * obj0 = 0 ;
7672 char *kwnames[] = {
7673 (char *) "self", NULL
7674 };
7675
7676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetPointSize",kwnames,&obj0)) goto fail;
7677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7678 if (SWIG_arg_fail(1)) SWIG_fail;
7679 {
7680 PyThreadState* __tstate = wxPyBeginAllowThreads();
7681 result = (int)((wxNativeFontInfo const *)arg1)->GetPointSize();
7682
7683 wxPyEndAllowThreads(__tstate);
7684 if (PyErr_Occurred()) SWIG_fail;
7685 }
7686 {
7687 resultobj = SWIG_From_int((int)(result));
7688 }
7689 return resultobj;
7690 fail:
7691 return NULL;
7692 }
7693
7694
7695 static PyObject *_wrap_NativeFontInfo_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
7696 PyObject *resultobj;
7697 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7698 wxFontStyle result;
7699 PyObject * obj0 = 0 ;
7700 char *kwnames[] = {
7701 (char *) "self", NULL
7702 };
7703
7704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetStyle",kwnames,&obj0)) goto fail;
7705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7706 if (SWIG_arg_fail(1)) SWIG_fail;
7707 {
7708 PyThreadState* __tstate = wxPyBeginAllowThreads();
7709 result = (wxFontStyle)((wxNativeFontInfo const *)arg1)->GetStyle();
7710
7711 wxPyEndAllowThreads(__tstate);
7712 if (PyErr_Occurred()) SWIG_fail;
7713 }
7714 resultobj = SWIG_From_int((result));
7715 return resultobj;
7716 fail:
7717 return NULL;
7718 }
7719
7720
7721 static PyObject *_wrap_NativeFontInfo_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
7722 PyObject *resultobj;
7723 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7724 wxFontWeight result;
7725 PyObject * obj0 = 0 ;
7726 char *kwnames[] = {
7727 (char *) "self", NULL
7728 };
7729
7730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetWeight",kwnames,&obj0)) goto fail;
7731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7732 if (SWIG_arg_fail(1)) SWIG_fail;
7733 {
7734 PyThreadState* __tstate = wxPyBeginAllowThreads();
7735 result = (wxFontWeight)((wxNativeFontInfo const *)arg1)->GetWeight();
7736
7737 wxPyEndAllowThreads(__tstate);
7738 if (PyErr_Occurred()) SWIG_fail;
7739 }
7740 resultobj = SWIG_From_int((result));
7741 return resultobj;
7742 fail:
7743 return NULL;
7744 }
7745
7746
7747 static PyObject *_wrap_NativeFontInfo_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
7748 PyObject *resultobj;
7749 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7750 bool result;
7751 PyObject * obj0 = 0 ;
7752 char *kwnames[] = {
7753 (char *) "self", NULL
7754 };
7755
7756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetUnderlined",kwnames,&obj0)) goto fail;
7757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7758 if (SWIG_arg_fail(1)) SWIG_fail;
7759 {
7760 PyThreadState* __tstate = wxPyBeginAllowThreads();
7761 result = (bool)((wxNativeFontInfo const *)arg1)->GetUnderlined();
7762
7763 wxPyEndAllowThreads(__tstate);
7764 if (PyErr_Occurred()) SWIG_fail;
7765 }
7766 {
7767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7768 }
7769 return resultobj;
7770 fail:
7771 return NULL;
7772 }
7773
7774
7775 static PyObject *_wrap_NativeFontInfo_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
7776 PyObject *resultobj;
7777 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7778 wxString result;
7779 PyObject * obj0 = 0 ;
7780 char *kwnames[] = {
7781 (char *) "self", NULL
7782 };
7783
7784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFaceName",kwnames,&obj0)) goto fail;
7785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7786 if (SWIG_arg_fail(1)) SWIG_fail;
7787 {
7788 PyThreadState* __tstate = wxPyBeginAllowThreads();
7789 result = ((wxNativeFontInfo const *)arg1)->GetFaceName();
7790
7791 wxPyEndAllowThreads(__tstate);
7792 if (PyErr_Occurred()) SWIG_fail;
7793 }
7794 {
7795 #if wxUSE_UNICODE
7796 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7797 #else
7798 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7799 #endif
7800 }
7801 return resultobj;
7802 fail:
7803 return NULL;
7804 }
7805
7806
7807 static PyObject *_wrap_NativeFontInfo_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
7808 PyObject *resultobj;
7809 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7810 wxFontFamily result;
7811 PyObject * obj0 = 0 ;
7812 char *kwnames[] = {
7813 (char *) "self", NULL
7814 };
7815
7816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetFamily",kwnames,&obj0)) goto fail;
7817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7818 if (SWIG_arg_fail(1)) SWIG_fail;
7819 {
7820 PyThreadState* __tstate = wxPyBeginAllowThreads();
7821 result = (wxFontFamily)((wxNativeFontInfo const *)arg1)->GetFamily();
7822
7823 wxPyEndAllowThreads(__tstate);
7824 if (PyErr_Occurred()) SWIG_fail;
7825 }
7826 resultobj = SWIG_From_int((result));
7827 return resultobj;
7828 fail:
7829 return NULL;
7830 }
7831
7832
7833 static PyObject *_wrap_NativeFontInfo_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
7834 PyObject *resultobj;
7835 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7836 wxFontEncoding result;
7837 PyObject * obj0 = 0 ;
7838 char *kwnames[] = {
7839 (char *) "self", NULL
7840 };
7841
7842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_GetEncoding",kwnames,&obj0)) goto fail;
7843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7844 if (SWIG_arg_fail(1)) SWIG_fail;
7845 {
7846 PyThreadState* __tstate = wxPyBeginAllowThreads();
7847 result = (wxFontEncoding)((wxNativeFontInfo const *)arg1)->GetEncoding();
7848
7849 wxPyEndAllowThreads(__tstate);
7850 if (PyErr_Occurred()) SWIG_fail;
7851 }
7852 resultobj = SWIG_From_int((result));
7853 return resultobj;
7854 fail:
7855 return NULL;
7856 }
7857
7858
7859 static PyObject *_wrap_NativeFontInfo_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
7860 PyObject *resultobj;
7861 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7862 int arg2 ;
7863 PyObject * obj0 = 0 ;
7864 PyObject * obj1 = 0 ;
7865 char *kwnames[] = {
7866 (char *) "self",(char *) "pointsize", NULL
7867 };
7868
7869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
7870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7871 if (SWIG_arg_fail(1)) SWIG_fail;
7872 {
7873 arg2 = (int)(SWIG_As_int(obj1));
7874 if (SWIG_arg_fail(2)) SWIG_fail;
7875 }
7876 {
7877 PyThreadState* __tstate = wxPyBeginAllowThreads();
7878 (arg1)->SetPointSize(arg2);
7879
7880 wxPyEndAllowThreads(__tstate);
7881 if (PyErr_Occurred()) SWIG_fail;
7882 }
7883 Py_INCREF(Py_None); resultobj = Py_None;
7884 return resultobj;
7885 fail:
7886 return NULL;
7887 }
7888
7889
7890 static PyObject *_wrap_NativeFontInfo_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
7891 PyObject *resultobj;
7892 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7893 wxFontStyle arg2 ;
7894 PyObject * obj0 = 0 ;
7895 PyObject * obj1 = 0 ;
7896 char *kwnames[] = {
7897 (char *) "self",(char *) "style", NULL
7898 };
7899
7900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetStyle",kwnames,&obj0,&obj1)) goto fail;
7901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7902 if (SWIG_arg_fail(1)) SWIG_fail;
7903 {
7904 arg2 = (wxFontStyle)(SWIG_As_int(obj1));
7905 if (SWIG_arg_fail(2)) SWIG_fail;
7906 }
7907 {
7908 PyThreadState* __tstate = wxPyBeginAllowThreads();
7909 (arg1)->SetStyle((wxFontStyle )arg2);
7910
7911 wxPyEndAllowThreads(__tstate);
7912 if (PyErr_Occurred()) SWIG_fail;
7913 }
7914 Py_INCREF(Py_None); resultobj = Py_None;
7915 return resultobj;
7916 fail:
7917 return NULL;
7918 }
7919
7920
7921 static PyObject *_wrap_NativeFontInfo_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
7922 PyObject *resultobj;
7923 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7924 wxFontWeight arg2 ;
7925 PyObject * obj0 = 0 ;
7926 PyObject * obj1 = 0 ;
7927 char *kwnames[] = {
7928 (char *) "self",(char *) "weight", NULL
7929 };
7930
7931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetWeight",kwnames,&obj0,&obj1)) goto fail;
7932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7933 if (SWIG_arg_fail(1)) SWIG_fail;
7934 {
7935 arg2 = (wxFontWeight)(SWIG_As_int(obj1));
7936 if (SWIG_arg_fail(2)) SWIG_fail;
7937 }
7938 {
7939 PyThreadState* __tstate = wxPyBeginAllowThreads();
7940 (arg1)->SetWeight((wxFontWeight )arg2);
7941
7942 wxPyEndAllowThreads(__tstate);
7943 if (PyErr_Occurred()) SWIG_fail;
7944 }
7945 Py_INCREF(Py_None); resultobj = Py_None;
7946 return resultobj;
7947 fail:
7948 return NULL;
7949 }
7950
7951
7952 static PyObject *_wrap_NativeFontInfo_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
7953 PyObject *resultobj;
7954 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7955 bool arg2 ;
7956 PyObject * obj0 = 0 ;
7957 PyObject * obj1 = 0 ;
7958 char *kwnames[] = {
7959 (char *) "self",(char *) "underlined", NULL
7960 };
7961
7962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
7963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7964 if (SWIG_arg_fail(1)) SWIG_fail;
7965 {
7966 arg2 = (bool)(SWIG_As_bool(obj1));
7967 if (SWIG_arg_fail(2)) SWIG_fail;
7968 }
7969 {
7970 PyThreadState* __tstate = wxPyBeginAllowThreads();
7971 (arg1)->SetUnderlined(arg2);
7972
7973 wxPyEndAllowThreads(__tstate);
7974 if (PyErr_Occurred()) SWIG_fail;
7975 }
7976 Py_INCREF(Py_None); resultobj = Py_None;
7977 return resultobj;
7978 fail:
7979 return NULL;
7980 }
7981
7982
7983 static PyObject *_wrap_NativeFontInfo_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
7984 PyObject *resultobj;
7985 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
7986 wxString arg2 ;
7987 PyObject * obj0 = 0 ;
7988 PyObject * obj1 = 0 ;
7989 char *kwnames[] = {
7990 (char *) "self",(char *) "facename", NULL
7991 };
7992
7993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
7994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
7995 if (SWIG_arg_fail(1)) SWIG_fail;
7996 {
7997 wxString* sptr = wxString_in_helper(obj1);
7998 if (sptr == NULL) SWIG_fail;
7999 arg2 = *sptr;
8000 delete sptr;
8001 }
8002 {
8003 PyThreadState* __tstate = wxPyBeginAllowThreads();
8004 (arg1)->SetFaceName(arg2);
8005
8006 wxPyEndAllowThreads(__tstate);
8007 if (PyErr_Occurred()) SWIG_fail;
8008 }
8009 Py_INCREF(Py_None); resultobj = Py_None;
8010 return resultobj;
8011 fail:
8012 return NULL;
8013 }
8014
8015
8016 static PyObject *_wrap_NativeFontInfo_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
8017 PyObject *resultobj;
8018 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8019 wxFontFamily arg2 ;
8020 PyObject * obj0 = 0 ;
8021 PyObject * obj1 = 0 ;
8022 char *kwnames[] = {
8023 (char *) "self",(char *) "family", NULL
8024 };
8025
8026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetFamily",kwnames,&obj0,&obj1)) goto fail;
8027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8028 if (SWIG_arg_fail(1)) SWIG_fail;
8029 {
8030 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
8031 if (SWIG_arg_fail(2)) SWIG_fail;
8032 }
8033 {
8034 PyThreadState* __tstate = wxPyBeginAllowThreads();
8035 (arg1)->SetFamily((wxFontFamily )arg2);
8036
8037 wxPyEndAllowThreads(__tstate);
8038 if (PyErr_Occurred()) SWIG_fail;
8039 }
8040 Py_INCREF(Py_None); resultobj = Py_None;
8041 return resultobj;
8042 fail:
8043 return NULL;
8044 }
8045
8046
8047 static PyObject *_wrap_NativeFontInfo_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8048 PyObject *resultobj;
8049 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8050 wxFontEncoding arg2 ;
8051 PyObject * obj0 = 0 ;
8052 PyObject * obj1 = 0 ;
8053 char *kwnames[] = {
8054 (char *) "self",(char *) "encoding", NULL
8055 };
8056
8057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
8058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8059 if (SWIG_arg_fail(1)) SWIG_fail;
8060 {
8061 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8062 if (SWIG_arg_fail(2)) SWIG_fail;
8063 }
8064 {
8065 PyThreadState* __tstate = wxPyBeginAllowThreads();
8066 (arg1)->SetEncoding((wxFontEncoding )arg2);
8067
8068 wxPyEndAllowThreads(__tstate);
8069 if (PyErr_Occurred()) SWIG_fail;
8070 }
8071 Py_INCREF(Py_None); resultobj = Py_None;
8072 return resultobj;
8073 fail:
8074 return NULL;
8075 }
8076
8077
8078 static PyObject *_wrap_NativeFontInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
8079 PyObject *resultobj;
8080 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8081 wxString *arg2 = 0 ;
8082 bool result;
8083 bool temp2 = false ;
8084 PyObject * obj0 = 0 ;
8085 PyObject * obj1 = 0 ;
8086 char *kwnames[] = {
8087 (char *) "self",(char *) "s", NULL
8088 };
8089
8090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
8091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8092 if (SWIG_arg_fail(1)) SWIG_fail;
8093 {
8094 arg2 = wxString_in_helper(obj1);
8095 if (arg2 == NULL) SWIG_fail;
8096 temp2 = true;
8097 }
8098 {
8099 PyThreadState* __tstate = wxPyBeginAllowThreads();
8100 result = (bool)(arg1)->FromString((wxString const &)*arg2);
8101
8102 wxPyEndAllowThreads(__tstate);
8103 if (PyErr_Occurred()) SWIG_fail;
8104 }
8105 {
8106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8107 }
8108 {
8109 if (temp2)
8110 delete arg2;
8111 }
8112 return resultobj;
8113 fail:
8114 {
8115 if (temp2)
8116 delete arg2;
8117 }
8118 return NULL;
8119 }
8120
8121
8122 static PyObject *_wrap_NativeFontInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
8123 PyObject *resultobj;
8124 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8125 wxString result;
8126 PyObject * obj0 = 0 ;
8127 char *kwnames[] = {
8128 (char *) "self", NULL
8129 };
8130
8131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToString",kwnames,&obj0)) goto fail;
8132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8133 if (SWIG_arg_fail(1)) SWIG_fail;
8134 {
8135 PyThreadState* __tstate = wxPyBeginAllowThreads();
8136 result = ((wxNativeFontInfo const *)arg1)->ToString();
8137
8138 wxPyEndAllowThreads(__tstate);
8139 if (PyErr_Occurred()) SWIG_fail;
8140 }
8141 {
8142 #if wxUSE_UNICODE
8143 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8144 #else
8145 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8146 #endif
8147 }
8148 return resultobj;
8149 fail:
8150 return NULL;
8151 }
8152
8153
8154 static PyObject *_wrap_NativeFontInfo___str__(PyObject *, PyObject *args, PyObject *kwargs) {
8155 PyObject *resultobj;
8156 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8157 wxString result;
8158 PyObject * obj0 = 0 ;
8159 char *kwnames[] = {
8160 (char *) "self", NULL
8161 };
8162
8163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo___str__",kwnames,&obj0)) goto fail;
8164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8165 if (SWIG_arg_fail(1)) SWIG_fail;
8166 {
8167 PyThreadState* __tstate = wxPyBeginAllowThreads();
8168 result = wxNativeFontInfo___str__(arg1);
8169
8170 wxPyEndAllowThreads(__tstate);
8171 if (PyErr_Occurred()) SWIG_fail;
8172 }
8173 {
8174 #if wxUSE_UNICODE
8175 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8176 #else
8177 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8178 #endif
8179 }
8180 return resultobj;
8181 fail:
8182 return NULL;
8183 }
8184
8185
8186 static PyObject *_wrap_NativeFontInfo_FromUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8187 PyObject *resultobj;
8188 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8189 wxString *arg2 = 0 ;
8190 bool result;
8191 bool temp2 = false ;
8192 PyObject * obj0 = 0 ;
8193 PyObject * obj1 = 0 ;
8194 char *kwnames[] = {
8195 (char *) "self",(char *) "s", NULL
8196 };
8197
8198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeFontInfo_FromUserString",kwnames,&obj0,&obj1)) goto fail;
8199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8200 if (SWIG_arg_fail(1)) SWIG_fail;
8201 {
8202 arg2 = wxString_in_helper(obj1);
8203 if (arg2 == NULL) SWIG_fail;
8204 temp2 = true;
8205 }
8206 {
8207 PyThreadState* __tstate = wxPyBeginAllowThreads();
8208 result = (bool)(arg1)->FromUserString((wxString const &)*arg2);
8209
8210 wxPyEndAllowThreads(__tstate);
8211 if (PyErr_Occurred()) SWIG_fail;
8212 }
8213 {
8214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8215 }
8216 {
8217 if (temp2)
8218 delete arg2;
8219 }
8220 return resultobj;
8221 fail:
8222 {
8223 if (temp2)
8224 delete arg2;
8225 }
8226 return NULL;
8227 }
8228
8229
8230 static PyObject *_wrap_NativeFontInfo_ToUserString(PyObject *, PyObject *args, PyObject *kwargs) {
8231 PyObject *resultobj;
8232 wxNativeFontInfo *arg1 = (wxNativeFontInfo *) 0 ;
8233 wxString result;
8234 PyObject * obj0 = 0 ;
8235 char *kwnames[] = {
8236 (char *) "self", NULL
8237 };
8238
8239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeFontInfo_ToUserString",kwnames,&obj0)) goto fail;
8240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
8241 if (SWIG_arg_fail(1)) SWIG_fail;
8242 {
8243 PyThreadState* __tstate = wxPyBeginAllowThreads();
8244 result = ((wxNativeFontInfo const *)arg1)->ToUserString();
8245
8246 wxPyEndAllowThreads(__tstate);
8247 if (PyErr_Occurred()) SWIG_fail;
8248 }
8249 {
8250 #if wxUSE_UNICODE
8251 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8252 #else
8253 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8254 #endif
8255 }
8256 return resultobj;
8257 fail:
8258 return NULL;
8259 }
8260
8261
8262 static PyObject * NativeFontInfo_swigregister(PyObject *, PyObject *args) {
8263 PyObject *obj;
8264 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8265 SWIG_TypeClientData(SWIGTYPE_p_wxNativeFontInfo, obj);
8266 Py_INCREF(obj);
8267 return Py_BuildValue((char *)"");
8268 }
8269 static PyObject *_wrap_NativeEncodingInfo_facename_set(PyObject *, PyObject *args, PyObject *kwargs) {
8270 PyObject *resultobj;
8271 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8272 wxString *arg2 = (wxString *) 0 ;
8273 bool temp2 = false ;
8274 PyObject * obj0 = 0 ;
8275 PyObject * obj1 = 0 ;
8276 char *kwnames[] = {
8277 (char *) "self",(char *) "facename", NULL
8278 };
8279
8280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_facename_set",kwnames,&obj0,&obj1)) goto fail;
8281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8282 if (SWIG_arg_fail(1)) SWIG_fail;
8283 {
8284 arg2 = wxString_in_helper(obj1);
8285 if (arg2 == NULL) SWIG_fail;
8286 temp2 = true;
8287 }
8288 if (arg1) (arg1)->facename = *arg2;
8289
8290 Py_INCREF(Py_None); resultobj = Py_None;
8291 {
8292 if (temp2)
8293 delete arg2;
8294 }
8295 return resultobj;
8296 fail:
8297 {
8298 if (temp2)
8299 delete arg2;
8300 }
8301 return NULL;
8302 }
8303
8304
8305 static PyObject *_wrap_NativeEncodingInfo_facename_get(PyObject *, PyObject *args, PyObject *kwargs) {
8306 PyObject *resultobj;
8307 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8308 wxString *result;
8309 PyObject * obj0 = 0 ;
8310 char *kwnames[] = {
8311 (char *) "self", NULL
8312 };
8313
8314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_facename_get",kwnames,&obj0)) goto fail;
8315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8316 if (SWIG_arg_fail(1)) SWIG_fail;
8317 result = (wxString *)& ((arg1)->facename);
8318
8319 {
8320 #if wxUSE_UNICODE
8321 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8322 #else
8323 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8324 #endif
8325 }
8326 return resultobj;
8327 fail:
8328 return NULL;
8329 }
8330
8331
8332 static PyObject *_wrap_NativeEncodingInfo_encoding_set(PyObject *, PyObject *args, PyObject *kwargs) {
8333 PyObject *resultobj;
8334 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8335 wxFontEncoding arg2 ;
8336 PyObject * obj0 = 0 ;
8337 PyObject * obj1 = 0 ;
8338 char *kwnames[] = {
8339 (char *) "self",(char *) "encoding", NULL
8340 };
8341
8342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_encoding_set",kwnames,&obj0,&obj1)) goto fail;
8343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8344 if (SWIG_arg_fail(1)) SWIG_fail;
8345 {
8346 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8347 if (SWIG_arg_fail(2)) SWIG_fail;
8348 }
8349 if (arg1) (arg1)->encoding = (wxFontEncoding )arg2;
8350
8351 Py_INCREF(Py_None); resultobj = Py_None;
8352 return resultobj;
8353 fail:
8354 return NULL;
8355 }
8356
8357
8358 static PyObject *_wrap_NativeEncodingInfo_encoding_get(PyObject *, PyObject *args, PyObject *kwargs) {
8359 PyObject *resultobj;
8360 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8361 wxFontEncoding result;
8362 PyObject * obj0 = 0 ;
8363 char *kwnames[] = {
8364 (char *) "self", NULL
8365 };
8366
8367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_encoding_get",kwnames,&obj0)) goto fail;
8368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8369 if (SWIG_arg_fail(1)) SWIG_fail;
8370 result = (wxFontEncoding) ((arg1)->encoding);
8371
8372 resultobj = SWIG_From_int((result));
8373 return resultobj;
8374 fail:
8375 return NULL;
8376 }
8377
8378
8379 static PyObject *_wrap_new_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8380 PyObject *resultobj;
8381 wxNativeEncodingInfo *result;
8382 char *kwnames[] = {
8383 NULL
8384 };
8385
8386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NativeEncodingInfo",kwnames)) goto fail;
8387 {
8388 PyThreadState* __tstate = wxPyBeginAllowThreads();
8389 result = (wxNativeEncodingInfo *)new wxNativeEncodingInfo();
8390
8391 wxPyEndAllowThreads(__tstate);
8392 if (PyErr_Occurred()) SWIG_fail;
8393 }
8394 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 1);
8395 return resultobj;
8396 fail:
8397 return NULL;
8398 }
8399
8400
8401 static PyObject *_wrap_delete_NativeEncodingInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8402 PyObject *resultobj;
8403 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8404 PyObject * obj0 = 0 ;
8405 char *kwnames[] = {
8406 (char *) "self", NULL
8407 };
8408
8409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_NativeEncodingInfo",kwnames,&obj0)) goto fail;
8410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8411 if (SWIG_arg_fail(1)) SWIG_fail;
8412 {
8413 PyThreadState* __tstate = wxPyBeginAllowThreads();
8414 delete arg1;
8415
8416 wxPyEndAllowThreads(__tstate);
8417 if (PyErr_Occurred()) SWIG_fail;
8418 }
8419 Py_INCREF(Py_None); resultobj = Py_None;
8420 return resultobj;
8421 fail:
8422 return NULL;
8423 }
8424
8425
8426 static PyObject *_wrap_NativeEncodingInfo_FromString(PyObject *, PyObject *args, PyObject *kwargs) {
8427 PyObject *resultobj;
8428 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8429 wxString *arg2 = 0 ;
8430 bool result;
8431 bool temp2 = false ;
8432 PyObject * obj0 = 0 ;
8433 PyObject * obj1 = 0 ;
8434 char *kwnames[] = {
8435 (char *) "self",(char *) "s", NULL
8436 };
8437
8438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_FromString",kwnames,&obj0,&obj1)) goto fail;
8439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8440 if (SWIG_arg_fail(1)) SWIG_fail;
8441 {
8442 arg2 = wxString_in_helper(obj1);
8443 if (arg2 == NULL) SWIG_fail;
8444 temp2 = true;
8445 }
8446 {
8447 PyThreadState* __tstate = wxPyBeginAllowThreads();
8448 result = (bool)(arg1)->FromString((wxString const &)*arg2);
8449
8450 wxPyEndAllowThreads(__tstate);
8451 if (PyErr_Occurred()) SWIG_fail;
8452 }
8453 {
8454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8455 }
8456 {
8457 if (temp2)
8458 delete arg2;
8459 }
8460 return resultobj;
8461 fail:
8462 {
8463 if (temp2)
8464 delete arg2;
8465 }
8466 return NULL;
8467 }
8468
8469
8470 static PyObject *_wrap_NativeEncodingInfo_ToString(PyObject *, PyObject *args, PyObject *kwargs) {
8471 PyObject *resultobj;
8472 wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
8473 wxString result;
8474 PyObject * obj0 = 0 ;
8475 char *kwnames[] = {
8476 (char *) "self", NULL
8477 };
8478
8479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_ToString",kwnames,&obj0)) goto fail;
8480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8481 if (SWIG_arg_fail(1)) SWIG_fail;
8482 {
8483 PyThreadState* __tstate = wxPyBeginAllowThreads();
8484 result = ((wxNativeEncodingInfo const *)arg1)->ToString();
8485
8486 wxPyEndAllowThreads(__tstate);
8487 if (PyErr_Occurred()) SWIG_fail;
8488 }
8489 {
8490 #if wxUSE_UNICODE
8491 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8492 #else
8493 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8494 #endif
8495 }
8496 return resultobj;
8497 fail:
8498 return NULL;
8499 }
8500
8501
8502 static PyObject * NativeEncodingInfo_swigregister(PyObject *, PyObject *args) {
8503 PyObject *obj;
8504 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8505 SWIG_TypeClientData(SWIGTYPE_p_wxNativeEncodingInfo, obj);
8506 Py_INCREF(obj);
8507 return Py_BuildValue((char *)"");
8508 }
8509 static PyObject *_wrap_GetNativeFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8510 PyObject *resultobj;
8511 wxFontEncoding arg1 ;
8512 wxNativeEncodingInfo *result;
8513 PyObject * obj0 = 0 ;
8514 char *kwnames[] = {
8515 (char *) "encoding", NULL
8516 };
8517
8518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetNativeFontEncoding",kwnames,&obj0)) goto fail;
8519 {
8520 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8521 if (SWIG_arg_fail(1)) SWIG_fail;
8522 }
8523 {
8524 PyThreadState* __tstate = wxPyBeginAllowThreads();
8525 result = (wxNativeEncodingInfo *)wxGetNativeFontEncoding((wxFontEncoding )arg1);
8526
8527 wxPyEndAllowThreads(__tstate);
8528 if (PyErr_Occurred()) SWIG_fail;
8529 }
8530 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeEncodingInfo, 0);
8531 return resultobj;
8532 fail:
8533 return NULL;
8534 }
8535
8536
8537 static PyObject *_wrap_TestFontEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8538 PyObject *resultobj;
8539 wxNativeEncodingInfo *arg1 = 0 ;
8540 bool result;
8541 PyObject * obj0 = 0 ;
8542 char *kwnames[] = {
8543 (char *) "info", NULL
8544 };
8545
8546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TestFontEncoding",kwnames,&obj0)) goto fail;
8547 {
8548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeEncodingInfo, SWIG_POINTER_EXCEPTION | 0);
8549 if (SWIG_arg_fail(1)) SWIG_fail;
8550 if (arg1 == NULL) {
8551 SWIG_null_ref("wxNativeEncodingInfo");
8552 }
8553 if (SWIG_arg_fail(1)) SWIG_fail;
8554 }
8555 {
8556 PyThreadState* __tstate = wxPyBeginAllowThreads();
8557 result = (bool)wxTestFontEncoding((wxNativeEncodingInfo const &)*arg1);
8558
8559 wxPyEndAllowThreads(__tstate);
8560 if (PyErr_Occurred()) SWIG_fail;
8561 }
8562 {
8563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8564 }
8565 return resultobj;
8566 fail:
8567 return NULL;
8568 }
8569
8570
8571 static PyObject *_wrap_new_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
8572 PyObject *resultobj;
8573 wxFontMapper *result;
8574 char *kwnames[] = {
8575 NULL
8576 };
8577
8578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontMapper",kwnames)) goto fail;
8579 {
8580 PyThreadState* __tstate = wxPyBeginAllowThreads();
8581 result = (wxFontMapper *)new wxFontMapper();
8582
8583 wxPyEndAllowThreads(__tstate);
8584 if (PyErr_Occurred()) SWIG_fail;
8585 }
8586 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 1);
8587 return resultobj;
8588 fail:
8589 return NULL;
8590 }
8591
8592
8593 static PyObject *_wrap_delete_FontMapper(PyObject *, PyObject *args, PyObject *kwargs) {
8594 PyObject *resultobj;
8595 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8596 PyObject * obj0 = 0 ;
8597 char *kwnames[] = {
8598 (char *) "self", NULL
8599 };
8600
8601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontMapper",kwnames,&obj0)) goto fail;
8602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8603 if (SWIG_arg_fail(1)) SWIG_fail;
8604 {
8605 PyThreadState* __tstate = wxPyBeginAllowThreads();
8606 delete arg1;
8607
8608 wxPyEndAllowThreads(__tstate);
8609 if (PyErr_Occurred()) SWIG_fail;
8610 }
8611 Py_INCREF(Py_None); resultobj = Py_None;
8612 return resultobj;
8613 fail:
8614 return NULL;
8615 }
8616
8617
8618 static PyObject *_wrap_FontMapper_Get(PyObject *, PyObject *args, PyObject *kwargs) {
8619 PyObject *resultobj;
8620 wxFontMapper *result;
8621 char *kwnames[] = {
8622 NULL
8623 };
8624
8625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_Get",kwnames)) goto fail;
8626 {
8627 PyThreadState* __tstate = wxPyBeginAllowThreads();
8628 result = (wxFontMapper *)wxFontMapper::Get();
8629
8630 wxPyEndAllowThreads(__tstate);
8631 if (PyErr_Occurred()) SWIG_fail;
8632 }
8633 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
8634 return resultobj;
8635 fail:
8636 return NULL;
8637 }
8638
8639
8640 static PyObject *_wrap_FontMapper_Set(PyObject *, PyObject *args, PyObject *kwargs) {
8641 PyObject *resultobj;
8642 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8643 wxFontMapper *result;
8644 PyObject * obj0 = 0 ;
8645 char *kwnames[] = {
8646 (char *) "mapper", NULL
8647 };
8648
8649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_Set",kwnames,&obj0)) goto fail;
8650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8651 if (SWIG_arg_fail(1)) SWIG_fail;
8652 {
8653 PyThreadState* __tstate = wxPyBeginAllowThreads();
8654 result = (wxFontMapper *)wxFontMapper::Set(arg1);
8655
8656 wxPyEndAllowThreads(__tstate);
8657 if (PyErr_Occurred()) SWIG_fail;
8658 }
8659 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFontMapper, 0);
8660 return resultobj;
8661 fail:
8662 return NULL;
8663 }
8664
8665
8666 static PyObject *_wrap_FontMapper_CharsetToEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8667 PyObject *resultobj;
8668 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8669 wxString *arg2 = 0 ;
8670 bool arg3 = (bool) true ;
8671 wxFontEncoding result;
8672 bool temp2 = false ;
8673 PyObject * obj0 = 0 ;
8674 PyObject * obj1 = 0 ;
8675 PyObject * obj2 = 0 ;
8676 char *kwnames[] = {
8677 (char *) "self",(char *) "charset",(char *) "interactive", NULL
8678 };
8679
8680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_CharsetToEncoding",kwnames,&obj0,&obj1,&obj2)) goto fail;
8681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8682 if (SWIG_arg_fail(1)) SWIG_fail;
8683 {
8684 arg2 = wxString_in_helper(obj1);
8685 if (arg2 == NULL) SWIG_fail;
8686 temp2 = true;
8687 }
8688 if (obj2) {
8689 {
8690 arg3 = (bool)(SWIG_As_bool(obj2));
8691 if (SWIG_arg_fail(3)) SWIG_fail;
8692 }
8693 }
8694 {
8695 PyThreadState* __tstate = wxPyBeginAllowThreads();
8696 result = (wxFontEncoding)(arg1)->CharsetToEncoding((wxString const &)*arg2,arg3);
8697
8698 wxPyEndAllowThreads(__tstate);
8699 if (PyErr_Occurred()) SWIG_fail;
8700 }
8701 resultobj = SWIG_From_int((result));
8702 {
8703 if (temp2)
8704 delete arg2;
8705 }
8706 return resultobj;
8707 fail:
8708 {
8709 if (temp2)
8710 delete arg2;
8711 }
8712 return NULL;
8713 }
8714
8715
8716 static PyObject *_wrap_FontMapper_GetSupportedEncodingsCount(PyObject *, PyObject *args, PyObject *kwargs) {
8717 PyObject *resultobj;
8718 size_t result;
8719 char *kwnames[] = {
8720 NULL
8721 };
8722
8723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetSupportedEncodingsCount",kwnames)) goto fail;
8724 {
8725 PyThreadState* __tstate = wxPyBeginAllowThreads();
8726 result = (size_t)wxFontMapper::GetSupportedEncodingsCount();
8727
8728 wxPyEndAllowThreads(__tstate);
8729 if (PyErr_Occurred()) SWIG_fail;
8730 }
8731 {
8732 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
8733 }
8734 return resultobj;
8735 fail:
8736 return NULL;
8737 }
8738
8739
8740 static PyObject *_wrap_FontMapper_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8741 PyObject *resultobj;
8742 size_t arg1 ;
8743 wxFontEncoding result;
8744 PyObject * obj0 = 0 ;
8745 char *kwnames[] = {
8746 (char *) "n", NULL
8747 };
8748
8749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncoding",kwnames,&obj0)) goto fail;
8750 {
8751 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8752 if (SWIG_arg_fail(1)) SWIG_fail;
8753 }
8754 {
8755 PyThreadState* __tstate = wxPyBeginAllowThreads();
8756 result = (wxFontEncoding)wxFontMapper::GetEncoding(arg1);
8757
8758 wxPyEndAllowThreads(__tstate);
8759 if (PyErr_Occurred()) SWIG_fail;
8760 }
8761 resultobj = SWIG_From_int((result));
8762 return resultobj;
8763 fail:
8764 return NULL;
8765 }
8766
8767
8768 static PyObject *_wrap_FontMapper_GetEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
8769 PyObject *resultobj;
8770 wxFontEncoding arg1 ;
8771 wxString result;
8772 PyObject * obj0 = 0 ;
8773 char *kwnames[] = {
8774 (char *) "encoding", NULL
8775 };
8776
8777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingName",kwnames,&obj0)) goto fail;
8778 {
8779 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8780 if (SWIG_arg_fail(1)) SWIG_fail;
8781 }
8782 {
8783 PyThreadState* __tstate = wxPyBeginAllowThreads();
8784 result = wxFontMapper::GetEncodingName((wxFontEncoding )arg1);
8785
8786 wxPyEndAllowThreads(__tstate);
8787 if (PyErr_Occurred()) SWIG_fail;
8788 }
8789 {
8790 #if wxUSE_UNICODE
8791 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8792 #else
8793 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8794 #endif
8795 }
8796 return resultobj;
8797 fail:
8798 return NULL;
8799 }
8800
8801
8802 static PyObject *_wrap_FontMapper_GetEncodingDescription(PyObject *, PyObject *args, PyObject *kwargs) {
8803 PyObject *resultobj;
8804 wxFontEncoding arg1 ;
8805 wxString result;
8806 PyObject * obj0 = 0 ;
8807 char *kwnames[] = {
8808 (char *) "encoding", NULL
8809 };
8810
8811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingDescription",kwnames,&obj0)) goto fail;
8812 {
8813 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
8814 if (SWIG_arg_fail(1)) SWIG_fail;
8815 }
8816 {
8817 PyThreadState* __tstate = wxPyBeginAllowThreads();
8818 result = wxFontMapper::GetEncodingDescription((wxFontEncoding )arg1);
8819
8820 wxPyEndAllowThreads(__tstate);
8821 if (PyErr_Occurred()) SWIG_fail;
8822 }
8823 {
8824 #if wxUSE_UNICODE
8825 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8826 #else
8827 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8828 #endif
8829 }
8830 return resultobj;
8831 fail:
8832 return NULL;
8833 }
8834
8835
8836 static PyObject *_wrap_FontMapper_GetEncodingFromName(PyObject *, PyObject *args, PyObject *kwargs) {
8837 PyObject *resultobj;
8838 wxString *arg1 = 0 ;
8839 wxFontEncoding result;
8840 bool temp1 = false ;
8841 PyObject * obj0 = 0 ;
8842 char *kwnames[] = {
8843 (char *) "name", NULL
8844 };
8845
8846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontMapper_GetEncodingFromName",kwnames,&obj0)) goto fail;
8847 {
8848 arg1 = wxString_in_helper(obj0);
8849 if (arg1 == NULL) SWIG_fail;
8850 temp1 = true;
8851 }
8852 {
8853 PyThreadState* __tstate = wxPyBeginAllowThreads();
8854 result = (wxFontEncoding)wxFontMapper::GetEncodingFromName((wxString const &)*arg1);
8855
8856 wxPyEndAllowThreads(__tstate);
8857 if (PyErr_Occurred()) SWIG_fail;
8858 }
8859 resultobj = SWIG_From_int((result));
8860 {
8861 if (temp1)
8862 delete arg1;
8863 }
8864 return resultobj;
8865 fail:
8866 {
8867 if (temp1)
8868 delete arg1;
8869 }
8870 return NULL;
8871 }
8872
8873
8874 static PyObject *_wrap_FontMapper_SetConfig(PyObject *, PyObject *args, PyObject *kwargs) {
8875 PyObject *resultobj;
8876 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8877 wxConfigBase *arg2 = (wxConfigBase *) 0 ;
8878 PyObject * obj0 = 0 ;
8879 PyObject * obj1 = 0 ;
8880 char *kwnames[] = {
8881 (char *) "self",(char *) "config", NULL
8882 };
8883
8884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfig",kwnames,&obj0,&obj1)) goto fail;
8885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8886 if (SWIG_arg_fail(1)) SWIG_fail;
8887 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
8888 if (SWIG_arg_fail(2)) SWIG_fail;
8889 {
8890 PyThreadState* __tstate = wxPyBeginAllowThreads();
8891 (arg1)->SetConfig(arg2);
8892
8893 wxPyEndAllowThreads(__tstate);
8894 if (PyErr_Occurred()) SWIG_fail;
8895 }
8896 Py_INCREF(Py_None); resultobj = Py_None;
8897 return resultobj;
8898 fail:
8899 return NULL;
8900 }
8901
8902
8903 static PyObject *_wrap_FontMapper_SetConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
8904 PyObject *resultobj;
8905 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8906 wxString *arg2 = 0 ;
8907 bool temp2 = false ;
8908 PyObject * obj0 = 0 ;
8909 PyObject * obj1 = 0 ;
8910 char *kwnames[] = {
8911 (char *) "self",(char *) "prefix", NULL
8912 };
8913
8914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetConfigPath",kwnames,&obj0,&obj1)) goto fail;
8915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8916 if (SWIG_arg_fail(1)) SWIG_fail;
8917 {
8918 arg2 = wxString_in_helper(obj1);
8919 if (arg2 == NULL) SWIG_fail;
8920 temp2 = true;
8921 }
8922 {
8923 PyThreadState* __tstate = wxPyBeginAllowThreads();
8924 (arg1)->SetConfigPath((wxString const &)*arg2);
8925
8926 wxPyEndAllowThreads(__tstate);
8927 if (PyErr_Occurred()) SWIG_fail;
8928 }
8929 Py_INCREF(Py_None); resultobj = Py_None;
8930 {
8931 if (temp2)
8932 delete arg2;
8933 }
8934 return resultobj;
8935 fail:
8936 {
8937 if (temp2)
8938 delete arg2;
8939 }
8940 return NULL;
8941 }
8942
8943
8944 static PyObject *_wrap_FontMapper_GetDefaultConfigPath(PyObject *, PyObject *args, PyObject *kwargs) {
8945 PyObject *resultobj;
8946 wxString result;
8947 char *kwnames[] = {
8948 NULL
8949 };
8950
8951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FontMapper_GetDefaultConfigPath",kwnames)) goto fail;
8952 {
8953 PyThreadState* __tstate = wxPyBeginAllowThreads();
8954 result = wxFontMapper::GetDefaultConfigPath();
8955
8956 wxPyEndAllowThreads(__tstate);
8957 if (PyErr_Occurred()) SWIG_fail;
8958 }
8959 {
8960 #if wxUSE_UNICODE
8961 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8962 #else
8963 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8964 #endif
8965 }
8966 return resultobj;
8967 fail:
8968 return NULL;
8969 }
8970
8971
8972 static PyObject *_wrap_FontMapper_GetAltForEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
8973 PyObject *resultobj;
8974 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
8975 wxFontEncoding arg2 ;
8976 wxString const &arg3_defvalue = wxPyEmptyString ;
8977 wxString *arg3 = (wxString *) &arg3_defvalue ;
8978 bool arg4 = (bool) true ;
8979 PyObject *result;
8980 bool temp3 = false ;
8981 PyObject * obj0 = 0 ;
8982 PyObject * obj1 = 0 ;
8983 PyObject * obj2 = 0 ;
8984 PyObject * obj3 = 0 ;
8985 char *kwnames[] = {
8986 (char *) "self",(char *) "encoding",(char *) "facename",(char *) "interactive", NULL
8987 };
8988
8989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:FontMapper_GetAltForEncoding",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
8991 if (SWIG_arg_fail(1)) SWIG_fail;
8992 {
8993 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
8994 if (SWIG_arg_fail(2)) SWIG_fail;
8995 }
8996 if (obj2) {
8997 {
8998 arg3 = wxString_in_helper(obj2);
8999 if (arg3 == NULL) SWIG_fail;
9000 temp3 = true;
9001 }
9002 }
9003 if (obj3) {
9004 {
9005 arg4 = (bool)(SWIG_As_bool(obj3));
9006 if (SWIG_arg_fail(4)) SWIG_fail;
9007 }
9008 }
9009 {
9010 PyThreadState* __tstate = wxPyBeginAllowThreads();
9011 result = (PyObject *)wxFontMapper_GetAltForEncoding(arg1,(wxFontEncoding )arg2,(wxString const &)*arg3,arg4);
9012
9013 wxPyEndAllowThreads(__tstate);
9014 if (PyErr_Occurred()) SWIG_fail;
9015 }
9016 resultobj = result;
9017 {
9018 if (temp3)
9019 delete arg3;
9020 }
9021 return resultobj;
9022 fail:
9023 {
9024 if (temp3)
9025 delete arg3;
9026 }
9027 return NULL;
9028 }
9029
9030
9031 static PyObject *_wrap_FontMapper_IsEncodingAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
9032 PyObject *resultobj;
9033 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9034 wxFontEncoding arg2 ;
9035 wxString const &arg3_defvalue = wxPyEmptyString ;
9036 wxString *arg3 = (wxString *) &arg3_defvalue ;
9037 bool result;
9038 bool temp3 = false ;
9039 PyObject * obj0 = 0 ;
9040 PyObject * obj1 = 0 ;
9041 PyObject * obj2 = 0 ;
9042 char *kwnames[] = {
9043 (char *) "self",(char *) "encoding",(char *) "facename", NULL
9044 };
9045
9046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FontMapper_IsEncodingAvailable",kwnames,&obj0,&obj1,&obj2)) goto fail;
9047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9048 if (SWIG_arg_fail(1)) SWIG_fail;
9049 {
9050 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
9051 if (SWIG_arg_fail(2)) SWIG_fail;
9052 }
9053 if (obj2) {
9054 {
9055 arg3 = wxString_in_helper(obj2);
9056 if (arg3 == NULL) SWIG_fail;
9057 temp3 = true;
9058 }
9059 }
9060 {
9061 PyThreadState* __tstate = wxPyBeginAllowThreads();
9062 result = (bool)(arg1)->IsEncodingAvailable((wxFontEncoding )arg2,(wxString const &)*arg3);
9063
9064 wxPyEndAllowThreads(__tstate);
9065 if (PyErr_Occurred()) SWIG_fail;
9066 }
9067 {
9068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9069 }
9070 {
9071 if (temp3)
9072 delete arg3;
9073 }
9074 return resultobj;
9075 fail:
9076 {
9077 if (temp3)
9078 delete arg3;
9079 }
9080 return NULL;
9081 }
9082
9083
9084 static PyObject *_wrap_FontMapper_SetDialogParent(PyObject *, PyObject *args, PyObject *kwargs) {
9085 PyObject *resultobj;
9086 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9087 wxWindow *arg2 = (wxWindow *) 0 ;
9088 PyObject * obj0 = 0 ;
9089 PyObject * obj1 = 0 ;
9090 char *kwnames[] = {
9091 (char *) "self",(char *) "parent", NULL
9092 };
9093
9094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogParent",kwnames,&obj0,&obj1)) goto fail;
9095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9096 if (SWIG_arg_fail(1)) SWIG_fail;
9097 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
9098 if (SWIG_arg_fail(2)) SWIG_fail;
9099 {
9100 PyThreadState* __tstate = wxPyBeginAllowThreads();
9101 (arg1)->SetDialogParent(arg2);
9102
9103 wxPyEndAllowThreads(__tstate);
9104 if (PyErr_Occurred()) SWIG_fail;
9105 }
9106 Py_INCREF(Py_None); resultobj = Py_None;
9107 return resultobj;
9108 fail:
9109 return NULL;
9110 }
9111
9112
9113 static PyObject *_wrap_FontMapper_SetDialogTitle(PyObject *, PyObject *args, PyObject *kwargs) {
9114 PyObject *resultobj;
9115 wxFontMapper *arg1 = (wxFontMapper *) 0 ;
9116 wxString *arg2 = 0 ;
9117 bool temp2 = false ;
9118 PyObject * obj0 = 0 ;
9119 PyObject * obj1 = 0 ;
9120 char *kwnames[] = {
9121 (char *) "self",(char *) "title", NULL
9122 };
9123
9124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontMapper_SetDialogTitle",kwnames,&obj0,&obj1)) goto fail;
9125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontMapper, SWIG_POINTER_EXCEPTION | 0);
9126 if (SWIG_arg_fail(1)) SWIG_fail;
9127 {
9128 arg2 = wxString_in_helper(obj1);
9129 if (arg2 == NULL) SWIG_fail;
9130 temp2 = true;
9131 }
9132 {
9133 PyThreadState* __tstate = wxPyBeginAllowThreads();
9134 (arg1)->SetDialogTitle((wxString const &)*arg2);
9135
9136 wxPyEndAllowThreads(__tstate);
9137 if (PyErr_Occurred()) SWIG_fail;
9138 }
9139 Py_INCREF(Py_None); resultobj = Py_None;
9140 {
9141 if (temp2)
9142 delete arg2;
9143 }
9144 return resultobj;
9145 fail:
9146 {
9147 if (temp2)
9148 delete arg2;
9149 }
9150 return NULL;
9151 }
9152
9153
9154 static PyObject * FontMapper_swigregister(PyObject *, PyObject *args) {
9155 PyObject *obj;
9156 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9157 SWIG_TypeClientData(SWIGTYPE_p_wxFontMapper, obj);
9158 Py_INCREF(obj);
9159 return Py_BuildValue((char *)"");
9160 }
9161 static PyObject *_wrap_new_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9162 PyObject *resultobj;
9163 int arg1 ;
9164 int arg2 ;
9165 int arg3 ;
9166 int arg4 ;
9167 bool arg5 = (bool) false ;
9168 wxString const &arg6_defvalue = wxPyEmptyString ;
9169 wxString *arg6 = (wxString *) &arg6_defvalue ;
9170 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9171 wxFont *result;
9172 bool temp6 = false ;
9173 PyObject * obj0 = 0 ;
9174 PyObject * obj1 = 0 ;
9175 PyObject * obj2 = 0 ;
9176 PyObject * obj3 = 0 ;
9177 PyObject * obj4 = 0 ;
9178 PyObject * obj5 = 0 ;
9179 PyObject * obj6 = 0 ;
9180 char *kwnames[] = {
9181 (char *) "pointSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "face",(char *) "encoding", NULL
9182 };
9183
9184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_Font",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9185 {
9186 arg1 = (int)(SWIG_As_int(obj0));
9187 if (SWIG_arg_fail(1)) SWIG_fail;
9188 }
9189 {
9190 arg2 = (int)(SWIG_As_int(obj1));
9191 if (SWIG_arg_fail(2)) SWIG_fail;
9192 }
9193 {
9194 arg3 = (int)(SWIG_As_int(obj2));
9195 if (SWIG_arg_fail(3)) SWIG_fail;
9196 }
9197 {
9198 arg4 = (int)(SWIG_As_int(obj3));
9199 if (SWIG_arg_fail(4)) SWIG_fail;
9200 }
9201 if (obj4) {
9202 {
9203 arg5 = (bool)(SWIG_As_bool(obj4));
9204 if (SWIG_arg_fail(5)) SWIG_fail;
9205 }
9206 }
9207 if (obj5) {
9208 {
9209 arg6 = wxString_in_helper(obj5);
9210 if (arg6 == NULL) SWIG_fail;
9211 temp6 = true;
9212 }
9213 }
9214 if (obj6) {
9215 {
9216 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
9217 if (SWIG_arg_fail(7)) SWIG_fail;
9218 }
9219 }
9220 {
9221 if (!wxPyCheckForApp()) SWIG_fail;
9222 PyThreadState* __tstate = wxPyBeginAllowThreads();
9223 result = (wxFont *)new wxFont(arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
9224
9225 wxPyEndAllowThreads(__tstate);
9226 if (PyErr_Occurred()) SWIG_fail;
9227 }
9228 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9229 {
9230 if (temp6)
9231 delete arg6;
9232 }
9233 return resultobj;
9234 fail:
9235 {
9236 if (temp6)
9237 delete arg6;
9238 }
9239 return NULL;
9240 }
9241
9242
9243 static PyObject *_wrap_delete_Font(PyObject *, PyObject *args, PyObject *kwargs) {
9244 PyObject *resultobj;
9245 wxFont *arg1 = (wxFont *) 0 ;
9246 PyObject * obj0 = 0 ;
9247 char *kwnames[] = {
9248 (char *) "self", NULL
9249 };
9250
9251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Font",kwnames,&obj0)) goto fail;
9252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9253 if (SWIG_arg_fail(1)) SWIG_fail;
9254 {
9255 PyThreadState* __tstate = wxPyBeginAllowThreads();
9256 delete arg1;
9257
9258 wxPyEndAllowThreads(__tstate);
9259 if (PyErr_Occurred()) SWIG_fail;
9260 }
9261 Py_INCREF(Py_None); resultobj = Py_None;
9262 return resultobj;
9263 fail:
9264 return NULL;
9265 }
9266
9267
9268 static PyObject *_wrap_new_FontFromNativeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9269 PyObject *resultobj;
9270 wxNativeFontInfo *arg1 = 0 ;
9271 wxFont *result;
9272 PyObject * obj0 = 0 ;
9273 char *kwnames[] = {
9274 (char *) "info", NULL
9275 };
9276
9277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfo",kwnames,&obj0)) goto fail;
9278 {
9279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
9280 if (SWIG_arg_fail(1)) SWIG_fail;
9281 if (arg1 == NULL) {
9282 SWIG_null_ref("wxNativeFontInfo");
9283 }
9284 if (SWIG_arg_fail(1)) SWIG_fail;
9285 }
9286 {
9287 if (!wxPyCheckForApp()) SWIG_fail;
9288 PyThreadState* __tstate = wxPyBeginAllowThreads();
9289 result = (wxFont *)new wxFont((wxNativeFontInfo const &)*arg1);
9290
9291 wxPyEndAllowThreads(__tstate);
9292 if (PyErr_Occurred()) SWIG_fail;
9293 }
9294 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9295 return resultobj;
9296 fail:
9297 return NULL;
9298 }
9299
9300
9301 static PyObject *_wrap_new_FontFromNativeInfoString(PyObject *, PyObject *args, PyObject *kwargs) {
9302 PyObject *resultobj;
9303 wxString *arg1 = 0 ;
9304 wxFont *result;
9305 bool temp1 = false ;
9306 PyObject * obj0 = 0 ;
9307 char *kwnames[] = {
9308 (char *) "info", NULL
9309 };
9310
9311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FontFromNativeInfoString",kwnames,&obj0)) goto fail;
9312 {
9313 arg1 = wxString_in_helper(obj0);
9314 if (arg1 == NULL) SWIG_fail;
9315 temp1 = true;
9316 }
9317 {
9318 if (!wxPyCheckForApp()) SWIG_fail;
9319 PyThreadState* __tstate = wxPyBeginAllowThreads();
9320 result = (wxFont *)new_wxFont((wxString const &)*arg1);
9321
9322 wxPyEndAllowThreads(__tstate);
9323 if (PyErr_Occurred()) SWIG_fail;
9324 }
9325 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9326 {
9327 if (temp1)
9328 delete arg1;
9329 }
9330 return resultobj;
9331 fail:
9332 {
9333 if (temp1)
9334 delete arg1;
9335 }
9336 return NULL;
9337 }
9338
9339
9340 static PyObject *_wrap_new_Font2(PyObject *, PyObject *args, PyObject *kwargs) {
9341 PyObject *resultobj;
9342 int arg1 ;
9343 wxFontFamily arg2 ;
9344 int arg3 = (int) wxFONTFLAG_DEFAULT ;
9345 wxString const &arg4_defvalue = wxPyEmptyString ;
9346 wxString *arg4 = (wxString *) &arg4_defvalue ;
9347 wxFontEncoding arg5 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9348 wxFont *result;
9349 bool temp4 = false ;
9350 PyObject * obj0 = 0 ;
9351 PyObject * obj1 = 0 ;
9352 PyObject * obj2 = 0 ;
9353 PyObject * obj3 = 0 ;
9354 PyObject * obj4 = 0 ;
9355 char *kwnames[] = {
9356 (char *) "pointSize",(char *) "family",(char *) "flags",(char *) "face",(char *) "encoding", NULL
9357 };
9358
9359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:new_Font2",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
9360 {
9361 arg1 = (int)(SWIG_As_int(obj0));
9362 if (SWIG_arg_fail(1)) SWIG_fail;
9363 }
9364 {
9365 arg2 = (wxFontFamily)(SWIG_As_int(obj1));
9366 if (SWIG_arg_fail(2)) SWIG_fail;
9367 }
9368 if (obj2) {
9369 {
9370 arg3 = (int)(SWIG_As_int(obj2));
9371 if (SWIG_arg_fail(3)) SWIG_fail;
9372 }
9373 }
9374 if (obj3) {
9375 {
9376 arg4 = wxString_in_helper(obj3);
9377 if (arg4 == NULL) SWIG_fail;
9378 temp4 = true;
9379 }
9380 }
9381 if (obj4) {
9382 {
9383 arg5 = (wxFontEncoding)(SWIG_As_int(obj4));
9384 if (SWIG_arg_fail(5)) SWIG_fail;
9385 }
9386 }
9387 {
9388 if (!wxPyCheckForApp()) SWIG_fail;
9389 PyThreadState* __tstate = wxPyBeginAllowThreads();
9390 result = (wxFont *)new_wxFont(arg1,(wxFontFamily )arg2,arg3,(wxString const &)*arg4,(wxFontEncoding )arg5);
9391
9392 wxPyEndAllowThreads(__tstate);
9393 if (PyErr_Occurred()) SWIG_fail;
9394 }
9395 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9396 {
9397 if (temp4)
9398 delete arg4;
9399 }
9400 return resultobj;
9401 fail:
9402 {
9403 if (temp4)
9404 delete arg4;
9405 }
9406 return NULL;
9407 }
9408
9409
9410 static PyObject *_wrap_new_FontFromPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
9411 PyObject *resultobj;
9412 wxSize *arg1 = 0 ;
9413 int arg2 ;
9414 int arg3 ;
9415 int arg4 ;
9416 bool arg5 = (bool) false ;
9417 wxString const &arg6_defvalue = wxEmptyString ;
9418 wxString *arg6 = (wxString *) &arg6_defvalue ;
9419 wxFontEncoding arg7 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
9420 wxFont *result;
9421 wxSize temp1 ;
9422 bool temp6 = false ;
9423 PyObject * obj0 = 0 ;
9424 PyObject * obj1 = 0 ;
9425 PyObject * obj2 = 0 ;
9426 PyObject * obj3 = 0 ;
9427 PyObject * obj4 = 0 ;
9428 PyObject * obj5 = 0 ;
9429 PyObject * obj6 = 0 ;
9430 char *kwnames[] = {
9431 (char *) "pixelSize",(char *) "family",(char *) "style",(char *) "weight",(char *) "underlined",(char *) "face",(char *) "encoding", NULL
9432 };
9433
9434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOO:new_FontFromPixelSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
9435 {
9436 arg1 = &temp1;
9437 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
9438 }
9439 {
9440 arg2 = (int)(SWIG_As_int(obj1));
9441 if (SWIG_arg_fail(2)) SWIG_fail;
9442 }
9443 {
9444 arg3 = (int)(SWIG_As_int(obj2));
9445 if (SWIG_arg_fail(3)) SWIG_fail;
9446 }
9447 {
9448 arg4 = (int)(SWIG_As_int(obj3));
9449 if (SWIG_arg_fail(4)) SWIG_fail;
9450 }
9451 if (obj4) {
9452 {
9453 arg5 = (bool)(SWIG_As_bool(obj4));
9454 if (SWIG_arg_fail(5)) SWIG_fail;
9455 }
9456 }
9457 if (obj5) {
9458 {
9459 arg6 = wxString_in_helper(obj5);
9460 if (arg6 == NULL) SWIG_fail;
9461 temp6 = true;
9462 }
9463 }
9464 if (obj6) {
9465 {
9466 arg7 = (wxFontEncoding)(SWIG_As_int(obj6));
9467 if (SWIG_arg_fail(7)) SWIG_fail;
9468 }
9469 }
9470 {
9471 if (!wxPyCheckForApp()) SWIG_fail;
9472 PyThreadState* __tstate = wxPyBeginAllowThreads();
9473 result = (wxFont *)new_wxFont((wxSize const &)*arg1,arg2,arg3,arg4,arg5,(wxString const &)*arg6,(wxFontEncoding )arg7);
9474
9475 wxPyEndAllowThreads(__tstate);
9476 if (PyErr_Occurred()) SWIG_fail;
9477 }
9478 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 1);
9479 {
9480 if (temp6)
9481 delete arg6;
9482 }
9483 return resultobj;
9484 fail:
9485 {
9486 if (temp6)
9487 delete arg6;
9488 }
9489 return NULL;
9490 }
9491
9492
9493 static PyObject *_wrap_Font_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
9494 PyObject *resultobj;
9495 wxFont *arg1 = (wxFont *) 0 ;
9496 bool result;
9497 PyObject * obj0 = 0 ;
9498 char *kwnames[] = {
9499 (char *) "self", NULL
9500 };
9501
9502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_Ok",kwnames,&obj0)) goto fail;
9503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9504 if (SWIG_arg_fail(1)) SWIG_fail;
9505 {
9506 PyThreadState* __tstate = wxPyBeginAllowThreads();
9507 result = (bool)((wxFont const *)arg1)->Ok();
9508
9509 wxPyEndAllowThreads(__tstate);
9510 if (PyErr_Occurred()) SWIG_fail;
9511 }
9512 {
9513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9514 }
9515 return resultobj;
9516 fail:
9517 return NULL;
9518 }
9519
9520
9521 static PyObject *_wrap_Font___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
9522 PyObject *resultobj;
9523 wxFont *arg1 = (wxFont *) 0 ;
9524 wxFont *arg2 = (wxFont *) 0 ;
9525 bool result;
9526 PyObject * obj0 = 0 ;
9527 PyObject * obj1 = 0 ;
9528 char *kwnames[] = {
9529 (char *) "self",(char *) "other", NULL
9530 };
9531
9532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___eq__",kwnames,&obj0,&obj1)) goto fail;
9533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9534 if (SWIG_arg_fail(1)) SWIG_fail;
9535 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9536 if (SWIG_arg_fail(2)) SWIG_fail;
9537 {
9538 PyThreadState* __tstate = wxPyBeginAllowThreads();
9539 result = (bool)wxFont___eq__(arg1,(wxFont const *)arg2);
9540
9541 wxPyEndAllowThreads(__tstate);
9542 if (PyErr_Occurred()) SWIG_fail;
9543 }
9544 {
9545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9546 }
9547 return resultobj;
9548 fail:
9549 return NULL;
9550 }
9551
9552
9553 static PyObject *_wrap_Font___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
9554 PyObject *resultobj;
9555 wxFont *arg1 = (wxFont *) 0 ;
9556 wxFont *arg2 = (wxFont *) 0 ;
9557 bool result;
9558 PyObject * obj0 = 0 ;
9559 PyObject * obj1 = 0 ;
9560 char *kwnames[] = {
9561 (char *) "self",(char *) "other", NULL
9562 };
9563
9564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font___ne__",kwnames,&obj0,&obj1)) goto fail;
9565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9566 if (SWIG_arg_fail(1)) SWIG_fail;
9567 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9568 if (SWIG_arg_fail(2)) SWIG_fail;
9569 {
9570 PyThreadState* __tstate = wxPyBeginAllowThreads();
9571 result = (bool)wxFont___ne__(arg1,(wxFont const *)arg2);
9572
9573 wxPyEndAllowThreads(__tstate);
9574 if (PyErr_Occurred()) SWIG_fail;
9575 }
9576 {
9577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9578 }
9579 return resultobj;
9580 fail:
9581 return NULL;
9582 }
9583
9584
9585 static PyObject *_wrap_Font_GetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
9586 PyObject *resultobj;
9587 wxFont *arg1 = (wxFont *) 0 ;
9588 int result;
9589 PyObject * obj0 = 0 ;
9590 char *kwnames[] = {
9591 (char *) "self", NULL
9592 };
9593
9594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPointSize",kwnames,&obj0)) goto fail;
9595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9596 if (SWIG_arg_fail(1)) SWIG_fail;
9597 {
9598 PyThreadState* __tstate = wxPyBeginAllowThreads();
9599 result = (int)((wxFont const *)arg1)->GetPointSize();
9600
9601 wxPyEndAllowThreads(__tstate);
9602 if (PyErr_Occurred()) SWIG_fail;
9603 }
9604 {
9605 resultobj = SWIG_From_int((int)(result));
9606 }
9607 return resultobj;
9608 fail:
9609 return NULL;
9610 }
9611
9612
9613 static PyObject *_wrap_Font_GetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
9614 PyObject *resultobj;
9615 wxFont *arg1 = (wxFont *) 0 ;
9616 wxSize result;
9617 PyObject * obj0 = 0 ;
9618 char *kwnames[] = {
9619 (char *) "self", NULL
9620 };
9621
9622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetPixelSize",kwnames,&obj0)) goto fail;
9623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9624 if (SWIG_arg_fail(1)) SWIG_fail;
9625 {
9626 PyThreadState* __tstate = wxPyBeginAllowThreads();
9627 result = ((wxFont const *)arg1)->GetPixelSize();
9628
9629 wxPyEndAllowThreads(__tstate);
9630 if (PyErr_Occurred()) SWIG_fail;
9631 }
9632 {
9633 wxSize * resultptr;
9634 resultptr = new wxSize((wxSize &)(result));
9635 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
9636 }
9637 return resultobj;
9638 fail:
9639 return NULL;
9640 }
9641
9642
9643 static PyObject *_wrap_Font_IsUsingSizeInPixels(PyObject *, PyObject *args, PyObject *kwargs) {
9644 PyObject *resultobj;
9645 wxFont *arg1 = (wxFont *) 0 ;
9646 bool result;
9647 PyObject * obj0 = 0 ;
9648 char *kwnames[] = {
9649 (char *) "self", NULL
9650 };
9651
9652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsUsingSizeInPixels",kwnames,&obj0)) goto fail;
9653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9654 if (SWIG_arg_fail(1)) SWIG_fail;
9655 {
9656 PyThreadState* __tstate = wxPyBeginAllowThreads();
9657 result = (bool)((wxFont const *)arg1)->IsUsingSizeInPixels();
9658
9659 wxPyEndAllowThreads(__tstate);
9660 if (PyErr_Occurred()) SWIG_fail;
9661 }
9662 {
9663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9664 }
9665 return resultobj;
9666 fail:
9667 return NULL;
9668 }
9669
9670
9671 static PyObject *_wrap_Font_GetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
9672 PyObject *resultobj;
9673 wxFont *arg1 = (wxFont *) 0 ;
9674 int result;
9675 PyObject * obj0 = 0 ;
9676 char *kwnames[] = {
9677 (char *) "self", NULL
9678 };
9679
9680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamily",kwnames,&obj0)) goto fail;
9681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9682 if (SWIG_arg_fail(1)) SWIG_fail;
9683 {
9684 PyThreadState* __tstate = wxPyBeginAllowThreads();
9685 result = (int)((wxFont const *)arg1)->GetFamily();
9686
9687 wxPyEndAllowThreads(__tstate);
9688 if (PyErr_Occurred()) SWIG_fail;
9689 }
9690 {
9691 resultobj = SWIG_From_int((int)(result));
9692 }
9693 return resultobj;
9694 fail:
9695 return NULL;
9696 }
9697
9698
9699 static PyObject *_wrap_Font_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
9700 PyObject *resultobj;
9701 wxFont *arg1 = (wxFont *) 0 ;
9702 int result;
9703 PyObject * obj0 = 0 ;
9704 char *kwnames[] = {
9705 (char *) "self", NULL
9706 };
9707
9708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyle",kwnames,&obj0)) goto fail;
9709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9710 if (SWIG_arg_fail(1)) SWIG_fail;
9711 {
9712 PyThreadState* __tstate = wxPyBeginAllowThreads();
9713 result = (int)((wxFont const *)arg1)->GetStyle();
9714
9715 wxPyEndAllowThreads(__tstate);
9716 if (PyErr_Occurred()) SWIG_fail;
9717 }
9718 {
9719 resultobj = SWIG_From_int((int)(result));
9720 }
9721 return resultobj;
9722 fail:
9723 return NULL;
9724 }
9725
9726
9727 static PyObject *_wrap_Font_GetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
9728 PyObject *resultobj;
9729 wxFont *arg1 = (wxFont *) 0 ;
9730 int result;
9731 PyObject * obj0 = 0 ;
9732 char *kwnames[] = {
9733 (char *) "self", NULL
9734 };
9735
9736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeight",kwnames,&obj0)) goto fail;
9737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9738 if (SWIG_arg_fail(1)) SWIG_fail;
9739 {
9740 PyThreadState* __tstate = wxPyBeginAllowThreads();
9741 result = (int)((wxFont const *)arg1)->GetWeight();
9742
9743 wxPyEndAllowThreads(__tstate);
9744 if (PyErr_Occurred()) SWIG_fail;
9745 }
9746 {
9747 resultobj = SWIG_From_int((int)(result));
9748 }
9749 return resultobj;
9750 fail:
9751 return NULL;
9752 }
9753
9754
9755 static PyObject *_wrap_Font_GetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
9756 PyObject *resultobj;
9757 wxFont *arg1 = (wxFont *) 0 ;
9758 bool result;
9759 PyObject * obj0 = 0 ;
9760 char *kwnames[] = {
9761 (char *) "self", NULL
9762 };
9763
9764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetUnderlined",kwnames,&obj0)) goto fail;
9765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9766 if (SWIG_arg_fail(1)) SWIG_fail;
9767 {
9768 PyThreadState* __tstate = wxPyBeginAllowThreads();
9769 result = (bool)((wxFont const *)arg1)->GetUnderlined();
9770
9771 wxPyEndAllowThreads(__tstate);
9772 if (PyErr_Occurred()) SWIG_fail;
9773 }
9774 {
9775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9776 }
9777 return resultobj;
9778 fail:
9779 return NULL;
9780 }
9781
9782
9783 static PyObject *_wrap_Font_GetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
9784 PyObject *resultobj;
9785 wxFont *arg1 = (wxFont *) 0 ;
9786 wxString result;
9787 PyObject * obj0 = 0 ;
9788 char *kwnames[] = {
9789 (char *) "self", NULL
9790 };
9791
9792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFaceName",kwnames,&obj0)) goto fail;
9793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9794 if (SWIG_arg_fail(1)) SWIG_fail;
9795 {
9796 PyThreadState* __tstate = wxPyBeginAllowThreads();
9797 result = ((wxFont const *)arg1)->GetFaceName();
9798
9799 wxPyEndAllowThreads(__tstate);
9800 if (PyErr_Occurred()) SWIG_fail;
9801 }
9802 {
9803 #if wxUSE_UNICODE
9804 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9805 #else
9806 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9807 #endif
9808 }
9809 return resultobj;
9810 fail:
9811 return NULL;
9812 }
9813
9814
9815 static PyObject *_wrap_Font_GetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
9816 PyObject *resultobj;
9817 wxFont *arg1 = (wxFont *) 0 ;
9818 wxFontEncoding result;
9819 PyObject * obj0 = 0 ;
9820 char *kwnames[] = {
9821 (char *) "self", NULL
9822 };
9823
9824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetEncoding",kwnames,&obj0)) goto fail;
9825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9826 if (SWIG_arg_fail(1)) SWIG_fail;
9827 {
9828 PyThreadState* __tstate = wxPyBeginAllowThreads();
9829 result = (wxFontEncoding)((wxFont const *)arg1)->GetEncoding();
9830
9831 wxPyEndAllowThreads(__tstate);
9832 if (PyErr_Occurred()) SWIG_fail;
9833 }
9834 resultobj = SWIG_From_int((result));
9835 return resultobj;
9836 fail:
9837 return NULL;
9838 }
9839
9840
9841 static PyObject *_wrap_Font_GetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9842 PyObject *resultobj;
9843 wxFont *arg1 = (wxFont *) 0 ;
9844 wxNativeFontInfo *result;
9845 PyObject * obj0 = 0 ;
9846 char *kwnames[] = {
9847 (char *) "self", NULL
9848 };
9849
9850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfo",kwnames,&obj0)) goto fail;
9851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9852 if (SWIG_arg_fail(1)) SWIG_fail;
9853 {
9854 PyThreadState* __tstate = wxPyBeginAllowThreads();
9855 result = (wxNativeFontInfo *)((wxFont const *)arg1)->GetNativeFontInfo();
9856
9857 wxPyEndAllowThreads(__tstate);
9858 if (PyErr_Occurred()) SWIG_fail;
9859 }
9860 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNativeFontInfo, 0);
9861 return resultobj;
9862 fail:
9863 return NULL;
9864 }
9865
9866
9867 static PyObject *_wrap_Font_IsFixedWidth(PyObject *, PyObject *args, PyObject *kwargs) {
9868 PyObject *resultobj;
9869 wxFont *arg1 = (wxFont *) 0 ;
9870 bool result;
9871 PyObject * obj0 = 0 ;
9872 char *kwnames[] = {
9873 (char *) "self", NULL
9874 };
9875
9876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_IsFixedWidth",kwnames,&obj0)) goto fail;
9877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9878 if (SWIG_arg_fail(1)) SWIG_fail;
9879 {
9880 PyThreadState* __tstate = wxPyBeginAllowThreads();
9881 result = (bool)((wxFont const *)arg1)->IsFixedWidth();
9882
9883 wxPyEndAllowThreads(__tstate);
9884 if (PyErr_Occurred()) SWIG_fail;
9885 }
9886 {
9887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9888 }
9889 return resultobj;
9890 fail:
9891 return NULL;
9892 }
9893
9894
9895 static PyObject *_wrap_Font_GetNativeFontInfoDesc(PyObject *, PyObject *args, PyObject *kwargs) {
9896 PyObject *resultobj;
9897 wxFont *arg1 = (wxFont *) 0 ;
9898 wxString result;
9899 PyObject * obj0 = 0 ;
9900 char *kwnames[] = {
9901 (char *) "self", NULL
9902 };
9903
9904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoDesc",kwnames,&obj0)) goto fail;
9905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9906 if (SWIG_arg_fail(1)) SWIG_fail;
9907 {
9908 PyThreadState* __tstate = wxPyBeginAllowThreads();
9909 result = ((wxFont const *)arg1)->GetNativeFontInfoDesc();
9910
9911 wxPyEndAllowThreads(__tstate);
9912 if (PyErr_Occurred()) SWIG_fail;
9913 }
9914 {
9915 #if wxUSE_UNICODE
9916 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9917 #else
9918 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9919 #endif
9920 }
9921 return resultobj;
9922 fail:
9923 return NULL;
9924 }
9925
9926
9927 static PyObject *_wrap_Font_GetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
9928 PyObject *resultobj;
9929 wxFont *arg1 = (wxFont *) 0 ;
9930 wxString result;
9931 PyObject * obj0 = 0 ;
9932 char *kwnames[] = {
9933 (char *) "self", NULL
9934 };
9935
9936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNativeFontInfoUserDesc",kwnames,&obj0)) goto fail;
9937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9938 if (SWIG_arg_fail(1)) SWIG_fail;
9939 {
9940 PyThreadState* __tstate = wxPyBeginAllowThreads();
9941 result = ((wxFont const *)arg1)->GetNativeFontInfoUserDesc();
9942
9943 wxPyEndAllowThreads(__tstate);
9944 if (PyErr_Occurred()) SWIG_fail;
9945 }
9946 {
9947 #if wxUSE_UNICODE
9948 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9949 #else
9950 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9951 #endif
9952 }
9953 return resultobj;
9954 fail:
9955 return NULL;
9956 }
9957
9958
9959 static PyObject *_wrap_Font_SetPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
9960 PyObject *resultobj;
9961 wxFont *arg1 = (wxFont *) 0 ;
9962 int arg2 ;
9963 PyObject * obj0 = 0 ;
9964 PyObject * obj1 = 0 ;
9965 char *kwnames[] = {
9966 (char *) "self",(char *) "pointSize", NULL
9967 };
9968
9969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPointSize",kwnames,&obj0,&obj1)) goto fail;
9970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
9971 if (SWIG_arg_fail(1)) SWIG_fail;
9972 {
9973 arg2 = (int)(SWIG_As_int(obj1));
9974 if (SWIG_arg_fail(2)) SWIG_fail;
9975 }
9976 {
9977 PyThreadState* __tstate = wxPyBeginAllowThreads();
9978 (arg1)->SetPointSize(arg2);
9979
9980 wxPyEndAllowThreads(__tstate);
9981 if (PyErr_Occurred()) SWIG_fail;
9982 }
9983 Py_INCREF(Py_None); resultobj = Py_None;
9984 return resultobj;
9985 fail:
9986 return NULL;
9987 }
9988
9989
9990 static PyObject *_wrap_Font_SetPixelSize(PyObject *, PyObject *args, PyObject *kwargs) {
9991 PyObject *resultobj;
9992 wxFont *arg1 = (wxFont *) 0 ;
9993 wxSize *arg2 = 0 ;
9994 wxSize temp2 ;
9995 PyObject * obj0 = 0 ;
9996 PyObject * obj1 = 0 ;
9997 char *kwnames[] = {
9998 (char *) "self",(char *) "pixelSize", NULL
9999 };
10000
10001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetPixelSize",kwnames,&obj0,&obj1)) goto fail;
10002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10003 if (SWIG_arg_fail(1)) SWIG_fail;
10004 {
10005 arg2 = &temp2;
10006 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
10007 }
10008 {
10009 PyThreadState* __tstate = wxPyBeginAllowThreads();
10010 (arg1)->SetPixelSize((wxSize const &)*arg2);
10011
10012 wxPyEndAllowThreads(__tstate);
10013 if (PyErr_Occurred()) SWIG_fail;
10014 }
10015 Py_INCREF(Py_None); resultobj = Py_None;
10016 return resultobj;
10017 fail:
10018 return NULL;
10019 }
10020
10021
10022 static PyObject *_wrap_Font_SetFamily(PyObject *, PyObject *args, PyObject *kwargs) {
10023 PyObject *resultobj;
10024 wxFont *arg1 = (wxFont *) 0 ;
10025 int arg2 ;
10026 PyObject * obj0 = 0 ;
10027 PyObject * obj1 = 0 ;
10028 char *kwnames[] = {
10029 (char *) "self",(char *) "family", NULL
10030 };
10031
10032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFamily",kwnames,&obj0,&obj1)) goto fail;
10033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10034 if (SWIG_arg_fail(1)) SWIG_fail;
10035 {
10036 arg2 = (int)(SWIG_As_int(obj1));
10037 if (SWIG_arg_fail(2)) SWIG_fail;
10038 }
10039 {
10040 PyThreadState* __tstate = wxPyBeginAllowThreads();
10041 (arg1)->SetFamily(arg2);
10042
10043 wxPyEndAllowThreads(__tstate);
10044 if (PyErr_Occurred()) SWIG_fail;
10045 }
10046 Py_INCREF(Py_None); resultobj = Py_None;
10047 return resultobj;
10048 fail:
10049 return NULL;
10050 }
10051
10052
10053 static PyObject *_wrap_Font_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
10054 PyObject *resultobj;
10055 wxFont *arg1 = (wxFont *) 0 ;
10056 int arg2 ;
10057 PyObject * obj0 = 0 ;
10058 PyObject * obj1 = 0 ;
10059 char *kwnames[] = {
10060 (char *) "self",(char *) "style", NULL
10061 };
10062
10063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetStyle",kwnames,&obj0,&obj1)) goto fail;
10064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10065 if (SWIG_arg_fail(1)) SWIG_fail;
10066 {
10067 arg2 = (int)(SWIG_As_int(obj1));
10068 if (SWIG_arg_fail(2)) SWIG_fail;
10069 }
10070 {
10071 PyThreadState* __tstate = wxPyBeginAllowThreads();
10072 (arg1)->SetStyle(arg2);
10073
10074 wxPyEndAllowThreads(__tstate);
10075 if (PyErr_Occurred()) SWIG_fail;
10076 }
10077 Py_INCREF(Py_None); resultobj = Py_None;
10078 return resultobj;
10079 fail:
10080 return NULL;
10081 }
10082
10083
10084 static PyObject *_wrap_Font_SetWeight(PyObject *, PyObject *args, PyObject *kwargs) {
10085 PyObject *resultobj;
10086 wxFont *arg1 = (wxFont *) 0 ;
10087 int arg2 ;
10088 PyObject * obj0 = 0 ;
10089 PyObject * obj1 = 0 ;
10090 char *kwnames[] = {
10091 (char *) "self",(char *) "weight", NULL
10092 };
10093
10094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetWeight",kwnames,&obj0,&obj1)) goto fail;
10095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10096 if (SWIG_arg_fail(1)) SWIG_fail;
10097 {
10098 arg2 = (int)(SWIG_As_int(obj1));
10099 if (SWIG_arg_fail(2)) SWIG_fail;
10100 }
10101 {
10102 PyThreadState* __tstate = wxPyBeginAllowThreads();
10103 (arg1)->SetWeight(arg2);
10104
10105 wxPyEndAllowThreads(__tstate);
10106 if (PyErr_Occurred()) SWIG_fail;
10107 }
10108 Py_INCREF(Py_None); resultobj = Py_None;
10109 return resultobj;
10110 fail:
10111 return NULL;
10112 }
10113
10114
10115 static PyObject *_wrap_Font_SetFaceName(PyObject *, PyObject *args, PyObject *kwargs) {
10116 PyObject *resultobj;
10117 wxFont *arg1 = (wxFont *) 0 ;
10118 wxString *arg2 = 0 ;
10119 bool temp2 = false ;
10120 PyObject * obj0 = 0 ;
10121 PyObject * obj1 = 0 ;
10122 char *kwnames[] = {
10123 (char *) "self",(char *) "faceName", NULL
10124 };
10125
10126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetFaceName",kwnames,&obj0,&obj1)) goto fail;
10127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10128 if (SWIG_arg_fail(1)) SWIG_fail;
10129 {
10130 arg2 = wxString_in_helper(obj1);
10131 if (arg2 == NULL) SWIG_fail;
10132 temp2 = true;
10133 }
10134 {
10135 PyThreadState* __tstate = wxPyBeginAllowThreads();
10136 (arg1)->SetFaceName((wxString const &)*arg2);
10137
10138 wxPyEndAllowThreads(__tstate);
10139 if (PyErr_Occurred()) SWIG_fail;
10140 }
10141 Py_INCREF(Py_None); resultobj = Py_None;
10142 {
10143 if (temp2)
10144 delete arg2;
10145 }
10146 return resultobj;
10147 fail:
10148 {
10149 if (temp2)
10150 delete arg2;
10151 }
10152 return NULL;
10153 }
10154
10155
10156 static PyObject *_wrap_Font_SetUnderlined(PyObject *, PyObject *args, PyObject *kwargs) {
10157 PyObject *resultobj;
10158 wxFont *arg1 = (wxFont *) 0 ;
10159 bool arg2 ;
10160 PyObject * obj0 = 0 ;
10161 PyObject * obj1 = 0 ;
10162 char *kwnames[] = {
10163 (char *) "self",(char *) "underlined", NULL
10164 };
10165
10166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetUnderlined",kwnames,&obj0,&obj1)) goto fail;
10167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10168 if (SWIG_arg_fail(1)) SWIG_fail;
10169 {
10170 arg2 = (bool)(SWIG_As_bool(obj1));
10171 if (SWIG_arg_fail(2)) SWIG_fail;
10172 }
10173 {
10174 PyThreadState* __tstate = wxPyBeginAllowThreads();
10175 (arg1)->SetUnderlined(arg2);
10176
10177 wxPyEndAllowThreads(__tstate);
10178 if (PyErr_Occurred()) SWIG_fail;
10179 }
10180 Py_INCREF(Py_None); resultobj = Py_None;
10181 return resultobj;
10182 fail:
10183 return NULL;
10184 }
10185
10186
10187 static PyObject *_wrap_Font_SetEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10188 PyObject *resultobj;
10189 wxFont *arg1 = (wxFont *) 0 ;
10190 wxFontEncoding arg2 ;
10191 PyObject * obj0 = 0 ;
10192 PyObject * obj1 = 0 ;
10193 char *kwnames[] = {
10194 (char *) "self",(char *) "encoding", NULL
10195 };
10196
10197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetEncoding",kwnames,&obj0,&obj1)) goto fail;
10198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10199 if (SWIG_arg_fail(1)) SWIG_fail;
10200 {
10201 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
10202 if (SWIG_arg_fail(2)) SWIG_fail;
10203 }
10204 {
10205 PyThreadState* __tstate = wxPyBeginAllowThreads();
10206 (arg1)->SetEncoding((wxFontEncoding )arg2);
10207
10208 wxPyEndAllowThreads(__tstate);
10209 if (PyErr_Occurred()) SWIG_fail;
10210 }
10211 Py_INCREF(Py_None); resultobj = Py_None;
10212 return resultobj;
10213 fail:
10214 return NULL;
10215 }
10216
10217
10218 static PyObject *_wrap_Font_SetNativeFontInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10219 PyObject *resultobj;
10220 wxFont *arg1 = (wxFont *) 0 ;
10221 wxNativeFontInfo *arg2 = 0 ;
10222 PyObject * obj0 = 0 ;
10223 PyObject * obj1 = 0 ;
10224 char *kwnames[] = {
10225 (char *) "self",(char *) "info", NULL
10226 };
10227
10228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfo",kwnames,&obj0,&obj1)) goto fail;
10229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10230 if (SWIG_arg_fail(1)) SWIG_fail;
10231 {
10232 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxNativeFontInfo, SWIG_POINTER_EXCEPTION | 0);
10233 if (SWIG_arg_fail(2)) SWIG_fail;
10234 if (arg2 == NULL) {
10235 SWIG_null_ref("wxNativeFontInfo");
10236 }
10237 if (SWIG_arg_fail(2)) SWIG_fail;
10238 }
10239 {
10240 PyThreadState* __tstate = wxPyBeginAllowThreads();
10241 (arg1)->SetNativeFontInfo((wxNativeFontInfo const &)*arg2);
10242
10243 wxPyEndAllowThreads(__tstate);
10244 if (PyErr_Occurred()) SWIG_fail;
10245 }
10246 Py_INCREF(Py_None); resultobj = Py_None;
10247 return resultobj;
10248 fail:
10249 return NULL;
10250 }
10251
10252
10253 static PyObject *_wrap_Font_SetNativeFontInfoFromString(PyObject *, PyObject *args, PyObject *kwargs) {
10254 PyObject *resultobj;
10255 wxFont *arg1 = (wxFont *) 0 ;
10256 wxString *arg2 = 0 ;
10257 bool temp2 = false ;
10258 PyObject * obj0 = 0 ;
10259 PyObject * obj1 = 0 ;
10260 char *kwnames[] = {
10261 (char *) "self",(char *) "info", NULL
10262 };
10263
10264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoFromString",kwnames,&obj0,&obj1)) goto fail;
10265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10266 if (SWIG_arg_fail(1)) SWIG_fail;
10267 {
10268 arg2 = wxString_in_helper(obj1);
10269 if (arg2 == NULL) SWIG_fail;
10270 temp2 = true;
10271 }
10272 {
10273 PyThreadState* __tstate = wxPyBeginAllowThreads();
10274 (arg1)->SetNativeFontInfo((wxString const &)*arg2);
10275
10276 wxPyEndAllowThreads(__tstate);
10277 if (PyErr_Occurred()) SWIG_fail;
10278 }
10279 Py_INCREF(Py_None); resultobj = Py_None;
10280 {
10281 if (temp2)
10282 delete arg2;
10283 }
10284 return resultobj;
10285 fail:
10286 {
10287 if (temp2)
10288 delete arg2;
10289 }
10290 return NULL;
10291 }
10292
10293
10294 static PyObject *_wrap_Font_SetNativeFontInfoUserDesc(PyObject *, PyObject *args, PyObject *kwargs) {
10295 PyObject *resultobj;
10296 wxFont *arg1 = (wxFont *) 0 ;
10297 wxString *arg2 = 0 ;
10298 bool temp2 = false ;
10299 PyObject * obj0 = 0 ;
10300 PyObject * obj1 = 0 ;
10301 char *kwnames[] = {
10302 (char *) "self",(char *) "info", NULL
10303 };
10304
10305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Font_SetNativeFontInfoUserDesc",kwnames,&obj0,&obj1)) goto fail;
10306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10307 if (SWIG_arg_fail(1)) SWIG_fail;
10308 {
10309 arg2 = wxString_in_helper(obj1);
10310 if (arg2 == NULL) SWIG_fail;
10311 temp2 = true;
10312 }
10313 {
10314 PyThreadState* __tstate = wxPyBeginAllowThreads();
10315 (arg1)->SetNativeFontInfoUserDesc((wxString const &)*arg2);
10316
10317 wxPyEndAllowThreads(__tstate);
10318 if (PyErr_Occurred()) SWIG_fail;
10319 }
10320 Py_INCREF(Py_None); resultobj = Py_None;
10321 {
10322 if (temp2)
10323 delete arg2;
10324 }
10325 return resultobj;
10326 fail:
10327 {
10328 if (temp2)
10329 delete arg2;
10330 }
10331 return NULL;
10332 }
10333
10334
10335 static PyObject *_wrap_Font_GetFamilyString(PyObject *, PyObject *args, PyObject *kwargs) {
10336 PyObject *resultobj;
10337 wxFont *arg1 = (wxFont *) 0 ;
10338 wxString result;
10339 PyObject * obj0 = 0 ;
10340 char *kwnames[] = {
10341 (char *) "self", NULL
10342 };
10343
10344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetFamilyString",kwnames,&obj0)) goto fail;
10345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10346 if (SWIG_arg_fail(1)) SWIG_fail;
10347 {
10348 PyThreadState* __tstate = wxPyBeginAllowThreads();
10349 result = ((wxFont const *)arg1)->GetFamilyString();
10350
10351 wxPyEndAllowThreads(__tstate);
10352 if (PyErr_Occurred()) SWIG_fail;
10353 }
10354 {
10355 #if wxUSE_UNICODE
10356 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10357 #else
10358 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10359 #endif
10360 }
10361 return resultobj;
10362 fail:
10363 return NULL;
10364 }
10365
10366
10367 static PyObject *_wrap_Font_GetStyleString(PyObject *, PyObject *args, PyObject *kwargs) {
10368 PyObject *resultobj;
10369 wxFont *arg1 = (wxFont *) 0 ;
10370 wxString result;
10371 PyObject * obj0 = 0 ;
10372 char *kwnames[] = {
10373 (char *) "self", NULL
10374 };
10375
10376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetStyleString",kwnames,&obj0)) goto fail;
10377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10378 if (SWIG_arg_fail(1)) SWIG_fail;
10379 {
10380 PyThreadState* __tstate = wxPyBeginAllowThreads();
10381 result = ((wxFont const *)arg1)->GetStyleString();
10382
10383 wxPyEndAllowThreads(__tstate);
10384 if (PyErr_Occurred()) SWIG_fail;
10385 }
10386 {
10387 #if wxUSE_UNICODE
10388 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10389 #else
10390 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10391 #endif
10392 }
10393 return resultobj;
10394 fail:
10395 return NULL;
10396 }
10397
10398
10399 static PyObject *_wrap_Font_GetWeightString(PyObject *, PyObject *args, PyObject *kwargs) {
10400 PyObject *resultobj;
10401 wxFont *arg1 = (wxFont *) 0 ;
10402 wxString result;
10403 PyObject * obj0 = 0 ;
10404 char *kwnames[] = {
10405 (char *) "self", NULL
10406 };
10407
10408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetWeightString",kwnames,&obj0)) goto fail;
10409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10410 if (SWIG_arg_fail(1)) SWIG_fail;
10411 {
10412 PyThreadState* __tstate = wxPyBeginAllowThreads();
10413 result = ((wxFont const *)arg1)->GetWeightString();
10414
10415 wxPyEndAllowThreads(__tstate);
10416 if (PyErr_Occurred()) SWIG_fail;
10417 }
10418 {
10419 #if wxUSE_UNICODE
10420 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10421 #else
10422 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10423 #endif
10424 }
10425 return resultobj;
10426 fail:
10427 return NULL;
10428 }
10429
10430
10431 static PyObject *_wrap_Font_SetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
10432 PyObject *resultobj;
10433 wxFont *arg1 = (wxFont *) 0 ;
10434 bool arg2 = (bool) true ;
10435 PyObject * obj0 = 0 ;
10436 PyObject * obj1 = 0 ;
10437 char *kwnames[] = {
10438 (char *) "self",(char *) "no", NULL
10439 };
10440
10441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Font_SetNoAntiAliasing",kwnames,&obj0,&obj1)) goto fail;
10442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10443 if (SWIG_arg_fail(1)) SWIG_fail;
10444 if (obj1) {
10445 {
10446 arg2 = (bool)(SWIG_As_bool(obj1));
10447 if (SWIG_arg_fail(2)) SWIG_fail;
10448 }
10449 }
10450 {
10451 PyThreadState* __tstate = wxPyBeginAllowThreads();
10452 (arg1)->SetNoAntiAliasing(arg2);
10453
10454 wxPyEndAllowThreads(__tstate);
10455 if (PyErr_Occurred()) SWIG_fail;
10456 }
10457 Py_INCREF(Py_None); resultobj = Py_None;
10458 return resultobj;
10459 fail:
10460 return NULL;
10461 }
10462
10463
10464 static PyObject *_wrap_Font_GetNoAntiAliasing(PyObject *, PyObject *args, PyObject *kwargs) {
10465 PyObject *resultobj;
10466 wxFont *arg1 = (wxFont *) 0 ;
10467 bool result;
10468 PyObject * obj0 = 0 ;
10469 char *kwnames[] = {
10470 (char *) "self", NULL
10471 };
10472
10473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_GetNoAntiAliasing",kwnames,&obj0)) goto fail;
10474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
10475 if (SWIG_arg_fail(1)) SWIG_fail;
10476 {
10477 PyThreadState* __tstate = wxPyBeginAllowThreads();
10478 result = (bool)((wxFont const *)arg1)->GetNoAntiAliasing();
10479
10480 wxPyEndAllowThreads(__tstate);
10481 if (PyErr_Occurred()) SWIG_fail;
10482 }
10483 {
10484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10485 }
10486 return resultobj;
10487 fail:
10488 return NULL;
10489 }
10490
10491
10492 static PyObject *_wrap_Font_GetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10493 PyObject *resultobj;
10494 wxFontEncoding result;
10495 char *kwnames[] = {
10496 NULL
10497 };
10498
10499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Font_GetDefaultEncoding",kwnames)) goto fail;
10500 {
10501 if (!wxPyCheckForApp()) SWIG_fail;
10502 PyThreadState* __tstate = wxPyBeginAllowThreads();
10503 result = (wxFontEncoding)wxFont::GetDefaultEncoding();
10504
10505 wxPyEndAllowThreads(__tstate);
10506 if (PyErr_Occurred()) SWIG_fail;
10507 }
10508 resultobj = SWIG_From_int((result));
10509 return resultobj;
10510 fail:
10511 return NULL;
10512 }
10513
10514
10515 static PyObject *_wrap_Font_SetDefaultEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
10516 PyObject *resultobj;
10517 wxFontEncoding arg1 ;
10518 PyObject * obj0 = 0 ;
10519 char *kwnames[] = {
10520 (char *) "encoding", NULL
10521 };
10522
10523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Font_SetDefaultEncoding",kwnames,&obj0)) goto fail;
10524 {
10525 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
10526 if (SWIG_arg_fail(1)) SWIG_fail;
10527 }
10528 {
10529 if (!wxPyCheckForApp()) SWIG_fail;
10530 PyThreadState* __tstate = wxPyBeginAllowThreads();
10531 wxFont::SetDefaultEncoding((wxFontEncoding )arg1);
10532
10533 wxPyEndAllowThreads(__tstate);
10534 if (PyErr_Occurred()) SWIG_fail;
10535 }
10536 Py_INCREF(Py_None); resultobj = Py_None;
10537 return resultobj;
10538 fail:
10539 return NULL;
10540 }
10541
10542
10543 static PyObject * Font_swigregister(PyObject *, PyObject *args) {
10544 PyObject *obj;
10545 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10546 SWIG_TypeClientData(SWIGTYPE_p_wxFont, obj);
10547 Py_INCREF(obj);
10548 return Py_BuildValue((char *)"");
10549 }
10550 static PyObject *_wrap_new_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
10551 PyObject *resultobj;
10552 wxPyFontEnumerator *result;
10553 char *kwnames[] = {
10554 NULL
10555 };
10556
10557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FontEnumerator",kwnames)) goto fail;
10558 {
10559 if (!wxPyCheckForApp()) SWIG_fail;
10560 PyThreadState* __tstate = wxPyBeginAllowThreads();
10561 result = (wxPyFontEnumerator *)new wxPyFontEnumerator();
10562
10563 wxPyEndAllowThreads(__tstate);
10564 if (PyErr_Occurred()) SWIG_fail;
10565 }
10566 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFontEnumerator, 1);
10567 return resultobj;
10568 fail:
10569 return NULL;
10570 }
10571
10572
10573 static PyObject *_wrap_delete_FontEnumerator(PyObject *, PyObject *args, PyObject *kwargs) {
10574 PyObject *resultobj;
10575 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10576 PyObject * obj0 = 0 ;
10577 char *kwnames[] = {
10578 (char *) "self", NULL
10579 };
10580
10581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FontEnumerator",kwnames,&obj0)) goto fail;
10582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10583 if (SWIG_arg_fail(1)) SWIG_fail;
10584 {
10585 PyThreadState* __tstate = wxPyBeginAllowThreads();
10586 delete arg1;
10587
10588 wxPyEndAllowThreads(__tstate);
10589 if (PyErr_Occurred()) SWIG_fail;
10590 }
10591 Py_INCREF(Py_None); resultobj = Py_None;
10592 return resultobj;
10593 fail:
10594 return NULL;
10595 }
10596
10597
10598 static PyObject *_wrap_FontEnumerator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10599 PyObject *resultobj;
10600 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10601 PyObject *arg2 = (PyObject *) 0 ;
10602 PyObject *arg3 = (PyObject *) 0 ;
10603 bool arg4 ;
10604 PyObject * obj0 = 0 ;
10605 PyObject * obj1 = 0 ;
10606 PyObject * obj2 = 0 ;
10607 PyObject * obj3 = 0 ;
10608 char *kwnames[] = {
10609 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
10610 };
10611
10612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FontEnumerator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10614 if (SWIG_arg_fail(1)) SWIG_fail;
10615 arg2 = obj1;
10616 arg3 = obj2;
10617 {
10618 arg4 = (bool)(SWIG_As_bool(obj3));
10619 if (SWIG_arg_fail(4)) SWIG_fail;
10620 }
10621 {
10622 PyThreadState* __tstate = wxPyBeginAllowThreads();
10623 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
10624
10625 wxPyEndAllowThreads(__tstate);
10626 if (PyErr_Occurred()) SWIG_fail;
10627 }
10628 Py_INCREF(Py_None); resultobj = Py_None;
10629 return resultobj;
10630 fail:
10631 return NULL;
10632 }
10633
10634
10635 static PyObject *_wrap_FontEnumerator_EnumerateFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
10636 PyObject *resultobj;
10637 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10638 wxFontEncoding arg2 = (wxFontEncoding) wxFONTENCODING_SYSTEM ;
10639 bool arg3 = (bool) false ;
10640 bool result;
10641 PyObject * obj0 = 0 ;
10642 PyObject * obj1 = 0 ;
10643 PyObject * obj2 = 0 ;
10644 char *kwnames[] = {
10645 (char *) "self",(char *) "encoding",(char *) "fixedWidthOnly", NULL
10646 };
10647
10648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FontEnumerator_EnumerateFacenames",kwnames,&obj0,&obj1,&obj2)) goto fail;
10649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10650 if (SWIG_arg_fail(1)) SWIG_fail;
10651 if (obj1) {
10652 {
10653 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
10654 if (SWIG_arg_fail(2)) SWIG_fail;
10655 }
10656 }
10657 if (obj2) {
10658 {
10659 arg3 = (bool)(SWIG_As_bool(obj2));
10660 if (SWIG_arg_fail(3)) SWIG_fail;
10661 }
10662 }
10663 {
10664 PyThreadState* __tstate = wxPyBeginAllowThreads();
10665 result = (bool)(arg1)->EnumerateFacenames((wxFontEncoding )arg2,arg3);
10666
10667 wxPyEndAllowThreads(__tstate);
10668 if (PyErr_Occurred()) SWIG_fail;
10669 }
10670 {
10671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10672 }
10673 return resultobj;
10674 fail:
10675 return NULL;
10676 }
10677
10678
10679 static PyObject *_wrap_FontEnumerator_EnumerateEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
10680 PyObject *resultobj;
10681 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10682 wxString const &arg2_defvalue = wxPyEmptyString ;
10683 wxString *arg2 = (wxString *) &arg2_defvalue ;
10684 bool result;
10685 bool temp2 = false ;
10686 PyObject * obj0 = 0 ;
10687 PyObject * obj1 = 0 ;
10688 char *kwnames[] = {
10689 (char *) "self",(char *) "facename", NULL
10690 };
10691
10692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FontEnumerator_EnumerateEncodings",kwnames,&obj0,&obj1)) goto fail;
10693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10694 if (SWIG_arg_fail(1)) SWIG_fail;
10695 if (obj1) {
10696 {
10697 arg2 = wxString_in_helper(obj1);
10698 if (arg2 == NULL) SWIG_fail;
10699 temp2 = true;
10700 }
10701 }
10702 {
10703 PyThreadState* __tstate = wxPyBeginAllowThreads();
10704 result = (bool)(arg1)->EnumerateEncodings((wxString const &)*arg2);
10705
10706 wxPyEndAllowThreads(__tstate);
10707 if (PyErr_Occurred()) SWIG_fail;
10708 }
10709 {
10710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10711 }
10712 {
10713 if (temp2)
10714 delete arg2;
10715 }
10716 return resultobj;
10717 fail:
10718 {
10719 if (temp2)
10720 delete arg2;
10721 }
10722 return NULL;
10723 }
10724
10725
10726 static PyObject *_wrap_FontEnumerator_GetEncodings(PyObject *, PyObject *args, PyObject *kwargs) {
10727 PyObject *resultobj;
10728 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10729 PyObject *result;
10730 PyObject * obj0 = 0 ;
10731 char *kwnames[] = {
10732 (char *) "self", NULL
10733 };
10734
10735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetEncodings",kwnames,&obj0)) goto fail;
10736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10737 if (SWIG_arg_fail(1)) SWIG_fail;
10738 {
10739 PyThreadState* __tstate = wxPyBeginAllowThreads();
10740 result = (PyObject *)wxPyFontEnumerator_GetEncodings(arg1);
10741
10742 wxPyEndAllowThreads(__tstate);
10743 if (PyErr_Occurred()) SWIG_fail;
10744 }
10745 resultobj = result;
10746 return resultobj;
10747 fail:
10748 return NULL;
10749 }
10750
10751
10752 static PyObject *_wrap_FontEnumerator_GetFacenames(PyObject *, PyObject *args, PyObject *kwargs) {
10753 PyObject *resultobj;
10754 wxPyFontEnumerator *arg1 = (wxPyFontEnumerator *) 0 ;
10755 PyObject *result;
10756 PyObject * obj0 = 0 ;
10757 char *kwnames[] = {
10758 (char *) "self", NULL
10759 };
10760
10761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontEnumerator_GetFacenames",kwnames,&obj0)) goto fail;
10762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFontEnumerator, SWIG_POINTER_EXCEPTION | 0);
10763 if (SWIG_arg_fail(1)) SWIG_fail;
10764 {
10765 PyThreadState* __tstate = wxPyBeginAllowThreads();
10766 result = (PyObject *)wxPyFontEnumerator_GetFacenames(arg1);
10767
10768 wxPyEndAllowThreads(__tstate);
10769 if (PyErr_Occurred()) SWIG_fail;
10770 }
10771 resultobj = result;
10772 return resultobj;
10773 fail:
10774 return NULL;
10775 }
10776
10777
10778 static PyObject * FontEnumerator_swigregister(PyObject *, PyObject *args) {
10779 PyObject *obj;
10780 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10781 SWIG_TypeClientData(SWIGTYPE_p_wxPyFontEnumerator, obj);
10782 Py_INCREF(obj);
10783 return Py_BuildValue((char *)"");
10784 }
10785 static PyObject *_wrap_LanguageInfo_Language_set(PyObject *, PyObject *args, PyObject *kwargs) {
10786 PyObject *resultobj;
10787 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10788 int arg2 ;
10789 PyObject * obj0 = 0 ;
10790 PyObject * obj1 = 0 ;
10791 char *kwnames[] = {
10792 (char *) "self",(char *) "Language", NULL
10793 };
10794
10795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Language_set",kwnames,&obj0,&obj1)) goto fail;
10796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10797 if (SWIG_arg_fail(1)) SWIG_fail;
10798 {
10799 arg2 = (int)(SWIG_As_int(obj1));
10800 if (SWIG_arg_fail(2)) SWIG_fail;
10801 }
10802 if (arg1) (arg1)->Language = arg2;
10803
10804 Py_INCREF(Py_None); resultobj = Py_None;
10805 return resultobj;
10806 fail:
10807 return NULL;
10808 }
10809
10810
10811 static PyObject *_wrap_LanguageInfo_Language_get(PyObject *, PyObject *args, PyObject *kwargs) {
10812 PyObject *resultobj;
10813 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10814 int result;
10815 PyObject * obj0 = 0 ;
10816 char *kwnames[] = {
10817 (char *) "self", NULL
10818 };
10819
10820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Language_get",kwnames,&obj0)) goto fail;
10821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10822 if (SWIG_arg_fail(1)) SWIG_fail;
10823 result = (int) ((arg1)->Language);
10824
10825 {
10826 resultobj = SWIG_From_int((int)(result));
10827 }
10828 return resultobj;
10829 fail:
10830 return NULL;
10831 }
10832
10833
10834 static PyObject *_wrap_LanguageInfo_CanonicalName_set(PyObject *, PyObject *args, PyObject *kwargs) {
10835 PyObject *resultobj;
10836 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10837 wxString *arg2 = (wxString *) 0 ;
10838 bool temp2 = false ;
10839 PyObject * obj0 = 0 ;
10840 PyObject * obj1 = 0 ;
10841 char *kwnames[] = {
10842 (char *) "self",(char *) "CanonicalName", NULL
10843 };
10844
10845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_CanonicalName_set",kwnames,&obj0,&obj1)) goto fail;
10846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10847 if (SWIG_arg_fail(1)) SWIG_fail;
10848 {
10849 arg2 = wxString_in_helper(obj1);
10850 if (arg2 == NULL) SWIG_fail;
10851 temp2 = true;
10852 }
10853 if (arg1) (arg1)->CanonicalName = *arg2;
10854
10855 Py_INCREF(Py_None); resultobj = Py_None;
10856 {
10857 if (temp2)
10858 delete arg2;
10859 }
10860 return resultobj;
10861 fail:
10862 {
10863 if (temp2)
10864 delete arg2;
10865 }
10866 return NULL;
10867 }
10868
10869
10870 static PyObject *_wrap_LanguageInfo_CanonicalName_get(PyObject *, PyObject *args, PyObject *kwargs) {
10871 PyObject *resultobj;
10872 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10873 wxString *result;
10874 PyObject * obj0 = 0 ;
10875 char *kwnames[] = {
10876 (char *) "self", NULL
10877 };
10878
10879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_CanonicalName_get",kwnames,&obj0)) goto fail;
10880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10881 if (SWIG_arg_fail(1)) SWIG_fail;
10882 result = (wxString *)& ((arg1)->CanonicalName);
10883
10884 {
10885 #if wxUSE_UNICODE
10886 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10887 #else
10888 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10889 #endif
10890 }
10891 return resultobj;
10892 fail:
10893 return NULL;
10894 }
10895
10896
10897 static PyObject *_wrap_LanguageInfo_Description_set(PyObject *, PyObject *args, PyObject *kwargs) {
10898 PyObject *resultobj;
10899 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10900 wxString *arg2 = (wxString *) 0 ;
10901 bool temp2 = false ;
10902 PyObject * obj0 = 0 ;
10903 PyObject * obj1 = 0 ;
10904 char *kwnames[] = {
10905 (char *) "self",(char *) "Description", NULL
10906 };
10907
10908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Description_set",kwnames,&obj0,&obj1)) goto fail;
10909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10910 if (SWIG_arg_fail(1)) SWIG_fail;
10911 {
10912 arg2 = wxString_in_helper(obj1);
10913 if (arg2 == NULL) SWIG_fail;
10914 temp2 = true;
10915 }
10916 if (arg1) (arg1)->Description = *arg2;
10917
10918 Py_INCREF(Py_None); resultobj = Py_None;
10919 {
10920 if (temp2)
10921 delete arg2;
10922 }
10923 return resultobj;
10924 fail:
10925 {
10926 if (temp2)
10927 delete arg2;
10928 }
10929 return NULL;
10930 }
10931
10932
10933 static PyObject *_wrap_LanguageInfo_Description_get(PyObject *, PyObject *args, PyObject *kwargs) {
10934 PyObject *resultobj;
10935 wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
10936 wxString *result;
10937 PyObject * obj0 = 0 ;
10938 char *kwnames[] = {
10939 (char *) "self", NULL
10940 };
10941
10942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Description_get",kwnames,&obj0)) goto fail;
10943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
10944 if (SWIG_arg_fail(1)) SWIG_fail;
10945 result = (wxString *)& ((arg1)->Description);
10946
10947 {
10948 #if wxUSE_UNICODE
10949 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10950 #else
10951 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10952 #endif
10953 }
10954 return resultobj;
10955 fail:
10956 return NULL;
10957 }
10958
10959
10960 static PyObject * LanguageInfo_swigregister(PyObject *, PyObject *args) {
10961 PyObject *obj;
10962 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10963 SWIG_TypeClientData(SWIGTYPE_p_wxLanguageInfo, obj);
10964 Py_INCREF(obj);
10965 return Py_BuildValue((char *)"");
10966 }
10967 static PyObject *_wrap_new_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
10968 PyObject *resultobj;
10969 int arg1 = (int) -1 ;
10970 int arg2 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
10971 wxLocale *result;
10972 PyObject * obj0 = 0 ;
10973 PyObject * obj1 = 0 ;
10974 char *kwnames[] = {
10975 (char *) "language",(char *) "flags", NULL
10976 };
10977
10978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Locale",kwnames,&obj0,&obj1)) goto fail;
10979 if (obj0) {
10980 {
10981 arg1 = (int)(SWIG_As_int(obj0));
10982 if (SWIG_arg_fail(1)) SWIG_fail;
10983 }
10984 }
10985 if (obj1) {
10986 {
10987 arg2 = (int)(SWIG_As_int(obj1));
10988 if (SWIG_arg_fail(2)) SWIG_fail;
10989 }
10990 }
10991 {
10992 PyThreadState* __tstate = wxPyBeginAllowThreads();
10993 result = (wxLocale *)new_wxLocale(arg1,arg2);
10994
10995 wxPyEndAllowThreads(__tstate);
10996 if (PyErr_Occurred()) SWIG_fail;
10997 }
10998 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 1);
10999 return resultobj;
11000 fail:
11001 return NULL;
11002 }
11003
11004
11005 static PyObject *_wrap_delete_Locale(PyObject *, PyObject *args, PyObject *kwargs) {
11006 PyObject *resultobj;
11007 wxLocale *arg1 = (wxLocale *) 0 ;
11008 PyObject * obj0 = 0 ;
11009 char *kwnames[] = {
11010 (char *) "self", NULL
11011 };
11012
11013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Locale",kwnames,&obj0)) goto fail;
11014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11015 if (SWIG_arg_fail(1)) SWIG_fail;
11016 {
11017 PyThreadState* __tstate = wxPyBeginAllowThreads();
11018 delete arg1;
11019
11020 wxPyEndAllowThreads(__tstate);
11021 if (PyErr_Occurred()) SWIG_fail;
11022 }
11023 Py_INCREF(Py_None); resultobj = Py_None;
11024 return resultobj;
11025 fail:
11026 return NULL;
11027 }
11028
11029
11030 static PyObject *_wrap_Locale_Init1(PyObject *, PyObject *args, PyObject *kwargs) {
11031 PyObject *resultobj;
11032 wxLocale *arg1 = (wxLocale *) 0 ;
11033 wxString *arg2 = 0 ;
11034 wxString const &arg3_defvalue = wxPyEmptyString ;
11035 wxString *arg3 = (wxString *) &arg3_defvalue ;
11036 wxString const &arg4_defvalue = wxPyEmptyString ;
11037 wxString *arg4 = (wxString *) &arg4_defvalue ;
11038 bool arg5 = (bool) true ;
11039 bool arg6 = (bool) false ;
11040 bool result;
11041 bool temp2 = false ;
11042 bool temp3 = false ;
11043 bool temp4 = false ;
11044 PyObject * obj0 = 0 ;
11045 PyObject * obj1 = 0 ;
11046 PyObject * obj2 = 0 ;
11047 PyObject * obj3 = 0 ;
11048 PyObject * obj4 = 0 ;
11049 PyObject * obj5 = 0 ;
11050 char *kwnames[] = {
11051 (char *) "self",(char *) "szName",(char *) "szShort",(char *) "szLocale",(char *) "bLoadDefault",(char *) "bConvertEncoding", NULL
11052 };
11053
11054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Locale_Init1",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11056 if (SWIG_arg_fail(1)) SWIG_fail;
11057 {
11058 arg2 = wxString_in_helper(obj1);
11059 if (arg2 == NULL) SWIG_fail;
11060 temp2 = true;
11061 }
11062 if (obj2) {
11063 {
11064 arg3 = wxString_in_helper(obj2);
11065 if (arg3 == NULL) SWIG_fail;
11066 temp3 = true;
11067 }
11068 }
11069 if (obj3) {
11070 {
11071 arg4 = wxString_in_helper(obj3);
11072 if (arg4 == NULL) SWIG_fail;
11073 temp4 = true;
11074 }
11075 }
11076 if (obj4) {
11077 {
11078 arg5 = (bool)(SWIG_As_bool(obj4));
11079 if (SWIG_arg_fail(5)) SWIG_fail;
11080 }
11081 }
11082 if (obj5) {
11083 {
11084 arg6 = (bool)(SWIG_As_bool(obj5));
11085 if (SWIG_arg_fail(6)) SWIG_fail;
11086 }
11087 }
11088 {
11089 PyThreadState* __tstate = wxPyBeginAllowThreads();
11090 result = (bool)wxLocale_Init1(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
11091
11092 wxPyEndAllowThreads(__tstate);
11093 if (PyErr_Occurred()) SWIG_fail;
11094 }
11095 {
11096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11097 }
11098 {
11099 if (temp2)
11100 delete arg2;
11101 }
11102 {
11103 if (temp3)
11104 delete arg3;
11105 }
11106 {
11107 if (temp4)
11108 delete arg4;
11109 }
11110 return resultobj;
11111 fail:
11112 {
11113 if (temp2)
11114 delete arg2;
11115 }
11116 {
11117 if (temp3)
11118 delete arg3;
11119 }
11120 {
11121 if (temp4)
11122 delete arg4;
11123 }
11124 return NULL;
11125 }
11126
11127
11128 static PyObject *_wrap_Locale_Init2(PyObject *, PyObject *args, PyObject *kwargs) {
11129 PyObject *resultobj;
11130 wxLocale *arg1 = (wxLocale *) 0 ;
11131 int arg2 = (int) wxLANGUAGE_DEFAULT ;
11132 int arg3 = (int) wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING ;
11133 bool result;
11134 PyObject * obj0 = 0 ;
11135 PyObject * obj1 = 0 ;
11136 PyObject * obj2 = 0 ;
11137 char *kwnames[] = {
11138 (char *) "self",(char *) "language",(char *) "flags", NULL
11139 };
11140
11141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Locale_Init2",kwnames,&obj0,&obj1,&obj2)) goto fail;
11142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11143 if (SWIG_arg_fail(1)) SWIG_fail;
11144 if (obj1) {
11145 {
11146 arg2 = (int)(SWIG_As_int(obj1));
11147 if (SWIG_arg_fail(2)) SWIG_fail;
11148 }
11149 }
11150 if (obj2) {
11151 {
11152 arg3 = (int)(SWIG_As_int(obj2));
11153 if (SWIG_arg_fail(3)) SWIG_fail;
11154 }
11155 }
11156 {
11157 PyThreadState* __tstate = wxPyBeginAllowThreads();
11158 result = (bool)wxLocale_Init2(arg1,arg2,arg3);
11159
11160 wxPyEndAllowThreads(__tstate);
11161 if (PyErr_Occurred()) SWIG_fail;
11162 }
11163 {
11164 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11165 }
11166 return resultobj;
11167 fail:
11168 return NULL;
11169 }
11170
11171
11172 static PyObject *_wrap_Locale_GetSystemLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11173 PyObject *resultobj;
11174 int result;
11175 char *kwnames[] = {
11176 NULL
11177 };
11178
11179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemLanguage",kwnames)) goto fail;
11180 {
11181 PyThreadState* __tstate = wxPyBeginAllowThreads();
11182 result = (int)wxLocale::GetSystemLanguage();
11183
11184 wxPyEndAllowThreads(__tstate);
11185 if (PyErr_Occurred()) SWIG_fail;
11186 }
11187 {
11188 resultobj = SWIG_From_int((int)(result));
11189 }
11190 return resultobj;
11191 fail:
11192 return NULL;
11193 }
11194
11195
11196 static PyObject *_wrap_Locale_GetSystemEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
11197 PyObject *resultobj;
11198 wxFontEncoding result;
11199 char *kwnames[] = {
11200 NULL
11201 };
11202
11203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncoding",kwnames)) goto fail;
11204 {
11205 PyThreadState* __tstate = wxPyBeginAllowThreads();
11206 result = (wxFontEncoding)wxLocale::GetSystemEncoding();
11207
11208 wxPyEndAllowThreads(__tstate);
11209 if (PyErr_Occurred()) SWIG_fail;
11210 }
11211 resultobj = SWIG_From_int((result));
11212 return resultobj;
11213 fail:
11214 return NULL;
11215 }
11216
11217
11218 static PyObject *_wrap_Locale_GetSystemEncodingName(PyObject *, PyObject *args, PyObject *kwargs) {
11219 PyObject *resultobj;
11220 wxString result;
11221 char *kwnames[] = {
11222 NULL
11223 };
11224
11225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Locale_GetSystemEncodingName",kwnames)) goto fail;
11226 {
11227 PyThreadState* __tstate = wxPyBeginAllowThreads();
11228 result = wxLocale::GetSystemEncodingName();
11229
11230 wxPyEndAllowThreads(__tstate);
11231 if (PyErr_Occurred()) SWIG_fail;
11232 }
11233 {
11234 #if wxUSE_UNICODE
11235 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11236 #else
11237 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11238 #endif
11239 }
11240 return resultobj;
11241 fail:
11242 return NULL;
11243 }
11244
11245
11246 static PyObject *_wrap_Locale_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11247 PyObject *resultobj;
11248 wxLocale *arg1 = (wxLocale *) 0 ;
11249 bool result;
11250 PyObject * obj0 = 0 ;
11251 char *kwnames[] = {
11252 (char *) "self", NULL
11253 };
11254
11255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_IsOk",kwnames,&obj0)) goto fail;
11256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11257 if (SWIG_arg_fail(1)) SWIG_fail;
11258 {
11259 PyThreadState* __tstate = wxPyBeginAllowThreads();
11260 result = (bool)((wxLocale const *)arg1)->IsOk();
11261
11262 wxPyEndAllowThreads(__tstate);
11263 if (PyErr_Occurred()) SWIG_fail;
11264 }
11265 {
11266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11267 }
11268 return resultobj;
11269 fail:
11270 return NULL;
11271 }
11272
11273
11274 static PyObject *_wrap_Locale_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
11275 PyObject *resultobj;
11276 wxLocale *arg1 = (wxLocale *) 0 ;
11277 wxString result;
11278 PyObject * obj0 = 0 ;
11279 char *kwnames[] = {
11280 (char *) "self", NULL
11281 };
11282
11283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLocale",kwnames,&obj0)) goto fail;
11284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11285 if (SWIG_arg_fail(1)) SWIG_fail;
11286 {
11287 PyThreadState* __tstate = wxPyBeginAllowThreads();
11288 result = ((wxLocale const *)arg1)->GetLocale();
11289
11290 wxPyEndAllowThreads(__tstate);
11291 if (PyErr_Occurred()) SWIG_fail;
11292 }
11293 {
11294 #if wxUSE_UNICODE
11295 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11296 #else
11297 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11298 #endif
11299 }
11300 return resultobj;
11301 fail:
11302 return NULL;
11303 }
11304
11305
11306 static PyObject *_wrap_Locale_GetLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11307 PyObject *resultobj;
11308 wxLocale *arg1 = (wxLocale *) 0 ;
11309 int result;
11310 PyObject * obj0 = 0 ;
11311 char *kwnames[] = {
11312 (char *) "self", NULL
11313 };
11314
11315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguage",kwnames,&obj0)) goto fail;
11316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11317 if (SWIG_arg_fail(1)) SWIG_fail;
11318 {
11319 PyThreadState* __tstate = wxPyBeginAllowThreads();
11320 result = (int)((wxLocale const *)arg1)->GetLanguage();
11321
11322 wxPyEndAllowThreads(__tstate);
11323 if (PyErr_Occurred()) SWIG_fail;
11324 }
11325 {
11326 resultobj = SWIG_From_int((int)(result));
11327 }
11328 return resultobj;
11329 fail:
11330 return NULL;
11331 }
11332
11333
11334 static PyObject *_wrap_Locale_GetSysName(PyObject *, PyObject *args, PyObject *kwargs) {
11335 PyObject *resultobj;
11336 wxLocale *arg1 = (wxLocale *) 0 ;
11337 wxString result;
11338 PyObject * obj0 = 0 ;
11339 char *kwnames[] = {
11340 (char *) "self", NULL
11341 };
11342
11343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetSysName",kwnames,&obj0)) goto fail;
11344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11345 if (SWIG_arg_fail(1)) SWIG_fail;
11346 {
11347 PyThreadState* __tstate = wxPyBeginAllowThreads();
11348 result = ((wxLocale const *)arg1)->GetSysName();
11349
11350 wxPyEndAllowThreads(__tstate);
11351 if (PyErr_Occurred()) SWIG_fail;
11352 }
11353 {
11354 #if wxUSE_UNICODE
11355 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11356 #else
11357 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11358 #endif
11359 }
11360 return resultobj;
11361 fail:
11362 return NULL;
11363 }
11364
11365
11366 static PyObject *_wrap_Locale_GetCanonicalName(PyObject *, PyObject *args, PyObject *kwargs) {
11367 PyObject *resultobj;
11368 wxLocale *arg1 = (wxLocale *) 0 ;
11369 wxString result;
11370 PyObject * obj0 = 0 ;
11371 char *kwnames[] = {
11372 (char *) "self", NULL
11373 };
11374
11375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetCanonicalName",kwnames,&obj0)) goto fail;
11376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11377 if (SWIG_arg_fail(1)) SWIG_fail;
11378 {
11379 PyThreadState* __tstate = wxPyBeginAllowThreads();
11380 result = ((wxLocale const *)arg1)->GetCanonicalName();
11381
11382 wxPyEndAllowThreads(__tstate);
11383 if (PyErr_Occurred()) SWIG_fail;
11384 }
11385 {
11386 #if wxUSE_UNICODE
11387 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11388 #else
11389 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11390 #endif
11391 }
11392 return resultobj;
11393 fail:
11394 return NULL;
11395 }
11396
11397
11398 static PyObject *_wrap_Locale_AddCatalogLookupPathPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
11399 PyObject *resultobj;
11400 wxString *arg1 = 0 ;
11401 bool temp1 = false ;
11402 PyObject * obj0 = 0 ;
11403 char *kwnames[] = {
11404 (char *) "prefix", NULL
11405 };
11406
11407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddCatalogLookupPathPrefix",kwnames,&obj0)) goto fail;
11408 {
11409 arg1 = wxString_in_helper(obj0);
11410 if (arg1 == NULL) SWIG_fail;
11411 temp1 = true;
11412 }
11413 {
11414 PyThreadState* __tstate = wxPyBeginAllowThreads();
11415 wxLocale::AddCatalogLookupPathPrefix((wxString const &)*arg1);
11416
11417 wxPyEndAllowThreads(__tstate);
11418 if (PyErr_Occurred()) SWIG_fail;
11419 }
11420 Py_INCREF(Py_None); resultobj = Py_None;
11421 {
11422 if (temp1)
11423 delete arg1;
11424 }
11425 return resultobj;
11426 fail:
11427 {
11428 if (temp1)
11429 delete arg1;
11430 }
11431 return NULL;
11432 }
11433
11434
11435 static PyObject *_wrap_Locale_AddCatalog(PyObject *, PyObject *args, PyObject *kwargs) {
11436 PyObject *resultobj;
11437 wxLocale *arg1 = (wxLocale *) 0 ;
11438 wxString *arg2 = 0 ;
11439 bool result;
11440 bool temp2 = false ;
11441 PyObject * obj0 = 0 ;
11442 PyObject * obj1 = 0 ;
11443 char *kwnames[] = {
11444 (char *) "self",(char *) "szDomain", NULL
11445 };
11446
11447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_AddCatalog",kwnames,&obj0,&obj1)) goto fail;
11448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11449 if (SWIG_arg_fail(1)) SWIG_fail;
11450 {
11451 arg2 = wxString_in_helper(obj1);
11452 if (arg2 == NULL) SWIG_fail;
11453 temp2 = true;
11454 }
11455 {
11456 PyThreadState* __tstate = wxPyBeginAllowThreads();
11457 result = (bool)(arg1)->AddCatalog((wxString const &)*arg2);
11458
11459 wxPyEndAllowThreads(__tstate);
11460 if (PyErr_Occurred()) SWIG_fail;
11461 }
11462 {
11463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11464 }
11465 {
11466 if (temp2)
11467 delete arg2;
11468 }
11469 return resultobj;
11470 fail:
11471 {
11472 if (temp2)
11473 delete arg2;
11474 }
11475 return NULL;
11476 }
11477
11478
11479 static PyObject *_wrap_Locale_IsLoaded(PyObject *, PyObject *args, PyObject *kwargs) {
11480 PyObject *resultobj;
11481 wxLocale *arg1 = (wxLocale *) 0 ;
11482 wxString *arg2 = 0 ;
11483 bool result;
11484 bool temp2 = false ;
11485 PyObject * obj0 = 0 ;
11486 PyObject * obj1 = 0 ;
11487 char *kwnames[] = {
11488 (char *) "self",(char *) "szDomain", NULL
11489 };
11490
11491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Locale_IsLoaded",kwnames,&obj0,&obj1)) goto fail;
11492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11493 if (SWIG_arg_fail(1)) SWIG_fail;
11494 {
11495 arg2 = wxString_in_helper(obj1);
11496 if (arg2 == NULL) SWIG_fail;
11497 temp2 = true;
11498 }
11499 {
11500 PyThreadState* __tstate = wxPyBeginAllowThreads();
11501 result = (bool)((wxLocale const *)arg1)->IsLoaded((wxString const &)*arg2);
11502
11503 wxPyEndAllowThreads(__tstate);
11504 if (PyErr_Occurred()) SWIG_fail;
11505 }
11506 {
11507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11508 }
11509 {
11510 if (temp2)
11511 delete arg2;
11512 }
11513 return resultobj;
11514 fail:
11515 {
11516 if (temp2)
11517 delete arg2;
11518 }
11519 return NULL;
11520 }
11521
11522
11523 static PyObject *_wrap_Locale_GetLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11524 PyObject *resultobj;
11525 int arg1 ;
11526 wxLanguageInfo *result;
11527 PyObject * obj0 = 0 ;
11528 char *kwnames[] = {
11529 (char *) "lang", NULL
11530 };
11531
11532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageInfo",kwnames,&obj0)) goto fail;
11533 {
11534 arg1 = (int)(SWIG_As_int(obj0));
11535 if (SWIG_arg_fail(1)) SWIG_fail;
11536 }
11537 {
11538 PyThreadState* __tstate = wxPyBeginAllowThreads();
11539 result = (wxLanguageInfo *)wxLocale::GetLanguageInfo(arg1);
11540
11541 wxPyEndAllowThreads(__tstate);
11542 if (PyErr_Occurred()) SWIG_fail;
11543 }
11544 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
11545 return resultobj;
11546 fail:
11547 return NULL;
11548 }
11549
11550
11551 static PyObject *_wrap_Locale_GetLanguageName(PyObject *, PyObject *args, PyObject *kwargs) {
11552 PyObject *resultobj;
11553 int arg1 ;
11554 wxString result;
11555 PyObject * obj0 = 0 ;
11556 char *kwnames[] = {
11557 (char *) "lang", NULL
11558 };
11559
11560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetLanguageName",kwnames,&obj0)) goto fail;
11561 {
11562 arg1 = (int)(SWIG_As_int(obj0));
11563 if (SWIG_arg_fail(1)) SWIG_fail;
11564 }
11565 {
11566 PyThreadState* __tstate = wxPyBeginAllowThreads();
11567 result = wxLocale::GetLanguageName(arg1);
11568
11569 wxPyEndAllowThreads(__tstate);
11570 if (PyErr_Occurred()) SWIG_fail;
11571 }
11572 {
11573 #if wxUSE_UNICODE
11574 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11575 #else
11576 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11577 #endif
11578 }
11579 return resultobj;
11580 fail:
11581 return NULL;
11582 }
11583
11584
11585 static PyObject *_wrap_Locale_FindLanguageInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11586 PyObject *resultobj;
11587 wxString *arg1 = 0 ;
11588 wxLanguageInfo *result;
11589 bool temp1 = false ;
11590 PyObject * obj0 = 0 ;
11591 char *kwnames[] = {
11592 (char *) "locale", NULL
11593 };
11594
11595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_FindLanguageInfo",kwnames,&obj0)) goto fail;
11596 {
11597 arg1 = wxString_in_helper(obj0);
11598 if (arg1 == NULL) SWIG_fail;
11599 temp1 = true;
11600 }
11601 {
11602 PyThreadState* __tstate = wxPyBeginAllowThreads();
11603 result = (wxLanguageInfo *)wxLocale::FindLanguageInfo((wxString const &)*arg1);
11604
11605 wxPyEndAllowThreads(__tstate);
11606 if (PyErr_Occurred()) SWIG_fail;
11607 }
11608 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLanguageInfo, 0);
11609 {
11610 if (temp1)
11611 delete arg1;
11612 }
11613 return resultobj;
11614 fail:
11615 {
11616 if (temp1)
11617 delete arg1;
11618 }
11619 return NULL;
11620 }
11621
11622
11623 static PyObject *_wrap_Locale_AddLanguage(PyObject *, PyObject *args, PyObject *kwargs) {
11624 PyObject *resultobj;
11625 wxLanguageInfo *arg1 = 0 ;
11626 PyObject * obj0 = 0 ;
11627 char *kwnames[] = {
11628 (char *) "info", NULL
11629 };
11630
11631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_AddLanguage",kwnames,&obj0)) goto fail;
11632 {
11633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLanguageInfo, SWIG_POINTER_EXCEPTION | 0);
11634 if (SWIG_arg_fail(1)) SWIG_fail;
11635 if (arg1 == NULL) {
11636 SWIG_null_ref("wxLanguageInfo");
11637 }
11638 if (SWIG_arg_fail(1)) SWIG_fail;
11639 }
11640 {
11641 PyThreadState* __tstate = wxPyBeginAllowThreads();
11642 wxLocale::AddLanguage((wxLanguageInfo const &)*arg1);
11643
11644 wxPyEndAllowThreads(__tstate);
11645 if (PyErr_Occurred()) SWIG_fail;
11646 }
11647 Py_INCREF(Py_None); resultobj = Py_None;
11648 return resultobj;
11649 fail:
11650 return NULL;
11651 }
11652
11653
11654 static PyObject *_wrap_Locale_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
11655 PyObject *resultobj;
11656 wxLocale *arg1 = (wxLocale *) 0 ;
11657 wxString *arg2 = 0 ;
11658 wxString const &arg3_defvalue = wxPyEmptyString ;
11659 wxString *arg3 = (wxString *) &arg3_defvalue ;
11660 wxString result;
11661 bool temp2 = false ;
11662 bool temp3 = false ;
11663 PyObject * obj0 = 0 ;
11664 PyObject * obj1 = 0 ;
11665 PyObject * obj2 = 0 ;
11666 char *kwnames[] = {
11667 (char *) "self",(char *) "szOrigString",(char *) "szDomain", NULL
11668 };
11669
11670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Locale_GetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
11671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11672 if (SWIG_arg_fail(1)) SWIG_fail;
11673 {
11674 arg2 = wxString_in_helper(obj1);
11675 if (arg2 == NULL) SWIG_fail;
11676 temp2 = true;
11677 }
11678 if (obj2) {
11679 {
11680 arg3 = wxString_in_helper(obj2);
11681 if (arg3 == NULL) SWIG_fail;
11682 temp3 = true;
11683 }
11684 }
11685 {
11686 PyThreadState* __tstate = wxPyBeginAllowThreads();
11687 result = ((wxLocale const *)arg1)->GetString((wxString const &)*arg2,(wxString const &)*arg3);
11688
11689 wxPyEndAllowThreads(__tstate);
11690 if (PyErr_Occurred()) SWIG_fail;
11691 }
11692 {
11693 #if wxUSE_UNICODE
11694 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11695 #else
11696 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11697 #endif
11698 }
11699 {
11700 if (temp2)
11701 delete arg2;
11702 }
11703 {
11704 if (temp3)
11705 delete arg3;
11706 }
11707 return resultobj;
11708 fail:
11709 {
11710 if (temp2)
11711 delete arg2;
11712 }
11713 {
11714 if (temp3)
11715 delete arg3;
11716 }
11717 return NULL;
11718 }
11719
11720
11721 static PyObject *_wrap_Locale_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
11722 PyObject *resultobj;
11723 wxLocale *arg1 = (wxLocale *) 0 ;
11724 wxString *result;
11725 PyObject * obj0 = 0 ;
11726 char *kwnames[] = {
11727 (char *) "self", NULL
11728 };
11729
11730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Locale_GetName",kwnames,&obj0)) goto fail;
11731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLocale, SWIG_POINTER_EXCEPTION | 0);
11732 if (SWIG_arg_fail(1)) SWIG_fail;
11733 {
11734 PyThreadState* __tstate = wxPyBeginAllowThreads();
11735 {
11736 wxString const &_result_ref = ((wxLocale const *)arg1)->GetName();
11737 result = (wxString *) &_result_ref;
11738 }
11739
11740 wxPyEndAllowThreads(__tstate);
11741 if (PyErr_Occurred()) SWIG_fail;
11742 }
11743 {
11744 #if wxUSE_UNICODE
11745 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
11746 #else
11747 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
11748 #endif
11749 }
11750 return resultobj;
11751 fail:
11752 return NULL;
11753 }
11754
11755
11756 static PyObject * Locale_swigregister(PyObject *, PyObject *args) {
11757 PyObject *obj;
11758 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11759 SWIG_TypeClientData(SWIGTYPE_p_wxLocale, obj);
11760 Py_INCREF(obj);
11761 return Py_BuildValue((char *)"");
11762 }
11763 static PyObject *_wrap_GetLocale(PyObject *, PyObject *args, PyObject *kwargs) {
11764 PyObject *resultobj;
11765 wxLocale *result;
11766 char *kwnames[] = {
11767 NULL
11768 };
11769
11770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocale",kwnames)) goto fail;
11771 {
11772 PyThreadState* __tstate = wxPyBeginAllowThreads();
11773 result = (wxLocale *)wxGetLocale();
11774
11775 wxPyEndAllowThreads(__tstate);
11776 if (PyErr_Occurred()) SWIG_fail;
11777 }
11778 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLocale, 0);
11779 return resultobj;
11780 fail:
11781 return NULL;
11782 }
11783
11784
11785 static PyObject *_wrap_GetTranslation__SWIG_0(PyObject *, PyObject *args) {
11786 PyObject *resultobj;
11787 wxString *arg1 = 0 ;
11788 wxString result;
11789 bool temp1 = false ;
11790 PyObject * obj0 = 0 ;
11791
11792 if(!PyArg_ParseTuple(args,(char *)"O:GetTranslation",&obj0)) goto fail;
11793 {
11794 arg1 = wxString_in_helper(obj0);
11795 if (arg1 == NULL) SWIG_fail;
11796 temp1 = true;
11797 }
11798 {
11799 PyThreadState* __tstate = wxPyBeginAllowThreads();
11800 result = wxGetTranslation((wxString const &)*arg1);
11801
11802 wxPyEndAllowThreads(__tstate);
11803 if (PyErr_Occurred()) SWIG_fail;
11804 }
11805 {
11806 #if wxUSE_UNICODE
11807 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11808 #else
11809 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11810 #endif
11811 }
11812 {
11813 if (temp1)
11814 delete arg1;
11815 }
11816 return resultobj;
11817 fail:
11818 {
11819 if (temp1)
11820 delete arg1;
11821 }
11822 return NULL;
11823 }
11824
11825
11826 static PyObject *_wrap_GetTranslation__SWIG_1(PyObject *, PyObject *args) {
11827 PyObject *resultobj;
11828 wxString *arg1 = 0 ;
11829 wxString *arg2 = 0 ;
11830 size_t arg3 ;
11831 wxString result;
11832 bool temp1 = false ;
11833 bool temp2 = false ;
11834 PyObject * obj0 = 0 ;
11835 PyObject * obj1 = 0 ;
11836 PyObject * obj2 = 0 ;
11837
11838 if(!PyArg_ParseTuple(args,(char *)"OOO:GetTranslation",&obj0,&obj1,&obj2)) goto fail;
11839 {
11840 arg1 = wxString_in_helper(obj0);
11841 if (arg1 == NULL) SWIG_fail;
11842 temp1 = true;
11843 }
11844 {
11845 arg2 = wxString_in_helper(obj1);
11846 if (arg2 == NULL) SWIG_fail;
11847 temp2 = true;
11848 }
11849 {
11850 arg3 = (size_t)(SWIG_As_unsigned_SS_long(obj2));
11851 if (SWIG_arg_fail(3)) SWIG_fail;
11852 }
11853 {
11854 PyThreadState* __tstate = wxPyBeginAllowThreads();
11855 result = wxGetTranslation((wxString const &)*arg1,(wxString const &)*arg2,arg3);
11856
11857 wxPyEndAllowThreads(__tstate);
11858 if (PyErr_Occurred()) SWIG_fail;
11859 }
11860 {
11861 #if wxUSE_UNICODE
11862 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11863 #else
11864 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11865 #endif
11866 }
11867 {
11868 if (temp1)
11869 delete arg1;
11870 }
11871 {
11872 if (temp2)
11873 delete arg2;
11874 }
11875 return resultobj;
11876 fail:
11877 {
11878 if (temp1)
11879 delete arg1;
11880 }
11881 {
11882 if (temp2)
11883 delete arg2;
11884 }
11885 return NULL;
11886 }
11887
11888
11889 static PyObject *_wrap_GetTranslation(PyObject *self, PyObject *args) {
11890 int argc;
11891 PyObject *argv[4];
11892 int ii;
11893
11894 argc = PyObject_Length(args);
11895 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
11896 argv[ii] = PyTuple_GetItem(args,ii);
11897 }
11898 if (argc == 1) {
11899 int _v;
11900 {
11901 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
11902 }
11903 if (_v) {
11904 return _wrap_GetTranslation__SWIG_0(self,args);
11905 }
11906 }
11907 if (argc == 3) {
11908 int _v;
11909 {
11910 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
11911 }
11912 if (_v) {
11913 {
11914 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
11915 }
11916 if (_v) {
11917 _v = SWIG_Check_unsigned_SS_long(argv[2]);
11918 if (_v) {
11919 return _wrap_GetTranslation__SWIG_1(self,args);
11920 }
11921 }
11922 }
11923 }
11924
11925 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GetTranslation'");
11926 return NULL;
11927 }
11928
11929
11930 static PyObject *_wrap_new_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
11931 PyObject *resultobj;
11932 wxEncodingConverter *result;
11933 char *kwnames[] = {
11934 NULL
11935 };
11936
11937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EncodingConverter",kwnames)) goto fail;
11938 {
11939 PyThreadState* __tstate = wxPyBeginAllowThreads();
11940 result = (wxEncodingConverter *)new wxEncodingConverter();
11941
11942 wxPyEndAllowThreads(__tstate);
11943 if (PyErr_Occurred()) SWIG_fail;
11944 }
11945 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEncodingConverter, 1);
11946 return resultobj;
11947 fail:
11948 return NULL;
11949 }
11950
11951
11952 static PyObject *_wrap_delete_EncodingConverter(PyObject *, PyObject *args, PyObject *kwargs) {
11953 PyObject *resultobj;
11954 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
11955 PyObject * obj0 = 0 ;
11956 char *kwnames[] = {
11957 (char *) "self", NULL
11958 };
11959
11960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EncodingConverter",kwnames,&obj0)) goto fail;
11961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
11962 if (SWIG_arg_fail(1)) SWIG_fail;
11963 {
11964 PyThreadState* __tstate = wxPyBeginAllowThreads();
11965 delete arg1;
11966
11967 wxPyEndAllowThreads(__tstate);
11968 if (PyErr_Occurred()) SWIG_fail;
11969 }
11970 Py_INCREF(Py_None); resultobj = Py_None;
11971 return resultobj;
11972 fail:
11973 return NULL;
11974 }
11975
11976
11977 static PyObject *_wrap_EncodingConverter_Init(PyObject *, PyObject *args, PyObject *kwargs) {
11978 PyObject *resultobj;
11979 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
11980 wxFontEncoding arg2 ;
11981 wxFontEncoding arg3 ;
11982 int arg4 = (int) wxCONVERT_STRICT ;
11983 bool result;
11984 PyObject * obj0 = 0 ;
11985 PyObject * obj1 = 0 ;
11986 PyObject * obj2 = 0 ;
11987 PyObject * obj3 = 0 ;
11988 char *kwnames[] = {
11989 (char *) "self",(char *) "input_enc",(char *) "output_enc",(char *) "method", NULL
11990 };
11991
11992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:EncodingConverter_Init",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
11994 if (SWIG_arg_fail(1)) SWIG_fail;
11995 {
11996 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
11997 if (SWIG_arg_fail(2)) SWIG_fail;
11998 }
11999 {
12000 arg3 = (wxFontEncoding)(SWIG_As_int(obj2));
12001 if (SWIG_arg_fail(3)) SWIG_fail;
12002 }
12003 if (obj3) {
12004 {
12005 arg4 = (int)(SWIG_As_int(obj3));
12006 if (SWIG_arg_fail(4)) SWIG_fail;
12007 }
12008 }
12009 {
12010 PyThreadState* __tstate = wxPyBeginAllowThreads();
12011 result = (bool)(arg1)->Init((wxFontEncoding )arg2,(wxFontEncoding )arg3,arg4);
12012
12013 wxPyEndAllowThreads(__tstate);
12014 if (PyErr_Occurred()) SWIG_fail;
12015 }
12016 {
12017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12018 }
12019 return resultobj;
12020 fail:
12021 return NULL;
12022 }
12023
12024
12025 static PyObject *_wrap_EncodingConverter_Convert(PyObject *, PyObject *args, PyObject *kwargs) {
12026 PyObject *resultobj;
12027 wxEncodingConverter *arg1 = (wxEncodingConverter *) 0 ;
12028 wxString *arg2 = 0 ;
12029 wxString result;
12030 bool temp2 = false ;
12031 PyObject * obj0 = 0 ;
12032 PyObject * obj1 = 0 ;
12033 char *kwnames[] = {
12034 (char *) "self",(char *) "input", NULL
12035 };
12036
12037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_Convert",kwnames,&obj0,&obj1)) goto fail;
12038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEncodingConverter, SWIG_POINTER_EXCEPTION | 0);
12039 if (SWIG_arg_fail(1)) SWIG_fail;
12040 {
12041 arg2 = wxString_in_helper(obj1);
12042 if (arg2 == NULL) SWIG_fail;
12043 temp2 = true;
12044 }
12045 {
12046 PyThreadState* __tstate = wxPyBeginAllowThreads();
12047 result = (arg1)->Convert((wxString const &)*arg2);
12048
12049 wxPyEndAllowThreads(__tstate);
12050 if (PyErr_Occurred()) SWIG_fail;
12051 }
12052 {
12053 #if wxUSE_UNICODE
12054 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12055 #else
12056 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12057 #endif
12058 }
12059 {
12060 if (temp2)
12061 delete arg2;
12062 }
12063 return resultobj;
12064 fail:
12065 {
12066 if (temp2)
12067 delete arg2;
12068 }
12069 return NULL;
12070 }
12071
12072
12073 static PyObject *_wrap_EncodingConverter_GetPlatformEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12074 PyObject *resultobj;
12075 wxFontEncoding arg1 ;
12076 int arg2 = (int) wxPLATFORM_CURRENT ;
12077 wxFontEncodingArray result;
12078 PyObject * obj0 = 0 ;
12079 PyObject * obj1 = 0 ;
12080 char *kwnames[] = {
12081 (char *) "enc",(char *) "platform", NULL
12082 };
12083
12084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EncodingConverter_GetPlatformEquivalents",kwnames,&obj0,&obj1)) goto fail;
12085 {
12086 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12087 if (SWIG_arg_fail(1)) SWIG_fail;
12088 }
12089 if (obj1) {
12090 {
12091 arg2 = (int)(SWIG_As_int(obj1));
12092 if (SWIG_arg_fail(2)) SWIG_fail;
12093 }
12094 }
12095 {
12096 PyThreadState* __tstate = wxPyBeginAllowThreads();
12097 result = wxEncodingConverter::GetPlatformEquivalents((wxFontEncoding )arg1,arg2);
12098
12099 wxPyEndAllowThreads(__tstate);
12100 if (PyErr_Occurred()) SWIG_fail;
12101 }
12102 {
12103 resultobj = PyList_New(0);
12104 for (size_t i=0; i < (&result)->GetCount(); i++) {
12105 PyObject* number = PyInt_FromLong((&result)->Item(i));
12106 PyList_Append(resultobj, number);
12107 Py_DECREF(number);
12108 }
12109 }
12110 return resultobj;
12111 fail:
12112 return NULL;
12113 }
12114
12115
12116 static PyObject *_wrap_EncodingConverter_GetAllEquivalents(PyObject *, PyObject *args, PyObject *kwargs) {
12117 PyObject *resultobj;
12118 wxFontEncoding arg1 ;
12119 wxFontEncodingArray result;
12120 PyObject * obj0 = 0 ;
12121 char *kwnames[] = {
12122 (char *) "enc", NULL
12123 };
12124
12125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EncodingConverter_GetAllEquivalents",kwnames,&obj0)) goto fail;
12126 {
12127 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12128 if (SWIG_arg_fail(1)) SWIG_fail;
12129 }
12130 {
12131 PyThreadState* __tstate = wxPyBeginAllowThreads();
12132 result = wxEncodingConverter::GetAllEquivalents((wxFontEncoding )arg1);
12133
12134 wxPyEndAllowThreads(__tstate);
12135 if (PyErr_Occurred()) SWIG_fail;
12136 }
12137 {
12138 resultobj = PyList_New(0);
12139 for (size_t i=0; i < (&result)->GetCount(); i++) {
12140 PyObject* number = PyInt_FromLong((&result)->Item(i));
12141 PyList_Append(resultobj, number);
12142 Py_DECREF(number);
12143 }
12144 }
12145 return resultobj;
12146 fail:
12147 return NULL;
12148 }
12149
12150
12151 static PyObject *_wrap_EncodingConverter_CanConvert(PyObject *, PyObject *args, PyObject *kwargs) {
12152 PyObject *resultobj;
12153 wxFontEncoding arg1 ;
12154 wxFontEncoding arg2 ;
12155 bool result;
12156 PyObject * obj0 = 0 ;
12157 PyObject * obj1 = 0 ;
12158 char *kwnames[] = {
12159 (char *) "encIn",(char *) "encOut", NULL
12160 };
12161
12162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EncodingConverter_CanConvert",kwnames,&obj0,&obj1)) goto fail;
12163 {
12164 arg1 = (wxFontEncoding)(SWIG_As_int(obj0));
12165 if (SWIG_arg_fail(1)) SWIG_fail;
12166 }
12167 {
12168 arg2 = (wxFontEncoding)(SWIG_As_int(obj1));
12169 if (SWIG_arg_fail(2)) SWIG_fail;
12170 }
12171 {
12172 PyThreadState* __tstate = wxPyBeginAllowThreads();
12173 result = (bool)wxEncodingConverter::CanConvert((wxFontEncoding )arg1,(wxFontEncoding )arg2);
12174
12175 wxPyEndAllowThreads(__tstate);
12176 if (PyErr_Occurred()) SWIG_fail;
12177 }
12178 {
12179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12180 }
12181 return resultobj;
12182 fail:
12183 return NULL;
12184 }
12185
12186
12187 static PyObject * EncodingConverter_swigregister(PyObject *, PyObject *args) {
12188 PyObject *obj;
12189 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12190 SWIG_TypeClientData(SWIGTYPE_p_wxEncodingConverter, obj);
12191 Py_INCREF(obj);
12192 return Py_BuildValue((char *)"");
12193 }
12194 static PyObject *_wrap_delete_DC(PyObject *, PyObject *args, PyObject *kwargs) {
12195 PyObject *resultobj;
12196 wxDC *arg1 = (wxDC *) 0 ;
12197 PyObject * obj0 = 0 ;
12198 char *kwnames[] = {
12199 (char *) "self", NULL
12200 };
12201
12202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DC",kwnames,&obj0)) goto fail;
12203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12204 if (SWIG_arg_fail(1)) SWIG_fail;
12205 {
12206 PyThreadState* __tstate = wxPyBeginAllowThreads();
12207 delete arg1;
12208
12209 wxPyEndAllowThreads(__tstate);
12210 if (PyErr_Occurred()) SWIG_fail;
12211 }
12212 Py_INCREF(Py_None); resultobj = Py_None;
12213 return resultobj;
12214 fail:
12215 return NULL;
12216 }
12217
12218
12219 static PyObject *_wrap_DC_BeginDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12220 PyObject *resultobj;
12221 wxDC *arg1 = (wxDC *) 0 ;
12222 PyObject * obj0 = 0 ;
12223 char *kwnames[] = {
12224 (char *) "self", NULL
12225 };
12226
12227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_BeginDrawing",kwnames,&obj0)) goto fail;
12228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12229 if (SWIG_arg_fail(1)) SWIG_fail;
12230 {
12231 PyThreadState* __tstate = wxPyBeginAllowThreads();
12232 (arg1)->BeginDrawing();
12233
12234 wxPyEndAllowThreads(__tstate);
12235 if (PyErr_Occurred()) SWIG_fail;
12236 }
12237 Py_INCREF(Py_None); resultobj = Py_None;
12238 return resultobj;
12239 fail:
12240 return NULL;
12241 }
12242
12243
12244 static PyObject *_wrap_DC_EndDrawing(PyObject *, PyObject *args, PyObject *kwargs) {
12245 PyObject *resultobj;
12246 wxDC *arg1 = (wxDC *) 0 ;
12247 PyObject * obj0 = 0 ;
12248 char *kwnames[] = {
12249 (char *) "self", NULL
12250 };
12251
12252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDrawing",kwnames,&obj0)) goto fail;
12253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12254 if (SWIG_arg_fail(1)) SWIG_fail;
12255 {
12256 PyThreadState* __tstate = wxPyBeginAllowThreads();
12257 (arg1)->EndDrawing();
12258
12259 wxPyEndAllowThreads(__tstate);
12260 if (PyErr_Occurred()) SWIG_fail;
12261 }
12262 Py_INCREF(Py_None); resultobj = Py_None;
12263 return resultobj;
12264 fail:
12265 return NULL;
12266 }
12267
12268
12269 static PyObject *_wrap_DC_FloodFill(PyObject *, PyObject *args, PyObject *kwargs) {
12270 PyObject *resultobj;
12271 wxDC *arg1 = (wxDC *) 0 ;
12272 int arg2 ;
12273 int arg3 ;
12274 wxColour *arg4 = 0 ;
12275 int arg5 = (int) wxFLOOD_SURFACE ;
12276 bool result;
12277 wxColour temp4 ;
12278 PyObject * obj0 = 0 ;
12279 PyObject * obj1 = 0 ;
12280 PyObject * obj2 = 0 ;
12281 PyObject * obj3 = 0 ;
12282 PyObject * obj4 = 0 ;
12283 char *kwnames[] = {
12284 (char *) "self",(char *) "x",(char *) "y",(char *) "col",(char *) "style", NULL
12285 };
12286
12287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_FloodFill",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12289 if (SWIG_arg_fail(1)) SWIG_fail;
12290 {
12291 arg2 = (int)(SWIG_As_int(obj1));
12292 if (SWIG_arg_fail(2)) SWIG_fail;
12293 }
12294 {
12295 arg3 = (int)(SWIG_As_int(obj2));
12296 if (SWIG_arg_fail(3)) SWIG_fail;
12297 }
12298 {
12299 arg4 = &temp4;
12300 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
12301 }
12302 if (obj4) {
12303 {
12304 arg5 = (int)(SWIG_As_int(obj4));
12305 if (SWIG_arg_fail(5)) SWIG_fail;
12306 }
12307 }
12308 {
12309 PyThreadState* __tstate = wxPyBeginAllowThreads();
12310 result = (bool)(arg1)->FloodFill(arg2,arg3,(wxColour const &)*arg4,arg5);
12311
12312 wxPyEndAllowThreads(__tstate);
12313 if (PyErr_Occurred()) SWIG_fail;
12314 }
12315 {
12316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12317 }
12318 return resultobj;
12319 fail:
12320 return NULL;
12321 }
12322
12323
12324 static PyObject *_wrap_DC_FloodFillPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12325 PyObject *resultobj;
12326 wxDC *arg1 = (wxDC *) 0 ;
12327 wxPoint *arg2 = 0 ;
12328 wxColour *arg3 = 0 ;
12329 int arg4 = (int) wxFLOOD_SURFACE ;
12330 bool result;
12331 wxPoint temp2 ;
12332 wxColour temp3 ;
12333 PyObject * obj0 = 0 ;
12334 PyObject * obj1 = 0 ;
12335 PyObject * obj2 = 0 ;
12336 PyObject * obj3 = 0 ;
12337 char *kwnames[] = {
12338 (char *) "self",(char *) "pt",(char *) "col",(char *) "style", NULL
12339 };
12340
12341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_FloodFillPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12343 if (SWIG_arg_fail(1)) SWIG_fail;
12344 {
12345 arg2 = &temp2;
12346 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12347 }
12348 {
12349 arg3 = &temp3;
12350 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
12351 }
12352 if (obj3) {
12353 {
12354 arg4 = (int)(SWIG_As_int(obj3));
12355 if (SWIG_arg_fail(4)) SWIG_fail;
12356 }
12357 }
12358 {
12359 PyThreadState* __tstate = wxPyBeginAllowThreads();
12360 result = (bool)(arg1)->FloodFill((wxPoint const &)*arg2,(wxColour const &)*arg3,arg4);
12361
12362 wxPyEndAllowThreads(__tstate);
12363 if (PyErr_Occurred()) SWIG_fail;
12364 }
12365 {
12366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12367 }
12368 return resultobj;
12369 fail:
12370 return NULL;
12371 }
12372
12373
12374 static PyObject *_wrap_DC_GetPixel(PyObject *, PyObject *args, PyObject *kwargs) {
12375 PyObject *resultobj;
12376 wxDC *arg1 = (wxDC *) 0 ;
12377 int arg2 ;
12378 int arg3 ;
12379 wxColour result;
12380 PyObject * obj0 = 0 ;
12381 PyObject * obj1 = 0 ;
12382 PyObject * obj2 = 0 ;
12383 char *kwnames[] = {
12384 (char *) "self",(char *) "x",(char *) "y", NULL
12385 };
12386
12387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_GetPixel",kwnames,&obj0,&obj1,&obj2)) goto fail;
12388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12389 if (SWIG_arg_fail(1)) SWIG_fail;
12390 {
12391 arg2 = (int)(SWIG_As_int(obj1));
12392 if (SWIG_arg_fail(2)) SWIG_fail;
12393 }
12394 {
12395 arg3 = (int)(SWIG_As_int(obj2));
12396 if (SWIG_arg_fail(3)) SWIG_fail;
12397 }
12398 {
12399 PyThreadState* __tstate = wxPyBeginAllowThreads();
12400 result = wxDC_GetPixel(arg1,arg2,arg3);
12401
12402 wxPyEndAllowThreads(__tstate);
12403 if (PyErr_Occurred()) SWIG_fail;
12404 }
12405 {
12406 wxColour * resultptr;
12407 resultptr = new wxColour((wxColour &)(result));
12408 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12409 }
12410 return resultobj;
12411 fail:
12412 return NULL;
12413 }
12414
12415
12416 static PyObject *_wrap_DC_GetPixelPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12417 PyObject *resultobj;
12418 wxDC *arg1 = (wxDC *) 0 ;
12419 wxPoint *arg2 = 0 ;
12420 wxColour result;
12421 wxPoint temp2 ;
12422 PyObject * obj0 = 0 ;
12423 PyObject * obj1 = 0 ;
12424 char *kwnames[] = {
12425 (char *) "self",(char *) "pt", NULL
12426 };
12427
12428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPixelPoint",kwnames,&obj0,&obj1)) goto fail;
12429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12430 if (SWIG_arg_fail(1)) SWIG_fail;
12431 {
12432 arg2 = &temp2;
12433 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12434 }
12435 {
12436 PyThreadState* __tstate = wxPyBeginAllowThreads();
12437 result = wxDC_GetPixelPoint(arg1,(wxPoint const &)*arg2);
12438
12439 wxPyEndAllowThreads(__tstate);
12440 if (PyErr_Occurred()) SWIG_fail;
12441 }
12442 {
12443 wxColour * resultptr;
12444 resultptr = new wxColour((wxColour &)(result));
12445 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
12446 }
12447 return resultobj;
12448 fail:
12449 return NULL;
12450 }
12451
12452
12453 static PyObject *_wrap_DC_DrawLine(PyObject *, PyObject *args, PyObject *kwargs) {
12454 PyObject *resultobj;
12455 wxDC *arg1 = (wxDC *) 0 ;
12456 int arg2 ;
12457 int arg3 ;
12458 int arg4 ;
12459 int arg5 ;
12460 PyObject * obj0 = 0 ;
12461 PyObject * obj1 = 0 ;
12462 PyObject * obj2 = 0 ;
12463 PyObject * obj3 = 0 ;
12464 PyObject * obj4 = 0 ;
12465 char *kwnames[] = {
12466 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2", NULL
12467 };
12468
12469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawLine",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12471 if (SWIG_arg_fail(1)) SWIG_fail;
12472 {
12473 arg2 = (int)(SWIG_As_int(obj1));
12474 if (SWIG_arg_fail(2)) SWIG_fail;
12475 }
12476 {
12477 arg3 = (int)(SWIG_As_int(obj2));
12478 if (SWIG_arg_fail(3)) SWIG_fail;
12479 }
12480 {
12481 arg4 = (int)(SWIG_As_int(obj3));
12482 if (SWIG_arg_fail(4)) SWIG_fail;
12483 }
12484 {
12485 arg5 = (int)(SWIG_As_int(obj4));
12486 if (SWIG_arg_fail(5)) SWIG_fail;
12487 }
12488 {
12489 PyThreadState* __tstate = wxPyBeginAllowThreads();
12490 (arg1)->DrawLine(arg2,arg3,arg4,arg5);
12491
12492 wxPyEndAllowThreads(__tstate);
12493 if (PyErr_Occurred()) SWIG_fail;
12494 }
12495 Py_INCREF(Py_None); resultobj = Py_None;
12496 return resultobj;
12497 fail:
12498 return NULL;
12499 }
12500
12501
12502 static PyObject *_wrap_DC_DrawLinePoint(PyObject *, PyObject *args, PyObject *kwargs) {
12503 PyObject *resultobj;
12504 wxDC *arg1 = (wxDC *) 0 ;
12505 wxPoint *arg2 = 0 ;
12506 wxPoint *arg3 = 0 ;
12507 wxPoint temp2 ;
12508 wxPoint temp3 ;
12509 PyObject * obj0 = 0 ;
12510 PyObject * obj1 = 0 ;
12511 PyObject * obj2 = 0 ;
12512 char *kwnames[] = {
12513 (char *) "self",(char *) "pt1",(char *) "pt2", NULL
12514 };
12515
12516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawLinePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
12517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12518 if (SWIG_arg_fail(1)) SWIG_fail;
12519 {
12520 arg2 = &temp2;
12521 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12522 }
12523 {
12524 arg3 = &temp3;
12525 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12526 }
12527 {
12528 PyThreadState* __tstate = wxPyBeginAllowThreads();
12529 (arg1)->DrawLine((wxPoint const &)*arg2,(wxPoint const &)*arg3);
12530
12531 wxPyEndAllowThreads(__tstate);
12532 if (PyErr_Occurred()) SWIG_fail;
12533 }
12534 Py_INCREF(Py_None); resultobj = Py_None;
12535 return resultobj;
12536 fail:
12537 return NULL;
12538 }
12539
12540
12541 static PyObject *_wrap_DC_CrossHair(PyObject *, PyObject *args, PyObject *kwargs) {
12542 PyObject *resultobj;
12543 wxDC *arg1 = (wxDC *) 0 ;
12544 int arg2 ;
12545 int arg3 ;
12546 PyObject * obj0 = 0 ;
12547 PyObject * obj1 = 0 ;
12548 PyObject * obj2 = 0 ;
12549 char *kwnames[] = {
12550 (char *) "self",(char *) "x",(char *) "y", NULL
12551 };
12552
12553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CrossHair",kwnames,&obj0,&obj1,&obj2)) goto fail;
12554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12555 if (SWIG_arg_fail(1)) SWIG_fail;
12556 {
12557 arg2 = (int)(SWIG_As_int(obj1));
12558 if (SWIG_arg_fail(2)) SWIG_fail;
12559 }
12560 {
12561 arg3 = (int)(SWIG_As_int(obj2));
12562 if (SWIG_arg_fail(3)) SWIG_fail;
12563 }
12564 {
12565 PyThreadState* __tstate = wxPyBeginAllowThreads();
12566 (arg1)->CrossHair(arg2,arg3);
12567
12568 wxPyEndAllowThreads(__tstate);
12569 if (PyErr_Occurred()) SWIG_fail;
12570 }
12571 Py_INCREF(Py_None); resultobj = Py_None;
12572 return resultobj;
12573 fail:
12574 return NULL;
12575 }
12576
12577
12578 static PyObject *_wrap_DC_CrossHairPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12579 PyObject *resultobj;
12580 wxDC *arg1 = (wxDC *) 0 ;
12581 wxPoint *arg2 = 0 ;
12582 wxPoint temp2 ;
12583 PyObject * obj0 = 0 ;
12584 PyObject * obj1 = 0 ;
12585 char *kwnames[] = {
12586 (char *) "self",(char *) "pt", NULL
12587 };
12588
12589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CrossHairPoint",kwnames,&obj0,&obj1)) goto fail;
12590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12591 if (SWIG_arg_fail(1)) SWIG_fail;
12592 {
12593 arg2 = &temp2;
12594 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12595 }
12596 {
12597 PyThreadState* __tstate = wxPyBeginAllowThreads();
12598 (arg1)->CrossHair((wxPoint const &)*arg2);
12599
12600 wxPyEndAllowThreads(__tstate);
12601 if (PyErr_Occurred()) SWIG_fail;
12602 }
12603 Py_INCREF(Py_None); resultobj = Py_None;
12604 return resultobj;
12605 fail:
12606 return NULL;
12607 }
12608
12609
12610 static PyObject *_wrap_DC_DrawArc(PyObject *, PyObject *args, PyObject *kwargs) {
12611 PyObject *resultobj;
12612 wxDC *arg1 = (wxDC *) 0 ;
12613 int arg2 ;
12614 int arg3 ;
12615 int arg4 ;
12616 int arg5 ;
12617 int arg6 ;
12618 int arg7 ;
12619 PyObject * obj0 = 0 ;
12620 PyObject * obj1 = 0 ;
12621 PyObject * obj2 = 0 ;
12622 PyObject * obj3 = 0 ;
12623 PyObject * obj4 = 0 ;
12624 PyObject * obj5 = 0 ;
12625 PyObject * obj6 = 0 ;
12626 char *kwnames[] = {
12627 (char *) "self",(char *) "x1",(char *) "y1",(char *) "x2",(char *) "y2",(char *) "xc",(char *) "yc", NULL
12628 };
12629
12630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12632 if (SWIG_arg_fail(1)) SWIG_fail;
12633 {
12634 arg2 = (int)(SWIG_As_int(obj1));
12635 if (SWIG_arg_fail(2)) SWIG_fail;
12636 }
12637 {
12638 arg3 = (int)(SWIG_As_int(obj2));
12639 if (SWIG_arg_fail(3)) SWIG_fail;
12640 }
12641 {
12642 arg4 = (int)(SWIG_As_int(obj3));
12643 if (SWIG_arg_fail(4)) SWIG_fail;
12644 }
12645 {
12646 arg5 = (int)(SWIG_As_int(obj4));
12647 if (SWIG_arg_fail(5)) SWIG_fail;
12648 }
12649 {
12650 arg6 = (int)(SWIG_As_int(obj5));
12651 if (SWIG_arg_fail(6)) SWIG_fail;
12652 }
12653 {
12654 arg7 = (int)(SWIG_As_int(obj6));
12655 if (SWIG_arg_fail(7)) SWIG_fail;
12656 }
12657 {
12658 PyThreadState* __tstate = wxPyBeginAllowThreads();
12659 (arg1)->DrawArc(arg2,arg3,arg4,arg5,arg6,arg7);
12660
12661 wxPyEndAllowThreads(__tstate);
12662 if (PyErr_Occurred()) SWIG_fail;
12663 }
12664 Py_INCREF(Py_None); resultobj = Py_None;
12665 return resultobj;
12666 fail:
12667 return NULL;
12668 }
12669
12670
12671 static PyObject *_wrap_DC_DrawArcPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12672 PyObject *resultobj;
12673 wxDC *arg1 = (wxDC *) 0 ;
12674 wxPoint *arg2 = 0 ;
12675 wxPoint *arg3 = 0 ;
12676 wxPoint *arg4 = 0 ;
12677 wxPoint temp2 ;
12678 wxPoint temp3 ;
12679 wxPoint temp4 ;
12680 PyObject * obj0 = 0 ;
12681 PyObject * obj1 = 0 ;
12682 PyObject * obj2 = 0 ;
12683 PyObject * obj3 = 0 ;
12684 char *kwnames[] = {
12685 (char *) "self",(char *) "pt1",(char *) "pt2",(char *) "center", NULL
12686 };
12687
12688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawArcPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12690 if (SWIG_arg_fail(1)) SWIG_fail;
12691 {
12692 arg2 = &temp2;
12693 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12694 }
12695 {
12696 arg3 = &temp3;
12697 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12698 }
12699 {
12700 arg4 = &temp4;
12701 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
12702 }
12703 {
12704 PyThreadState* __tstate = wxPyBeginAllowThreads();
12705 (arg1)->DrawArc((wxPoint const &)*arg2,(wxPoint const &)*arg3,(wxPoint const &)*arg4);
12706
12707 wxPyEndAllowThreads(__tstate);
12708 if (PyErr_Occurred()) SWIG_fail;
12709 }
12710 Py_INCREF(Py_None); resultobj = Py_None;
12711 return resultobj;
12712 fail:
12713 return NULL;
12714 }
12715
12716
12717 static PyObject *_wrap_DC_DrawCheckMark(PyObject *, PyObject *args, PyObject *kwargs) {
12718 PyObject *resultobj;
12719 wxDC *arg1 = (wxDC *) 0 ;
12720 int arg2 ;
12721 int arg3 ;
12722 int arg4 ;
12723 int arg5 ;
12724 PyObject * obj0 = 0 ;
12725 PyObject * obj1 = 0 ;
12726 PyObject * obj2 = 0 ;
12727 PyObject * obj3 = 0 ;
12728 PyObject * obj4 = 0 ;
12729 char *kwnames[] = {
12730 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
12731 };
12732
12733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawCheckMark",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12735 if (SWIG_arg_fail(1)) SWIG_fail;
12736 {
12737 arg2 = (int)(SWIG_As_int(obj1));
12738 if (SWIG_arg_fail(2)) SWIG_fail;
12739 }
12740 {
12741 arg3 = (int)(SWIG_As_int(obj2));
12742 if (SWIG_arg_fail(3)) SWIG_fail;
12743 }
12744 {
12745 arg4 = (int)(SWIG_As_int(obj3));
12746 if (SWIG_arg_fail(4)) SWIG_fail;
12747 }
12748 {
12749 arg5 = (int)(SWIG_As_int(obj4));
12750 if (SWIG_arg_fail(5)) SWIG_fail;
12751 }
12752 {
12753 PyThreadState* __tstate = wxPyBeginAllowThreads();
12754 (arg1)->DrawCheckMark(arg2,arg3,arg4,arg5);
12755
12756 wxPyEndAllowThreads(__tstate);
12757 if (PyErr_Occurred()) SWIG_fail;
12758 }
12759 Py_INCREF(Py_None); resultobj = Py_None;
12760 return resultobj;
12761 fail:
12762 return NULL;
12763 }
12764
12765
12766 static PyObject *_wrap_DC_DrawCheckMarkRect(PyObject *, PyObject *args, PyObject *kwargs) {
12767 PyObject *resultobj;
12768 wxDC *arg1 = (wxDC *) 0 ;
12769 wxRect *arg2 = 0 ;
12770 wxRect temp2 ;
12771 PyObject * obj0 = 0 ;
12772 PyObject * obj1 = 0 ;
12773 char *kwnames[] = {
12774 (char *) "self",(char *) "rect", NULL
12775 };
12776
12777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawCheckMarkRect",kwnames,&obj0,&obj1)) goto fail;
12778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12779 if (SWIG_arg_fail(1)) SWIG_fail;
12780 {
12781 arg2 = &temp2;
12782 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12783 }
12784 {
12785 PyThreadState* __tstate = wxPyBeginAllowThreads();
12786 (arg1)->DrawCheckMark((wxRect const &)*arg2);
12787
12788 wxPyEndAllowThreads(__tstate);
12789 if (PyErr_Occurred()) SWIG_fail;
12790 }
12791 Py_INCREF(Py_None); resultobj = Py_None;
12792 return resultobj;
12793 fail:
12794 return NULL;
12795 }
12796
12797
12798 static PyObject *_wrap_DC_DrawEllipticArc(PyObject *, PyObject *args, PyObject *kwargs) {
12799 PyObject *resultobj;
12800 wxDC *arg1 = (wxDC *) 0 ;
12801 int arg2 ;
12802 int arg3 ;
12803 int arg4 ;
12804 int arg5 ;
12805 double arg6 ;
12806 double arg7 ;
12807 PyObject * obj0 = 0 ;
12808 PyObject * obj1 = 0 ;
12809 PyObject * obj2 = 0 ;
12810 PyObject * obj3 = 0 ;
12811 PyObject * obj4 = 0 ;
12812 PyObject * obj5 = 0 ;
12813 PyObject * obj6 = 0 ;
12814 char *kwnames[] = {
12815 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h",(char *) "start",(char *) "end", NULL
12816 };
12817
12818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:DC_DrawEllipticArc",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12820 if (SWIG_arg_fail(1)) SWIG_fail;
12821 {
12822 arg2 = (int)(SWIG_As_int(obj1));
12823 if (SWIG_arg_fail(2)) SWIG_fail;
12824 }
12825 {
12826 arg3 = (int)(SWIG_As_int(obj2));
12827 if (SWIG_arg_fail(3)) SWIG_fail;
12828 }
12829 {
12830 arg4 = (int)(SWIG_As_int(obj3));
12831 if (SWIG_arg_fail(4)) SWIG_fail;
12832 }
12833 {
12834 arg5 = (int)(SWIG_As_int(obj4));
12835 if (SWIG_arg_fail(5)) SWIG_fail;
12836 }
12837 {
12838 arg6 = (double)(SWIG_As_double(obj5));
12839 if (SWIG_arg_fail(6)) SWIG_fail;
12840 }
12841 {
12842 arg7 = (double)(SWIG_As_double(obj6));
12843 if (SWIG_arg_fail(7)) SWIG_fail;
12844 }
12845 {
12846 PyThreadState* __tstate = wxPyBeginAllowThreads();
12847 (arg1)->DrawEllipticArc(arg2,arg3,arg4,arg5,arg6,arg7);
12848
12849 wxPyEndAllowThreads(__tstate);
12850 if (PyErr_Occurred()) SWIG_fail;
12851 }
12852 Py_INCREF(Py_None); resultobj = Py_None;
12853 return resultobj;
12854 fail:
12855 return NULL;
12856 }
12857
12858
12859 static PyObject *_wrap_DC_DrawEllipticArcPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
12860 PyObject *resultobj;
12861 wxDC *arg1 = (wxDC *) 0 ;
12862 wxPoint *arg2 = 0 ;
12863 wxSize *arg3 = 0 ;
12864 double arg4 ;
12865 double arg5 ;
12866 wxPoint temp2 ;
12867 wxSize temp3 ;
12868 PyObject * obj0 = 0 ;
12869 PyObject * obj1 = 0 ;
12870 PyObject * obj2 = 0 ;
12871 PyObject * obj3 = 0 ;
12872 PyObject * obj4 = 0 ;
12873 char *kwnames[] = {
12874 (char *) "self",(char *) "pt",(char *) "sz",(char *) "start",(char *) "end", NULL
12875 };
12876
12877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipticArcPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12879 if (SWIG_arg_fail(1)) SWIG_fail;
12880 {
12881 arg2 = &temp2;
12882 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12883 }
12884 {
12885 arg3 = &temp3;
12886 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
12887 }
12888 {
12889 arg4 = (double)(SWIG_As_double(obj3));
12890 if (SWIG_arg_fail(4)) SWIG_fail;
12891 }
12892 {
12893 arg5 = (double)(SWIG_As_double(obj4));
12894 if (SWIG_arg_fail(5)) SWIG_fail;
12895 }
12896 {
12897 PyThreadState* __tstate = wxPyBeginAllowThreads();
12898 (arg1)->DrawEllipticArc((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,arg5);
12899
12900 wxPyEndAllowThreads(__tstate);
12901 if (PyErr_Occurred()) SWIG_fail;
12902 }
12903 Py_INCREF(Py_None); resultobj = Py_None;
12904 return resultobj;
12905 fail:
12906 return NULL;
12907 }
12908
12909
12910 static PyObject *_wrap_DC_DrawPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12911 PyObject *resultobj;
12912 wxDC *arg1 = (wxDC *) 0 ;
12913 int arg2 ;
12914 int arg3 ;
12915 PyObject * obj0 = 0 ;
12916 PyObject * obj1 = 0 ;
12917 PyObject * obj2 = 0 ;
12918 char *kwnames[] = {
12919 (char *) "self",(char *) "x",(char *) "y", NULL
12920 };
12921
12922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
12923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12924 if (SWIG_arg_fail(1)) SWIG_fail;
12925 {
12926 arg2 = (int)(SWIG_As_int(obj1));
12927 if (SWIG_arg_fail(2)) SWIG_fail;
12928 }
12929 {
12930 arg3 = (int)(SWIG_As_int(obj2));
12931 if (SWIG_arg_fail(3)) SWIG_fail;
12932 }
12933 {
12934 PyThreadState* __tstate = wxPyBeginAllowThreads();
12935 (arg1)->DrawPoint(arg2,arg3);
12936
12937 wxPyEndAllowThreads(__tstate);
12938 if (PyErr_Occurred()) SWIG_fail;
12939 }
12940 Py_INCREF(Py_None); resultobj = Py_None;
12941 return resultobj;
12942 fail:
12943 return NULL;
12944 }
12945
12946
12947 static PyObject *_wrap_DC_DrawPointPoint(PyObject *, PyObject *args, PyObject *kwargs) {
12948 PyObject *resultobj;
12949 wxDC *arg1 = (wxDC *) 0 ;
12950 wxPoint *arg2 = 0 ;
12951 wxPoint temp2 ;
12952 PyObject * obj0 = 0 ;
12953 PyObject * obj1 = 0 ;
12954 char *kwnames[] = {
12955 (char *) "self",(char *) "pt", NULL
12956 };
12957
12958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawPointPoint",kwnames,&obj0,&obj1)) goto fail;
12959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12960 if (SWIG_arg_fail(1)) SWIG_fail;
12961 {
12962 arg2 = &temp2;
12963 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12964 }
12965 {
12966 PyThreadState* __tstate = wxPyBeginAllowThreads();
12967 (arg1)->DrawPoint((wxPoint const &)*arg2);
12968
12969 wxPyEndAllowThreads(__tstate);
12970 if (PyErr_Occurred()) SWIG_fail;
12971 }
12972 Py_INCREF(Py_None); resultobj = Py_None;
12973 return resultobj;
12974 fail:
12975 return NULL;
12976 }
12977
12978
12979 static PyObject *_wrap_DC_DrawRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
12980 PyObject *resultobj;
12981 wxDC *arg1 = (wxDC *) 0 ;
12982 int arg2 ;
12983 int arg3 ;
12984 int arg4 ;
12985 int arg5 ;
12986 PyObject * obj0 = 0 ;
12987 PyObject * obj1 = 0 ;
12988 PyObject * obj2 = 0 ;
12989 PyObject * obj3 = 0 ;
12990 PyObject * obj4 = 0 ;
12991 char *kwnames[] = {
12992 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
12993 };
12994
12995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
12997 if (SWIG_arg_fail(1)) SWIG_fail;
12998 {
12999 arg2 = (int)(SWIG_As_int(obj1));
13000 if (SWIG_arg_fail(2)) SWIG_fail;
13001 }
13002 {
13003 arg3 = (int)(SWIG_As_int(obj2));
13004 if (SWIG_arg_fail(3)) SWIG_fail;
13005 }
13006 {
13007 arg4 = (int)(SWIG_As_int(obj3));
13008 if (SWIG_arg_fail(4)) SWIG_fail;
13009 }
13010 {
13011 arg5 = (int)(SWIG_As_int(obj4));
13012 if (SWIG_arg_fail(5)) SWIG_fail;
13013 }
13014 {
13015 PyThreadState* __tstate = wxPyBeginAllowThreads();
13016 (arg1)->DrawRectangle(arg2,arg3,arg4,arg5);
13017
13018 wxPyEndAllowThreads(__tstate);
13019 if (PyErr_Occurred()) SWIG_fail;
13020 }
13021 Py_INCREF(Py_None); resultobj = Py_None;
13022 return resultobj;
13023 fail:
13024 return NULL;
13025 }
13026
13027
13028 static PyObject *_wrap_DC_DrawRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13029 PyObject *resultobj;
13030 wxDC *arg1 = (wxDC *) 0 ;
13031 wxRect *arg2 = 0 ;
13032 wxRect temp2 ;
13033 PyObject * obj0 = 0 ;
13034 PyObject * obj1 = 0 ;
13035 char *kwnames[] = {
13036 (char *) "self",(char *) "rect", NULL
13037 };
13038
13039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawRectangleRect",kwnames,&obj0,&obj1)) goto fail;
13040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13041 if (SWIG_arg_fail(1)) SWIG_fail;
13042 {
13043 arg2 = &temp2;
13044 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13045 }
13046 {
13047 PyThreadState* __tstate = wxPyBeginAllowThreads();
13048 (arg1)->DrawRectangle((wxRect const &)*arg2);
13049
13050 wxPyEndAllowThreads(__tstate);
13051 if (PyErr_Occurred()) SWIG_fail;
13052 }
13053 Py_INCREF(Py_None); resultobj = Py_None;
13054 return resultobj;
13055 fail:
13056 return NULL;
13057 }
13058
13059
13060 static PyObject *_wrap_DC_DrawRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13061 PyObject *resultobj;
13062 wxDC *arg1 = (wxDC *) 0 ;
13063 wxPoint *arg2 = 0 ;
13064 wxSize *arg3 = 0 ;
13065 wxPoint temp2 ;
13066 wxSize temp3 ;
13067 PyObject * obj0 = 0 ;
13068 PyObject * obj1 = 0 ;
13069 PyObject * obj2 = 0 ;
13070 char *kwnames[] = {
13071 (char *) "self",(char *) "pt",(char *) "sz", NULL
13072 };
13073
13074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRectanglePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13076 if (SWIG_arg_fail(1)) SWIG_fail;
13077 {
13078 arg2 = &temp2;
13079 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13080 }
13081 {
13082 arg3 = &temp3;
13083 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13084 }
13085 {
13086 PyThreadState* __tstate = wxPyBeginAllowThreads();
13087 (arg1)->DrawRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3);
13088
13089 wxPyEndAllowThreads(__tstate);
13090 if (PyErr_Occurred()) SWIG_fail;
13091 }
13092 Py_INCREF(Py_None); resultobj = Py_None;
13093 return resultobj;
13094 fail:
13095 return NULL;
13096 }
13097
13098
13099 static PyObject *_wrap_DC_DrawRoundedRectangle(PyObject *, PyObject *args, PyObject *kwargs) {
13100 PyObject *resultobj;
13101 wxDC *arg1 = (wxDC *) 0 ;
13102 int arg2 ;
13103 int arg3 ;
13104 int arg4 ;
13105 int arg5 ;
13106 double arg6 ;
13107 PyObject * obj0 = 0 ;
13108 PyObject * obj1 = 0 ;
13109 PyObject * obj2 = 0 ;
13110 PyObject * obj3 = 0 ;
13111 PyObject * obj4 = 0 ;
13112 PyObject * obj5 = 0 ;
13113 char *kwnames[] = {
13114 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "radius", NULL
13115 };
13116
13117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:DC_DrawRoundedRectangle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
13118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13119 if (SWIG_arg_fail(1)) SWIG_fail;
13120 {
13121 arg2 = (int)(SWIG_As_int(obj1));
13122 if (SWIG_arg_fail(2)) SWIG_fail;
13123 }
13124 {
13125 arg3 = (int)(SWIG_As_int(obj2));
13126 if (SWIG_arg_fail(3)) SWIG_fail;
13127 }
13128 {
13129 arg4 = (int)(SWIG_As_int(obj3));
13130 if (SWIG_arg_fail(4)) SWIG_fail;
13131 }
13132 {
13133 arg5 = (int)(SWIG_As_int(obj4));
13134 if (SWIG_arg_fail(5)) SWIG_fail;
13135 }
13136 {
13137 arg6 = (double)(SWIG_As_double(obj5));
13138 if (SWIG_arg_fail(6)) SWIG_fail;
13139 }
13140 {
13141 PyThreadState* __tstate = wxPyBeginAllowThreads();
13142 (arg1)->DrawRoundedRectangle(arg2,arg3,arg4,arg5,arg6);
13143
13144 wxPyEndAllowThreads(__tstate);
13145 if (PyErr_Occurred()) SWIG_fail;
13146 }
13147 Py_INCREF(Py_None); resultobj = Py_None;
13148 return resultobj;
13149 fail:
13150 return NULL;
13151 }
13152
13153
13154 static PyObject *_wrap_DC_DrawRoundedRectangleRect(PyObject *, PyObject *args, PyObject *kwargs) {
13155 PyObject *resultobj;
13156 wxDC *arg1 = (wxDC *) 0 ;
13157 wxRect *arg2 = 0 ;
13158 double arg3 ;
13159 wxRect temp2 ;
13160 PyObject * obj0 = 0 ;
13161 PyObject * obj1 = 0 ;
13162 PyObject * obj2 = 0 ;
13163 char *kwnames[] = {
13164 (char *) "self",(char *) "r",(char *) "radius", NULL
13165 };
13166
13167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawRoundedRectangleRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
13168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13169 if (SWIG_arg_fail(1)) SWIG_fail;
13170 {
13171 arg2 = &temp2;
13172 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13173 }
13174 {
13175 arg3 = (double)(SWIG_As_double(obj2));
13176 if (SWIG_arg_fail(3)) SWIG_fail;
13177 }
13178 {
13179 PyThreadState* __tstate = wxPyBeginAllowThreads();
13180 (arg1)->DrawRoundedRectangle((wxRect const &)*arg2,arg3);
13181
13182 wxPyEndAllowThreads(__tstate);
13183 if (PyErr_Occurred()) SWIG_fail;
13184 }
13185 Py_INCREF(Py_None); resultobj = Py_None;
13186 return resultobj;
13187 fail:
13188 return NULL;
13189 }
13190
13191
13192 static PyObject *_wrap_DC_DrawRoundedRectanglePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13193 PyObject *resultobj;
13194 wxDC *arg1 = (wxDC *) 0 ;
13195 wxPoint *arg2 = 0 ;
13196 wxSize *arg3 = 0 ;
13197 double arg4 ;
13198 wxPoint temp2 ;
13199 wxSize temp3 ;
13200 PyObject * obj0 = 0 ;
13201 PyObject * obj1 = 0 ;
13202 PyObject * obj2 = 0 ;
13203 PyObject * obj3 = 0 ;
13204 char *kwnames[] = {
13205 (char *) "self",(char *) "pt",(char *) "sz",(char *) "radius", NULL
13206 };
13207
13208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRoundedRectanglePointSize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13210 if (SWIG_arg_fail(1)) SWIG_fail;
13211 {
13212 arg2 = &temp2;
13213 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13214 }
13215 {
13216 arg3 = &temp3;
13217 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13218 }
13219 {
13220 arg4 = (double)(SWIG_As_double(obj3));
13221 if (SWIG_arg_fail(4)) SWIG_fail;
13222 }
13223 {
13224 PyThreadState* __tstate = wxPyBeginAllowThreads();
13225 (arg1)->DrawRoundedRectangle((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4);
13226
13227 wxPyEndAllowThreads(__tstate);
13228 if (PyErr_Occurred()) SWIG_fail;
13229 }
13230 Py_INCREF(Py_None); resultobj = Py_None;
13231 return resultobj;
13232 fail:
13233 return NULL;
13234 }
13235
13236
13237 static PyObject *_wrap_DC_DrawCircle(PyObject *, PyObject *args, PyObject *kwargs) {
13238 PyObject *resultobj;
13239 wxDC *arg1 = (wxDC *) 0 ;
13240 int arg2 ;
13241 int arg3 ;
13242 int arg4 ;
13243 PyObject * obj0 = 0 ;
13244 PyObject * obj1 = 0 ;
13245 PyObject * obj2 = 0 ;
13246 PyObject * obj3 = 0 ;
13247 char *kwnames[] = {
13248 (char *) "self",(char *) "x",(char *) "y",(char *) "radius", NULL
13249 };
13250
13251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawCircle",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13253 if (SWIG_arg_fail(1)) SWIG_fail;
13254 {
13255 arg2 = (int)(SWIG_As_int(obj1));
13256 if (SWIG_arg_fail(2)) SWIG_fail;
13257 }
13258 {
13259 arg3 = (int)(SWIG_As_int(obj2));
13260 if (SWIG_arg_fail(3)) SWIG_fail;
13261 }
13262 {
13263 arg4 = (int)(SWIG_As_int(obj3));
13264 if (SWIG_arg_fail(4)) SWIG_fail;
13265 }
13266 {
13267 PyThreadState* __tstate = wxPyBeginAllowThreads();
13268 (arg1)->DrawCircle(arg2,arg3,arg4);
13269
13270 wxPyEndAllowThreads(__tstate);
13271 if (PyErr_Occurred()) SWIG_fail;
13272 }
13273 Py_INCREF(Py_None); resultobj = Py_None;
13274 return resultobj;
13275 fail:
13276 return NULL;
13277 }
13278
13279
13280 static PyObject *_wrap_DC_DrawCirclePoint(PyObject *, PyObject *args, PyObject *kwargs) {
13281 PyObject *resultobj;
13282 wxDC *arg1 = (wxDC *) 0 ;
13283 wxPoint *arg2 = 0 ;
13284 int arg3 ;
13285 wxPoint temp2 ;
13286 PyObject * obj0 = 0 ;
13287 PyObject * obj1 = 0 ;
13288 PyObject * obj2 = 0 ;
13289 char *kwnames[] = {
13290 (char *) "self",(char *) "pt",(char *) "radius", NULL
13291 };
13292
13293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawCirclePoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13295 if (SWIG_arg_fail(1)) SWIG_fail;
13296 {
13297 arg2 = &temp2;
13298 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13299 }
13300 {
13301 arg3 = (int)(SWIG_As_int(obj2));
13302 if (SWIG_arg_fail(3)) SWIG_fail;
13303 }
13304 {
13305 PyThreadState* __tstate = wxPyBeginAllowThreads();
13306 (arg1)->DrawCircle((wxPoint const &)*arg2,arg3);
13307
13308 wxPyEndAllowThreads(__tstate);
13309 if (PyErr_Occurred()) SWIG_fail;
13310 }
13311 Py_INCREF(Py_None); resultobj = Py_None;
13312 return resultobj;
13313 fail:
13314 return NULL;
13315 }
13316
13317
13318 static PyObject *_wrap_DC_DrawEllipse(PyObject *, PyObject *args, PyObject *kwargs) {
13319 PyObject *resultobj;
13320 wxDC *arg1 = (wxDC *) 0 ;
13321 int arg2 ;
13322 int arg3 ;
13323 int arg4 ;
13324 int arg5 ;
13325 PyObject * obj0 = 0 ;
13326 PyObject * obj1 = 0 ;
13327 PyObject * obj2 = 0 ;
13328 PyObject * obj3 = 0 ;
13329 PyObject * obj4 = 0 ;
13330 char *kwnames[] = {
13331 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
13332 };
13333
13334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawEllipse",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13336 if (SWIG_arg_fail(1)) SWIG_fail;
13337 {
13338 arg2 = (int)(SWIG_As_int(obj1));
13339 if (SWIG_arg_fail(2)) SWIG_fail;
13340 }
13341 {
13342 arg3 = (int)(SWIG_As_int(obj2));
13343 if (SWIG_arg_fail(3)) SWIG_fail;
13344 }
13345 {
13346 arg4 = (int)(SWIG_As_int(obj3));
13347 if (SWIG_arg_fail(4)) SWIG_fail;
13348 }
13349 {
13350 arg5 = (int)(SWIG_As_int(obj4));
13351 if (SWIG_arg_fail(5)) SWIG_fail;
13352 }
13353 {
13354 PyThreadState* __tstate = wxPyBeginAllowThreads();
13355 (arg1)->DrawEllipse(arg2,arg3,arg4,arg5);
13356
13357 wxPyEndAllowThreads(__tstate);
13358 if (PyErr_Occurred()) SWIG_fail;
13359 }
13360 Py_INCREF(Py_None); resultobj = Py_None;
13361 return resultobj;
13362 fail:
13363 return NULL;
13364 }
13365
13366
13367 static PyObject *_wrap_DC_DrawEllipseRect(PyObject *, PyObject *args, PyObject *kwargs) {
13368 PyObject *resultobj;
13369 wxDC *arg1 = (wxDC *) 0 ;
13370 wxRect *arg2 = 0 ;
13371 wxRect temp2 ;
13372 PyObject * obj0 = 0 ;
13373 PyObject * obj1 = 0 ;
13374 char *kwnames[] = {
13375 (char *) "self",(char *) "rect", NULL
13376 };
13377
13378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawEllipseRect",kwnames,&obj0,&obj1)) goto fail;
13379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13380 if (SWIG_arg_fail(1)) SWIG_fail;
13381 {
13382 arg2 = &temp2;
13383 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13384 }
13385 {
13386 PyThreadState* __tstate = wxPyBeginAllowThreads();
13387 (arg1)->DrawEllipse((wxRect const &)*arg2);
13388
13389 wxPyEndAllowThreads(__tstate);
13390 if (PyErr_Occurred()) SWIG_fail;
13391 }
13392 Py_INCREF(Py_None); resultobj = Py_None;
13393 return resultobj;
13394 fail:
13395 return NULL;
13396 }
13397
13398
13399 static PyObject *_wrap_DC_DrawEllipsePointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13400 PyObject *resultobj;
13401 wxDC *arg1 = (wxDC *) 0 ;
13402 wxPoint *arg2 = 0 ;
13403 wxSize *arg3 = 0 ;
13404 wxPoint temp2 ;
13405 wxSize temp3 ;
13406 PyObject * obj0 = 0 ;
13407 PyObject * obj1 = 0 ;
13408 PyObject * obj2 = 0 ;
13409 char *kwnames[] = {
13410 (char *) "self",(char *) "pt",(char *) "sz", NULL
13411 };
13412
13413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawEllipsePointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
13414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13415 if (SWIG_arg_fail(1)) SWIG_fail;
13416 {
13417 arg2 = &temp2;
13418 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13419 }
13420 {
13421 arg3 = &temp3;
13422 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13423 }
13424 {
13425 PyThreadState* __tstate = wxPyBeginAllowThreads();
13426 (arg1)->DrawEllipse((wxPoint const &)*arg2,(wxSize const &)*arg3);
13427
13428 wxPyEndAllowThreads(__tstate);
13429 if (PyErr_Occurred()) SWIG_fail;
13430 }
13431 Py_INCREF(Py_None); resultobj = Py_None;
13432 return resultobj;
13433 fail:
13434 return NULL;
13435 }
13436
13437
13438 static PyObject *_wrap_DC_DrawIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13439 PyObject *resultobj;
13440 wxDC *arg1 = (wxDC *) 0 ;
13441 wxIcon *arg2 = 0 ;
13442 int arg3 ;
13443 int arg4 ;
13444 PyObject * obj0 = 0 ;
13445 PyObject * obj1 = 0 ;
13446 PyObject * obj2 = 0 ;
13447 PyObject * obj3 = 0 ;
13448 char *kwnames[] = {
13449 (char *) "self",(char *) "icon",(char *) "x",(char *) "y", NULL
13450 };
13451
13452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawIcon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13454 if (SWIG_arg_fail(1)) SWIG_fail;
13455 {
13456 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
13457 if (SWIG_arg_fail(2)) SWIG_fail;
13458 if (arg2 == NULL) {
13459 SWIG_null_ref("wxIcon");
13460 }
13461 if (SWIG_arg_fail(2)) SWIG_fail;
13462 }
13463 {
13464 arg3 = (int)(SWIG_As_int(obj2));
13465 if (SWIG_arg_fail(3)) SWIG_fail;
13466 }
13467 {
13468 arg4 = (int)(SWIG_As_int(obj3));
13469 if (SWIG_arg_fail(4)) SWIG_fail;
13470 }
13471 {
13472 PyThreadState* __tstate = wxPyBeginAllowThreads();
13473 (arg1)->DrawIcon((wxIcon const &)*arg2,arg3,arg4);
13474
13475 wxPyEndAllowThreads(__tstate);
13476 if (PyErr_Occurred()) SWIG_fail;
13477 }
13478 Py_INCREF(Py_None); resultobj = Py_None;
13479 return resultobj;
13480 fail:
13481 return NULL;
13482 }
13483
13484
13485 static PyObject *_wrap_DC_DrawIconPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13486 PyObject *resultobj;
13487 wxDC *arg1 = (wxDC *) 0 ;
13488 wxIcon *arg2 = 0 ;
13489 wxPoint *arg3 = 0 ;
13490 wxPoint temp3 ;
13491 PyObject * obj0 = 0 ;
13492 PyObject * obj1 = 0 ;
13493 PyObject * obj2 = 0 ;
13494 char *kwnames[] = {
13495 (char *) "self",(char *) "icon",(char *) "pt", NULL
13496 };
13497
13498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawIconPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13500 if (SWIG_arg_fail(1)) SWIG_fail;
13501 {
13502 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
13503 if (SWIG_arg_fail(2)) SWIG_fail;
13504 if (arg2 == NULL) {
13505 SWIG_null_ref("wxIcon");
13506 }
13507 if (SWIG_arg_fail(2)) SWIG_fail;
13508 }
13509 {
13510 arg3 = &temp3;
13511 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13512 }
13513 {
13514 PyThreadState* __tstate = wxPyBeginAllowThreads();
13515 (arg1)->DrawIcon((wxIcon const &)*arg2,(wxPoint const &)*arg3);
13516
13517 wxPyEndAllowThreads(__tstate);
13518 if (PyErr_Occurred()) SWIG_fail;
13519 }
13520 Py_INCREF(Py_None); resultobj = Py_None;
13521 return resultobj;
13522 fail:
13523 return NULL;
13524 }
13525
13526
13527 static PyObject *_wrap_DC_DrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13528 PyObject *resultobj;
13529 wxDC *arg1 = (wxDC *) 0 ;
13530 wxBitmap *arg2 = 0 ;
13531 int arg3 ;
13532 int arg4 ;
13533 bool arg5 = (bool) false ;
13534 PyObject * obj0 = 0 ;
13535 PyObject * obj1 = 0 ;
13536 PyObject * obj2 = 0 ;
13537 PyObject * obj3 = 0 ;
13538 PyObject * obj4 = 0 ;
13539 char *kwnames[] = {
13540 (char *) "self",(char *) "bmp",(char *) "x",(char *) "y",(char *) "useMask", NULL
13541 };
13542
13543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:DC_DrawBitmap",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13545 if (SWIG_arg_fail(1)) SWIG_fail;
13546 {
13547 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
13548 if (SWIG_arg_fail(2)) SWIG_fail;
13549 if (arg2 == NULL) {
13550 SWIG_null_ref("wxBitmap");
13551 }
13552 if (SWIG_arg_fail(2)) SWIG_fail;
13553 }
13554 {
13555 arg3 = (int)(SWIG_As_int(obj2));
13556 if (SWIG_arg_fail(3)) SWIG_fail;
13557 }
13558 {
13559 arg4 = (int)(SWIG_As_int(obj3));
13560 if (SWIG_arg_fail(4)) SWIG_fail;
13561 }
13562 if (obj4) {
13563 {
13564 arg5 = (bool)(SWIG_As_bool(obj4));
13565 if (SWIG_arg_fail(5)) SWIG_fail;
13566 }
13567 }
13568 {
13569 PyThreadState* __tstate = wxPyBeginAllowThreads();
13570 (arg1)->DrawBitmap((wxBitmap const &)*arg2,arg3,arg4,arg5);
13571
13572 wxPyEndAllowThreads(__tstate);
13573 if (PyErr_Occurred()) SWIG_fail;
13574 }
13575 Py_INCREF(Py_None); resultobj = Py_None;
13576 return resultobj;
13577 fail:
13578 return NULL;
13579 }
13580
13581
13582 static PyObject *_wrap_DC_DrawBitmapPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13583 PyObject *resultobj;
13584 wxDC *arg1 = (wxDC *) 0 ;
13585 wxBitmap *arg2 = 0 ;
13586 wxPoint *arg3 = 0 ;
13587 bool arg4 = (bool) false ;
13588 wxPoint temp3 ;
13589 PyObject * obj0 = 0 ;
13590 PyObject * obj1 = 0 ;
13591 PyObject * obj2 = 0 ;
13592 PyObject * obj3 = 0 ;
13593 char *kwnames[] = {
13594 (char *) "self",(char *) "bmp",(char *) "pt",(char *) "useMask", NULL
13595 };
13596
13597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DC_DrawBitmapPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13599 if (SWIG_arg_fail(1)) SWIG_fail;
13600 {
13601 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
13602 if (SWIG_arg_fail(2)) SWIG_fail;
13603 if (arg2 == NULL) {
13604 SWIG_null_ref("wxBitmap");
13605 }
13606 if (SWIG_arg_fail(2)) SWIG_fail;
13607 }
13608 {
13609 arg3 = &temp3;
13610 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13611 }
13612 if (obj3) {
13613 {
13614 arg4 = (bool)(SWIG_As_bool(obj3));
13615 if (SWIG_arg_fail(4)) SWIG_fail;
13616 }
13617 }
13618 {
13619 PyThreadState* __tstate = wxPyBeginAllowThreads();
13620 (arg1)->DrawBitmap((wxBitmap const &)*arg2,(wxPoint const &)*arg3,arg4);
13621
13622 wxPyEndAllowThreads(__tstate);
13623 if (PyErr_Occurred()) SWIG_fail;
13624 }
13625 Py_INCREF(Py_None); resultobj = Py_None;
13626 return resultobj;
13627 fail:
13628 return NULL;
13629 }
13630
13631
13632 static PyObject *_wrap_DC_DrawText(PyObject *, PyObject *args, PyObject *kwargs) {
13633 PyObject *resultobj;
13634 wxDC *arg1 = (wxDC *) 0 ;
13635 wxString *arg2 = 0 ;
13636 int arg3 ;
13637 int arg4 ;
13638 bool temp2 = false ;
13639 PyObject * obj0 = 0 ;
13640 PyObject * obj1 = 0 ;
13641 PyObject * obj2 = 0 ;
13642 PyObject * obj3 = 0 ;
13643 char *kwnames[] = {
13644 (char *) "self",(char *) "text",(char *) "x",(char *) "y", NULL
13645 };
13646
13647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawText",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13649 if (SWIG_arg_fail(1)) SWIG_fail;
13650 {
13651 arg2 = wxString_in_helper(obj1);
13652 if (arg2 == NULL) SWIG_fail;
13653 temp2 = true;
13654 }
13655 {
13656 arg3 = (int)(SWIG_As_int(obj2));
13657 if (SWIG_arg_fail(3)) SWIG_fail;
13658 }
13659 {
13660 arg4 = (int)(SWIG_As_int(obj3));
13661 if (SWIG_arg_fail(4)) SWIG_fail;
13662 }
13663 {
13664 PyThreadState* __tstate = wxPyBeginAllowThreads();
13665 (arg1)->DrawText((wxString const &)*arg2,arg3,arg4);
13666
13667 wxPyEndAllowThreads(__tstate);
13668 if (PyErr_Occurred()) SWIG_fail;
13669 }
13670 Py_INCREF(Py_None); resultobj = Py_None;
13671 {
13672 if (temp2)
13673 delete arg2;
13674 }
13675 return resultobj;
13676 fail:
13677 {
13678 if (temp2)
13679 delete arg2;
13680 }
13681 return NULL;
13682 }
13683
13684
13685 static PyObject *_wrap_DC_DrawTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13686 PyObject *resultobj;
13687 wxDC *arg1 = (wxDC *) 0 ;
13688 wxString *arg2 = 0 ;
13689 wxPoint *arg3 = 0 ;
13690 bool temp2 = false ;
13691 wxPoint temp3 ;
13692 PyObject * obj0 = 0 ;
13693 PyObject * obj1 = 0 ;
13694 PyObject * obj2 = 0 ;
13695 char *kwnames[] = {
13696 (char *) "self",(char *) "text",(char *) "pt", NULL
13697 };
13698
13699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_DrawTextPoint",kwnames,&obj0,&obj1,&obj2)) goto fail;
13700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13701 if (SWIG_arg_fail(1)) SWIG_fail;
13702 {
13703 arg2 = wxString_in_helper(obj1);
13704 if (arg2 == NULL) SWIG_fail;
13705 temp2 = true;
13706 }
13707 {
13708 arg3 = &temp3;
13709 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13710 }
13711 {
13712 PyThreadState* __tstate = wxPyBeginAllowThreads();
13713 (arg1)->DrawText((wxString const &)*arg2,(wxPoint const &)*arg3);
13714
13715 wxPyEndAllowThreads(__tstate);
13716 if (PyErr_Occurred()) SWIG_fail;
13717 }
13718 Py_INCREF(Py_None); resultobj = Py_None;
13719 {
13720 if (temp2)
13721 delete arg2;
13722 }
13723 return resultobj;
13724 fail:
13725 {
13726 if (temp2)
13727 delete arg2;
13728 }
13729 return NULL;
13730 }
13731
13732
13733 static PyObject *_wrap_DC_DrawRotatedText(PyObject *, PyObject *args, PyObject *kwargs) {
13734 PyObject *resultobj;
13735 wxDC *arg1 = (wxDC *) 0 ;
13736 wxString *arg2 = 0 ;
13737 int arg3 ;
13738 int arg4 ;
13739 double arg5 ;
13740 bool temp2 = false ;
13741 PyObject * obj0 = 0 ;
13742 PyObject * obj1 = 0 ;
13743 PyObject * obj2 = 0 ;
13744 PyObject * obj3 = 0 ;
13745 PyObject * obj4 = 0 ;
13746 char *kwnames[] = {
13747 (char *) "self",(char *) "text",(char *) "x",(char *) "y",(char *) "angle", NULL
13748 };
13749
13750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_DrawRotatedText",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13752 if (SWIG_arg_fail(1)) SWIG_fail;
13753 {
13754 arg2 = wxString_in_helper(obj1);
13755 if (arg2 == NULL) SWIG_fail;
13756 temp2 = true;
13757 }
13758 {
13759 arg3 = (int)(SWIG_As_int(obj2));
13760 if (SWIG_arg_fail(3)) SWIG_fail;
13761 }
13762 {
13763 arg4 = (int)(SWIG_As_int(obj3));
13764 if (SWIG_arg_fail(4)) SWIG_fail;
13765 }
13766 {
13767 arg5 = (double)(SWIG_As_double(obj4));
13768 if (SWIG_arg_fail(5)) SWIG_fail;
13769 }
13770 {
13771 PyThreadState* __tstate = wxPyBeginAllowThreads();
13772 (arg1)->DrawRotatedText((wxString const &)*arg2,arg3,arg4,arg5);
13773
13774 wxPyEndAllowThreads(__tstate);
13775 if (PyErr_Occurred()) SWIG_fail;
13776 }
13777 Py_INCREF(Py_None); resultobj = Py_None;
13778 {
13779 if (temp2)
13780 delete arg2;
13781 }
13782 return resultobj;
13783 fail:
13784 {
13785 if (temp2)
13786 delete arg2;
13787 }
13788 return NULL;
13789 }
13790
13791
13792 static PyObject *_wrap_DC_DrawRotatedTextPoint(PyObject *, PyObject *args, PyObject *kwargs) {
13793 PyObject *resultobj;
13794 wxDC *arg1 = (wxDC *) 0 ;
13795 wxString *arg2 = 0 ;
13796 wxPoint *arg3 = 0 ;
13797 double arg4 ;
13798 bool temp2 = false ;
13799 wxPoint temp3 ;
13800 PyObject * obj0 = 0 ;
13801 PyObject * obj1 = 0 ;
13802 PyObject * obj2 = 0 ;
13803 PyObject * obj3 = 0 ;
13804 char *kwnames[] = {
13805 (char *) "self",(char *) "text",(char *) "pt",(char *) "angle", NULL
13806 };
13807
13808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC_DrawRotatedTextPoint",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13810 if (SWIG_arg_fail(1)) SWIG_fail;
13811 {
13812 arg2 = wxString_in_helper(obj1);
13813 if (arg2 == NULL) SWIG_fail;
13814 temp2 = true;
13815 }
13816 {
13817 arg3 = &temp3;
13818 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13819 }
13820 {
13821 arg4 = (double)(SWIG_As_double(obj3));
13822 if (SWIG_arg_fail(4)) SWIG_fail;
13823 }
13824 {
13825 PyThreadState* __tstate = wxPyBeginAllowThreads();
13826 (arg1)->DrawRotatedText((wxString const &)*arg2,(wxPoint const &)*arg3,arg4);
13827
13828 wxPyEndAllowThreads(__tstate);
13829 if (PyErr_Occurred()) SWIG_fail;
13830 }
13831 Py_INCREF(Py_None); resultobj = Py_None;
13832 {
13833 if (temp2)
13834 delete arg2;
13835 }
13836 return resultobj;
13837 fail:
13838 {
13839 if (temp2)
13840 delete arg2;
13841 }
13842 return NULL;
13843 }
13844
13845
13846 static PyObject *_wrap_DC_Blit(PyObject *, PyObject *args, PyObject *kwargs) {
13847 PyObject *resultobj;
13848 wxDC *arg1 = (wxDC *) 0 ;
13849 int arg2 ;
13850 int arg3 ;
13851 int arg4 ;
13852 int arg5 ;
13853 wxDC *arg6 = (wxDC *) 0 ;
13854 int arg7 ;
13855 int arg8 ;
13856 int arg9 = (int) wxCOPY ;
13857 bool arg10 = (bool) false ;
13858 int arg11 = (int) -1 ;
13859 int arg12 = (int) -1 ;
13860 bool result;
13861 PyObject * obj0 = 0 ;
13862 PyObject * obj1 = 0 ;
13863 PyObject * obj2 = 0 ;
13864 PyObject * obj3 = 0 ;
13865 PyObject * obj4 = 0 ;
13866 PyObject * obj5 = 0 ;
13867 PyObject * obj6 = 0 ;
13868 PyObject * obj7 = 0 ;
13869 PyObject * obj8 = 0 ;
13870 PyObject * obj9 = 0 ;
13871 PyObject * obj10 = 0 ;
13872 PyObject * obj11 = 0 ;
13873 char *kwnames[] = {
13874 (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
13875 };
13876
13877 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;
13878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13879 if (SWIG_arg_fail(1)) SWIG_fail;
13880 {
13881 arg2 = (int)(SWIG_As_int(obj1));
13882 if (SWIG_arg_fail(2)) SWIG_fail;
13883 }
13884 {
13885 arg3 = (int)(SWIG_As_int(obj2));
13886 if (SWIG_arg_fail(3)) SWIG_fail;
13887 }
13888 {
13889 arg4 = (int)(SWIG_As_int(obj3));
13890 if (SWIG_arg_fail(4)) SWIG_fail;
13891 }
13892 {
13893 arg5 = (int)(SWIG_As_int(obj4));
13894 if (SWIG_arg_fail(5)) SWIG_fail;
13895 }
13896 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13897 if (SWIG_arg_fail(6)) SWIG_fail;
13898 {
13899 arg7 = (int)(SWIG_As_int(obj6));
13900 if (SWIG_arg_fail(7)) SWIG_fail;
13901 }
13902 {
13903 arg8 = (int)(SWIG_As_int(obj7));
13904 if (SWIG_arg_fail(8)) SWIG_fail;
13905 }
13906 if (obj8) {
13907 {
13908 arg9 = (int)(SWIG_As_int(obj8));
13909 if (SWIG_arg_fail(9)) SWIG_fail;
13910 }
13911 }
13912 if (obj9) {
13913 {
13914 arg10 = (bool)(SWIG_As_bool(obj9));
13915 if (SWIG_arg_fail(10)) SWIG_fail;
13916 }
13917 }
13918 if (obj10) {
13919 {
13920 arg11 = (int)(SWIG_As_int(obj10));
13921 if (SWIG_arg_fail(11)) SWIG_fail;
13922 }
13923 }
13924 if (obj11) {
13925 {
13926 arg12 = (int)(SWIG_As_int(obj11));
13927 if (SWIG_arg_fail(12)) SWIG_fail;
13928 }
13929 }
13930 {
13931 PyThreadState* __tstate = wxPyBeginAllowThreads();
13932 result = (bool)(arg1)->Blit(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
13933
13934 wxPyEndAllowThreads(__tstate);
13935 if (PyErr_Occurred()) SWIG_fail;
13936 }
13937 {
13938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13939 }
13940 return resultobj;
13941 fail:
13942 return NULL;
13943 }
13944
13945
13946 static PyObject *_wrap_DC_BlitPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
13947 PyObject *resultobj;
13948 wxDC *arg1 = (wxDC *) 0 ;
13949 wxPoint *arg2 = 0 ;
13950 wxSize *arg3 = 0 ;
13951 wxDC *arg4 = (wxDC *) 0 ;
13952 wxPoint *arg5 = 0 ;
13953 int arg6 = (int) wxCOPY ;
13954 bool arg7 = (bool) false ;
13955 wxPoint const &arg8_defvalue = wxDefaultPosition ;
13956 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
13957 bool result;
13958 wxPoint temp2 ;
13959 wxSize temp3 ;
13960 wxPoint temp5 ;
13961 wxPoint temp8 ;
13962 PyObject * obj0 = 0 ;
13963 PyObject * obj1 = 0 ;
13964 PyObject * obj2 = 0 ;
13965 PyObject * obj3 = 0 ;
13966 PyObject * obj4 = 0 ;
13967 PyObject * obj5 = 0 ;
13968 PyObject * obj6 = 0 ;
13969 PyObject * obj7 = 0 ;
13970 char *kwnames[] = {
13971 (char *) "self",(char *) "destPt",(char *) "sz",(char *) "source",(char *) "srcPt",(char *) "rop",(char *) "useMask",(char *) "srcPtMask", NULL
13972 };
13973
13974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:DC_BlitPointSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
13975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13976 if (SWIG_arg_fail(1)) SWIG_fail;
13977 {
13978 arg2 = &temp2;
13979 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13980 }
13981 {
13982 arg3 = &temp3;
13983 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
13984 }
13985 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
13986 if (SWIG_arg_fail(4)) SWIG_fail;
13987 {
13988 arg5 = &temp5;
13989 if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;
13990 }
13991 if (obj5) {
13992 {
13993 arg6 = (int)(SWIG_As_int(obj5));
13994 if (SWIG_arg_fail(6)) SWIG_fail;
13995 }
13996 }
13997 if (obj6) {
13998 {
13999 arg7 = (bool)(SWIG_As_bool(obj6));
14000 if (SWIG_arg_fail(7)) SWIG_fail;
14001 }
14002 }
14003 if (obj7) {
14004 {
14005 arg8 = &temp8;
14006 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
14007 }
14008 }
14009 {
14010 PyThreadState* __tstate = wxPyBeginAllowThreads();
14011 result = (bool)(arg1)->Blit((wxPoint const &)*arg2,(wxSize const &)*arg3,arg4,(wxPoint const &)*arg5,arg6,arg7,(wxPoint const &)*arg8);
14012
14013 wxPyEndAllowThreads(__tstate);
14014 if (PyErr_Occurred()) SWIG_fail;
14015 }
14016 {
14017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14018 }
14019 return resultobj;
14020 fail:
14021 return NULL;
14022 }
14023
14024
14025 static PyObject *_wrap_DC_SetClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14026 PyObject *resultobj;
14027 wxDC *arg1 = (wxDC *) 0 ;
14028 int arg2 ;
14029 int arg3 ;
14030 int arg4 ;
14031 int arg5 ;
14032 PyObject * obj0 = 0 ;
14033 PyObject * obj1 = 0 ;
14034 PyObject * obj2 = 0 ;
14035 PyObject * obj3 = 0 ;
14036 PyObject * obj4 = 0 ;
14037 char *kwnames[] = {
14038 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
14039 };
14040
14041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC_SetClippingRegion",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14043 if (SWIG_arg_fail(1)) SWIG_fail;
14044 {
14045 arg2 = (int)(SWIG_As_int(obj1));
14046 if (SWIG_arg_fail(2)) SWIG_fail;
14047 }
14048 {
14049 arg3 = (int)(SWIG_As_int(obj2));
14050 if (SWIG_arg_fail(3)) SWIG_fail;
14051 }
14052 {
14053 arg4 = (int)(SWIG_As_int(obj3));
14054 if (SWIG_arg_fail(4)) SWIG_fail;
14055 }
14056 {
14057 arg5 = (int)(SWIG_As_int(obj4));
14058 if (SWIG_arg_fail(5)) SWIG_fail;
14059 }
14060 {
14061 PyThreadState* __tstate = wxPyBeginAllowThreads();
14062 (arg1)->SetClippingRegion(arg2,arg3,arg4,arg5);
14063
14064 wxPyEndAllowThreads(__tstate);
14065 if (PyErr_Occurred()) SWIG_fail;
14066 }
14067 Py_INCREF(Py_None); resultobj = Py_None;
14068 return resultobj;
14069 fail:
14070 return NULL;
14071 }
14072
14073
14074 static PyObject *_wrap_DC_SetClippingRegionPointSize(PyObject *, PyObject *args, PyObject *kwargs) {
14075 PyObject *resultobj;
14076 wxDC *arg1 = (wxDC *) 0 ;
14077 wxPoint *arg2 = 0 ;
14078 wxSize *arg3 = 0 ;
14079 wxPoint temp2 ;
14080 wxSize temp3 ;
14081 PyObject * obj0 = 0 ;
14082 PyObject * obj1 = 0 ;
14083 PyObject * obj2 = 0 ;
14084 char *kwnames[] = {
14085 (char *) "self",(char *) "pt",(char *) "sz", NULL
14086 };
14087
14088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetClippingRegionPointSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14090 if (SWIG_arg_fail(1)) SWIG_fail;
14091 {
14092 arg2 = &temp2;
14093 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14094 }
14095 {
14096 arg3 = &temp3;
14097 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
14098 }
14099 {
14100 PyThreadState* __tstate = wxPyBeginAllowThreads();
14101 (arg1)->SetClippingRegion((wxPoint const &)*arg2,(wxSize const &)*arg3);
14102
14103 wxPyEndAllowThreads(__tstate);
14104 if (PyErr_Occurred()) SWIG_fail;
14105 }
14106 Py_INCREF(Py_None); resultobj = Py_None;
14107 return resultobj;
14108 fail:
14109 return NULL;
14110 }
14111
14112
14113 static PyObject *_wrap_DC_SetClippingRegionAsRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14114 PyObject *resultobj;
14115 wxDC *arg1 = (wxDC *) 0 ;
14116 wxRegion *arg2 = 0 ;
14117 PyObject * obj0 = 0 ;
14118 PyObject * obj1 = 0 ;
14119 char *kwnames[] = {
14120 (char *) "self",(char *) "region", NULL
14121 };
14122
14123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRegionAsRegion",kwnames,&obj0,&obj1)) goto fail;
14124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14125 if (SWIG_arg_fail(1)) SWIG_fail;
14126 {
14127 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRegion, SWIG_POINTER_EXCEPTION | 0);
14128 if (SWIG_arg_fail(2)) SWIG_fail;
14129 if (arg2 == NULL) {
14130 SWIG_null_ref("wxRegion");
14131 }
14132 if (SWIG_arg_fail(2)) SWIG_fail;
14133 }
14134 {
14135 PyThreadState* __tstate = wxPyBeginAllowThreads();
14136 (arg1)->SetClippingRegion((wxRegion const &)*arg2);
14137
14138 wxPyEndAllowThreads(__tstate);
14139 if (PyErr_Occurred()) SWIG_fail;
14140 }
14141 Py_INCREF(Py_None); resultobj = Py_None;
14142 return resultobj;
14143 fail:
14144 return NULL;
14145 }
14146
14147
14148 static PyObject *_wrap_DC_SetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
14149 PyObject *resultobj;
14150 wxDC *arg1 = (wxDC *) 0 ;
14151 wxRect *arg2 = 0 ;
14152 wxRect temp2 ;
14153 PyObject * obj0 = 0 ;
14154 PyObject * obj1 = 0 ;
14155 char *kwnames[] = {
14156 (char *) "self",(char *) "rect", NULL
14157 };
14158
14159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetClippingRect",kwnames,&obj0,&obj1)) goto fail;
14160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14161 if (SWIG_arg_fail(1)) SWIG_fail;
14162 {
14163 arg2 = &temp2;
14164 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14165 }
14166 {
14167 PyThreadState* __tstate = wxPyBeginAllowThreads();
14168 (arg1)->SetClippingRegion((wxRect const &)*arg2);
14169
14170 wxPyEndAllowThreads(__tstate);
14171 if (PyErr_Occurred()) SWIG_fail;
14172 }
14173 Py_INCREF(Py_None); resultobj = Py_None;
14174 return resultobj;
14175 fail:
14176 return NULL;
14177 }
14178
14179
14180 static PyObject *_wrap_DC_DrawLines(PyObject *, PyObject *args, PyObject *kwargs) {
14181 PyObject *resultobj;
14182 wxDC *arg1 = (wxDC *) 0 ;
14183 int arg2 ;
14184 wxPoint *arg3 = (wxPoint *) 0 ;
14185 int arg4 = (int) 0 ;
14186 int arg5 = (int) 0 ;
14187 PyObject * obj0 = 0 ;
14188 PyObject * obj1 = 0 ;
14189 PyObject * obj2 = 0 ;
14190 PyObject * obj3 = 0 ;
14191 char *kwnames[] = {
14192 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset", NULL
14193 };
14194
14195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DC_DrawLines",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14197 if (SWIG_arg_fail(1)) SWIG_fail;
14198 {
14199 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14200 if (arg3 == NULL) SWIG_fail;
14201 }
14202 if (obj2) {
14203 {
14204 arg4 = (int)(SWIG_As_int(obj2));
14205 if (SWIG_arg_fail(4)) SWIG_fail;
14206 }
14207 }
14208 if (obj3) {
14209 {
14210 arg5 = (int)(SWIG_As_int(obj3));
14211 if (SWIG_arg_fail(5)) SWIG_fail;
14212 }
14213 }
14214 {
14215 PyThreadState* __tstate = wxPyBeginAllowThreads();
14216 (arg1)->DrawLines(arg2,arg3,arg4,arg5);
14217
14218 wxPyEndAllowThreads(__tstate);
14219 if (PyErr_Occurred()) SWIG_fail;
14220 }
14221 Py_INCREF(Py_None); resultobj = Py_None;
14222 {
14223 if (arg3) delete [] arg3;
14224 }
14225 return resultobj;
14226 fail:
14227 {
14228 if (arg3) delete [] arg3;
14229 }
14230 return NULL;
14231 }
14232
14233
14234 static PyObject *_wrap_DC_DrawPolygon(PyObject *, PyObject *args, PyObject *kwargs) {
14235 PyObject *resultobj;
14236 wxDC *arg1 = (wxDC *) 0 ;
14237 int arg2 ;
14238 wxPoint *arg3 = (wxPoint *) 0 ;
14239 int arg4 = (int) 0 ;
14240 int arg5 = (int) 0 ;
14241 int arg6 = (int) wxODDEVEN_RULE ;
14242 PyObject * obj0 = 0 ;
14243 PyObject * obj1 = 0 ;
14244 PyObject * obj2 = 0 ;
14245 PyObject * obj3 = 0 ;
14246 PyObject * obj4 = 0 ;
14247 char *kwnames[] = {
14248 (char *) "self",(char *) "points",(char *) "xoffset",(char *) "yoffset",(char *) "fillStyle", NULL
14249 };
14250
14251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DC_DrawPolygon",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14253 if (SWIG_arg_fail(1)) SWIG_fail;
14254 {
14255 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14256 if (arg3 == NULL) SWIG_fail;
14257 }
14258 if (obj2) {
14259 {
14260 arg4 = (int)(SWIG_As_int(obj2));
14261 if (SWIG_arg_fail(4)) SWIG_fail;
14262 }
14263 }
14264 if (obj3) {
14265 {
14266 arg5 = (int)(SWIG_As_int(obj3));
14267 if (SWIG_arg_fail(5)) SWIG_fail;
14268 }
14269 }
14270 if (obj4) {
14271 {
14272 arg6 = (int)(SWIG_As_int(obj4));
14273 if (SWIG_arg_fail(6)) SWIG_fail;
14274 }
14275 }
14276 {
14277 PyThreadState* __tstate = wxPyBeginAllowThreads();
14278 (arg1)->DrawPolygon(arg2,arg3,arg4,arg5,arg6);
14279
14280 wxPyEndAllowThreads(__tstate);
14281 if (PyErr_Occurred()) SWIG_fail;
14282 }
14283 Py_INCREF(Py_None); resultobj = Py_None;
14284 {
14285 if (arg3) delete [] arg3;
14286 }
14287 return resultobj;
14288 fail:
14289 {
14290 if (arg3) delete [] arg3;
14291 }
14292 return NULL;
14293 }
14294
14295
14296 static PyObject *_wrap_DC_DrawLabel(PyObject *, PyObject *args, PyObject *kwargs) {
14297 PyObject *resultobj;
14298 wxDC *arg1 = (wxDC *) 0 ;
14299 wxString *arg2 = 0 ;
14300 wxRect *arg3 = 0 ;
14301 int arg4 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
14302 int arg5 = (int) -1 ;
14303 bool temp2 = false ;
14304 wxRect temp3 ;
14305 PyObject * obj0 = 0 ;
14306 PyObject * obj1 = 0 ;
14307 PyObject * obj2 = 0 ;
14308 PyObject * obj3 = 0 ;
14309 PyObject * obj4 = 0 ;
14310 char *kwnames[] = {
14311 (char *) "self",(char *) "text",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
14312 };
14313
14314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:DC_DrawLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14316 if (SWIG_arg_fail(1)) SWIG_fail;
14317 {
14318 arg2 = wxString_in_helper(obj1);
14319 if (arg2 == NULL) SWIG_fail;
14320 temp2 = true;
14321 }
14322 {
14323 arg3 = &temp3;
14324 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
14325 }
14326 if (obj3) {
14327 {
14328 arg4 = (int)(SWIG_As_int(obj3));
14329 if (SWIG_arg_fail(4)) SWIG_fail;
14330 }
14331 }
14332 if (obj4) {
14333 {
14334 arg5 = (int)(SWIG_As_int(obj4));
14335 if (SWIG_arg_fail(5)) SWIG_fail;
14336 }
14337 }
14338 {
14339 PyThreadState* __tstate = wxPyBeginAllowThreads();
14340 (arg1)->DrawLabel((wxString const &)*arg2,(wxRect const &)*arg3,arg4,arg5);
14341
14342 wxPyEndAllowThreads(__tstate);
14343 if (PyErr_Occurred()) SWIG_fail;
14344 }
14345 Py_INCREF(Py_None); resultobj = Py_None;
14346 {
14347 if (temp2)
14348 delete arg2;
14349 }
14350 return resultobj;
14351 fail:
14352 {
14353 if (temp2)
14354 delete arg2;
14355 }
14356 return NULL;
14357 }
14358
14359
14360 static PyObject *_wrap_DC_DrawImageLabel(PyObject *, PyObject *args, PyObject *kwargs) {
14361 PyObject *resultobj;
14362 wxDC *arg1 = (wxDC *) 0 ;
14363 wxString *arg2 = 0 ;
14364 wxBitmap *arg3 = 0 ;
14365 wxRect *arg4 = 0 ;
14366 int arg5 = (int) wxALIGN_LEFT|wxALIGN_TOP ;
14367 int arg6 = (int) -1 ;
14368 wxRect result;
14369 bool temp2 = false ;
14370 wxRect temp4 ;
14371 PyObject * obj0 = 0 ;
14372 PyObject * obj1 = 0 ;
14373 PyObject * obj2 = 0 ;
14374 PyObject * obj3 = 0 ;
14375 PyObject * obj4 = 0 ;
14376 PyObject * obj5 = 0 ;
14377 char *kwnames[] = {
14378 (char *) "self",(char *) "text",(char *) "image",(char *) "rect",(char *) "alignment",(char *) "indexAccel", NULL
14379 };
14380
14381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:DC_DrawImageLabel",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
14382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14383 if (SWIG_arg_fail(1)) SWIG_fail;
14384 {
14385 arg2 = wxString_in_helper(obj1);
14386 if (arg2 == NULL) SWIG_fail;
14387 temp2 = true;
14388 }
14389 {
14390 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
14391 if (SWIG_arg_fail(3)) SWIG_fail;
14392 if (arg3 == NULL) {
14393 SWIG_null_ref("wxBitmap");
14394 }
14395 if (SWIG_arg_fail(3)) SWIG_fail;
14396 }
14397 {
14398 arg4 = &temp4;
14399 if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;
14400 }
14401 if (obj4) {
14402 {
14403 arg5 = (int)(SWIG_As_int(obj4));
14404 if (SWIG_arg_fail(5)) SWIG_fail;
14405 }
14406 }
14407 if (obj5) {
14408 {
14409 arg6 = (int)(SWIG_As_int(obj5));
14410 if (SWIG_arg_fail(6)) SWIG_fail;
14411 }
14412 }
14413 {
14414 PyThreadState* __tstate = wxPyBeginAllowThreads();
14415 result = wxDC_DrawImageLabel(arg1,(wxString const &)*arg2,(wxBitmap const &)*arg3,(wxRect const &)*arg4,arg5,arg6);
14416
14417 wxPyEndAllowThreads(__tstate);
14418 if (PyErr_Occurred()) SWIG_fail;
14419 }
14420 {
14421 wxRect * resultptr;
14422 resultptr = new wxRect((wxRect &)(result));
14423 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
14424 }
14425 {
14426 if (temp2)
14427 delete arg2;
14428 }
14429 return resultobj;
14430 fail:
14431 {
14432 if (temp2)
14433 delete arg2;
14434 }
14435 return NULL;
14436 }
14437
14438
14439 static PyObject *_wrap_DC_DrawSpline(PyObject *, PyObject *args, PyObject *kwargs) {
14440 PyObject *resultobj;
14441 wxDC *arg1 = (wxDC *) 0 ;
14442 int arg2 ;
14443 wxPoint *arg3 = (wxPoint *) 0 ;
14444 PyObject * obj0 = 0 ;
14445 PyObject * obj1 = 0 ;
14446 char *kwnames[] = {
14447 (char *) "self",(char *) "points", NULL
14448 };
14449
14450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DrawSpline",kwnames,&obj0,&obj1)) goto fail;
14451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14452 if (SWIG_arg_fail(1)) SWIG_fail;
14453 {
14454 arg3 = wxPoint_LIST_helper(obj1, &arg2);
14455 if (arg3 == NULL) SWIG_fail;
14456 }
14457 {
14458 PyThreadState* __tstate = wxPyBeginAllowThreads();
14459 (arg1)->DrawSpline(arg2,arg3);
14460
14461 wxPyEndAllowThreads(__tstate);
14462 if (PyErr_Occurred()) SWIG_fail;
14463 }
14464 Py_INCREF(Py_None); resultobj = Py_None;
14465 {
14466 if (arg3) delete [] arg3;
14467 }
14468 return resultobj;
14469 fail:
14470 {
14471 if (arg3) delete [] arg3;
14472 }
14473 return NULL;
14474 }
14475
14476
14477 static PyObject *_wrap_DC_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
14478 PyObject *resultobj;
14479 wxDC *arg1 = (wxDC *) 0 ;
14480 PyObject * obj0 = 0 ;
14481 char *kwnames[] = {
14482 (char *) "self", NULL
14483 };
14484
14485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Clear",kwnames,&obj0)) goto fail;
14486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14487 if (SWIG_arg_fail(1)) SWIG_fail;
14488 {
14489 PyThreadState* __tstate = wxPyBeginAllowThreads();
14490 (arg1)->Clear();
14491
14492 wxPyEndAllowThreads(__tstate);
14493 if (PyErr_Occurred()) SWIG_fail;
14494 }
14495 Py_INCREF(Py_None); resultobj = Py_None;
14496 return resultobj;
14497 fail:
14498 return NULL;
14499 }
14500
14501
14502 static PyObject *_wrap_DC_StartDoc(PyObject *, PyObject *args, PyObject *kwargs) {
14503 PyObject *resultobj;
14504 wxDC *arg1 = (wxDC *) 0 ;
14505 wxString *arg2 = 0 ;
14506 bool result;
14507 bool temp2 = false ;
14508 PyObject * obj0 = 0 ;
14509 PyObject * obj1 = 0 ;
14510 char *kwnames[] = {
14511 (char *) "self",(char *) "message", NULL
14512 };
14513
14514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_StartDoc",kwnames,&obj0,&obj1)) goto fail;
14515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14516 if (SWIG_arg_fail(1)) SWIG_fail;
14517 {
14518 arg2 = wxString_in_helper(obj1);
14519 if (arg2 == NULL) SWIG_fail;
14520 temp2 = true;
14521 }
14522 {
14523 PyThreadState* __tstate = wxPyBeginAllowThreads();
14524 result = (bool)(arg1)->StartDoc((wxString const &)*arg2);
14525
14526 wxPyEndAllowThreads(__tstate);
14527 if (PyErr_Occurred()) SWIG_fail;
14528 }
14529 {
14530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14531 }
14532 {
14533 if (temp2)
14534 delete arg2;
14535 }
14536 return resultobj;
14537 fail:
14538 {
14539 if (temp2)
14540 delete arg2;
14541 }
14542 return NULL;
14543 }
14544
14545
14546 static PyObject *_wrap_DC_EndDoc(PyObject *, PyObject *args, PyObject *kwargs) {
14547 PyObject *resultobj;
14548 wxDC *arg1 = (wxDC *) 0 ;
14549 PyObject * obj0 = 0 ;
14550 char *kwnames[] = {
14551 (char *) "self", NULL
14552 };
14553
14554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndDoc",kwnames,&obj0)) goto fail;
14555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14556 if (SWIG_arg_fail(1)) SWIG_fail;
14557 {
14558 PyThreadState* __tstate = wxPyBeginAllowThreads();
14559 (arg1)->EndDoc();
14560
14561 wxPyEndAllowThreads(__tstate);
14562 if (PyErr_Occurred()) SWIG_fail;
14563 }
14564 Py_INCREF(Py_None); resultobj = Py_None;
14565 return resultobj;
14566 fail:
14567 return NULL;
14568 }
14569
14570
14571 static PyObject *_wrap_DC_StartPage(PyObject *, PyObject *args, PyObject *kwargs) {
14572 PyObject *resultobj;
14573 wxDC *arg1 = (wxDC *) 0 ;
14574 PyObject * obj0 = 0 ;
14575 char *kwnames[] = {
14576 (char *) "self", NULL
14577 };
14578
14579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_StartPage",kwnames,&obj0)) goto fail;
14580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14581 if (SWIG_arg_fail(1)) SWIG_fail;
14582 {
14583 PyThreadState* __tstate = wxPyBeginAllowThreads();
14584 (arg1)->StartPage();
14585
14586 wxPyEndAllowThreads(__tstate);
14587 if (PyErr_Occurred()) SWIG_fail;
14588 }
14589 Py_INCREF(Py_None); resultobj = Py_None;
14590 return resultobj;
14591 fail:
14592 return NULL;
14593 }
14594
14595
14596 static PyObject *_wrap_DC_EndPage(PyObject *, PyObject *args, PyObject *kwargs) {
14597 PyObject *resultobj;
14598 wxDC *arg1 = (wxDC *) 0 ;
14599 PyObject * obj0 = 0 ;
14600 char *kwnames[] = {
14601 (char *) "self", NULL
14602 };
14603
14604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_EndPage",kwnames,&obj0)) goto fail;
14605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14606 if (SWIG_arg_fail(1)) SWIG_fail;
14607 {
14608 PyThreadState* __tstate = wxPyBeginAllowThreads();
14609 (arg1)->EndPage();
14610
14611 wxPyEndAllowThreads(__tstate);
14612 if (PyErr_Occurred()) SWIG_fail;
14613 }
14614 Py_INCREF(Py_None); resultobj = Py_None;
14615 return resultobj;
14616 fail:
14617 return NULL;
14618 }
14619
14620
14621 static PyObject *_wrap_DC_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
14622 PyObject *resultobj;
14623 wxDC *arg1 = (wxDC *) 0 ;
14624 wxFont *arg2 = 0 ;
14625 PyObject * obj0 = 0 ;
14626 PyObject * obj1 = 0 ;
14627 char *kwnames[] = {
14628 (char *) "self",(char *) "font", NULL
14629 };
14630
14631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetFont",kwnames,&obj0,&obj1)) goto fail;
14632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14633 if (SWIG_arg_fail(1)) SWIG_fail;
14634 {
14635 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
14636 if (SWIG_arg_fail(2)) SWIG_fail;
14637 if (arg2 == NULL) {
14638 SWIG_null_ref("wxFont");
14639 }
14640 if (SWIG_arg_fail(2)) SWIG_fail;
14641 }
14642 {
14643 PyThreadState* __tstate = wxPyBeginAllowThreads();
14644 (arg1)->SetFont((wxFont const &)*arg2);
14645
14646 wxPyEndAllowThreads(__tstate);
14647 if (PyErr_Occurred()) SWIG_fail;
14648 }
14649 Py_INCREF(Py_None); resultobj = Py_None;
14650 return resultobj;
14651 fail:
14652 return NULL;
14653 }
14654
14655
14656 static PyObject *_wrap_DC_SetPen(PyObject *, PyObject *args, PyObject *kwargs) {
14657 PyObject *resultobj;
14658 wxDC *arg1 = (wxDC *) 0 ;
14659 wxPen *arg2 = 0 ;
14660 PyObject * obj0 = 0 ;
14661 PyObject * obj1 = 0 ;
14662 char *kwnames[] = {
14663 (char *) "self",(char *) "pen", NULL
14664 };
14665
14666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPen",kwnames,&obj0,&obj1)) goto fail;
14667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14668 if (SWIG_arg_fail(1)) SWIG_fail;
14669 {
14670 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
14671 if (SWIG_arg_fail(2)) SWIG_fail;
14672 if (arg2 == NULL) {
14673 SWIG_null_ref("wxPen");
14674 }
14675 if (SWIG_arg_fail(2)) SWIG_fail;
14676 }
14677 {
14678 PyThreadState* __tstate = wxPyBeginAllowThreads();
14679 (arg1)->SetPen((wxPen const &)*arg2);
14680
14681 wxPyEndAllowThreads(__tstate);
14682 if (PyErr_Occurred()) SWIG_fail;
14683 }
14684 Py_INCREF(Py_None); resultobj = Py_None;
14685 return resultobj;
14686 fail:
14687 return NULL;
14688 }
14689
14690
14691 static PyObject *_wrap_DC_SetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
14692 PyObject *resultobj;
14693 wxDC *arg1 = (wxDC *) 0 ;
14694 wxBrush *arg2 = 0 ;
14695 PyObject * obj0 = 0 ;
14696 PyObject * obj1 = 0 ;
14697 char *kwnames[] = {
14698 (char *) "self",(char *) "brush", NULL
14699 };
14700
14701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBrush",kwnames,&obj0,&obj1)) goto fail;
14702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14703 if (SWIG_arg_fail(1)) SWIG_fail;
14704 {
14705 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
14706 if (SWIG_arg_fail(2)) SWIG_fail;
14707 if (arg2 == NULL) {
14708 SWIG_null_ref("wxBrush");
14709 }
14710 if (SWIG_arg_fail(2)) SWIG_fail;
14711 }
14712 {
14713 PyThreadState* __tstate = wxPyBeginAllowThreads();
14714 (arg1)->SetBrush((wxBrush const &)*arg2);
14715
14716 wxPyEndAllowThreads(__tstate);
14717 if (PyErr_Occurred()) SWIG_fail;
14718 }
14719 Py_INCREF(Py_None); resultobj = Py_None;
14720 return resultobj;
14721 fail:
14722 return NULL;
14723 }
14724
14725
14726 static PyObject *_wrap_DC_SetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
14727 PyObject *resultobj;
14728 wxDC *arg1 = (wxDC *) 0 ;
14729 wxBrush *arg2 = 0 ;
14730 PyObject * obj0 = 0 ;
14731 PyObject * obj1 = 0 ;
14732 char *kwnames[] = {
14733 (char *) "self",(char *) "brush", NULL
14734 };
14735
14736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackground",kwnames,&obj0,&obj1)) goto fail;
14737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14738 if (SWIG_arg_fail(1)) SWIG_fail;
14739 {
14740 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
14741 if (SWIG_arg_fail(2)) SWIG_fail;
14742 if (arg2 == NULL) {
14743 SWIG_null_ref("wxBrush");
14744 }
14745 if (SWIG_arg_fail(2)) SWIG_fail;
14746 }
14747 {
14748 PyThreadState* __tstate = wxPyBeginAllowThreads();
14749 (arg1)->SetBackground((wxBrush const &)*arg2);
14750
14751 wxPyEndAllowThreads(__tstate);
14752 if (PyErr_Occurred()) SWIG_fail;
14753 }
14754 Py_INCREF(Py_None); resultobj = Py_None;
14755 return resultobj;
14756 fail:
14757 return NULL;
14758 }
14759
14760
14761 static PyObject *_wrap_DC_SetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
14762 PyObject *resultobj;
14763 wxDC *arg1 = (wxDC *) 0 ;
14764 int arg2 ;
14765 PyObject * obj0 = 0 ;
14766 PyObject * obj1 = 0 ;
14767 char *kwnames[] = {
14768 (char *) "self",(char *) "mode", NULL
14769 };
14770
14771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetBackgroundMode",kwnames,&obj0,&obj1)) goto fail;
14772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14773 if (SWIG_arg_fail(1)) SWIG_fail;
14774 {
14775 arg2 = (int)(SWIG_As_int(obj1));
14776 if (SWIG_arg_fail(2)) SWIG_fail;
14777 }
14778 {
14779 PyThreadState* __tstate = wxPyBeginAllowThreads();
14780 (arg1)->SetBackgroundMode(arg2);
14781
14782 wxPyEndAllowThreads(__tstate);
14783 if (PyErr_Occurred()) SWIG_fail;
14784 }
14785 Py_INCREF(Py_None); resultobj = Py_None;
14786 return resultobj;
14787 fail:
14788 return NULL;
14789 }
14790
14791
14792 static PyObject *_wrap_DC_SetPalette(PyObject *, PyObject *args, PyObject *kwargs) {
14793 PyObject *resultobj;
14794 wxDC *arg1 = (wxDC *) 0 ;
14795 wxPalette *arg2 = 0 ;
14796 PyObject * obj0 = 0 ;
14797 PyObject * obj1 = 0 ;
14798 char *kwnames[] = {
14799 (char *) "self",(char *) "palette", NULL
14800 };
14801
14802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetPalette",kwnames,&obj0,&obj1)) goto fail;
14803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14804 if (SWIG_arg_fail(1)) SWIG_fail;
14805 {
14806 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPalette, SWIG_POINTER_EXCEPTION | 0);
14807 if (SWIG_arg_fail(2)) SWIG_fail;
14808 if (arg2 == NULL) {
14809 SWIG_null_ref("wxPalette");
14810 }
14811 if (SWIG_arg_fail(2)) SWIG_fail;
14812 }
14813 {
14814 PyThreadState* __tstate = wxPyBeginAllowThreads();
14815 (arg1)->SetPalette((wxPalette const &)*arg2);
14816
14817 wxPyEndAllowThreads(__tstate);
14818 if (PyErr_Occurred()) SWIG_fail;
14819 }
14820 Py_INCREF(Py_None); resultobj = Py_None;
14821 return resultobj;
14822 fail:
14823 return NULL;
14824 }
14825
14826
14827 static PyObject *_wrap_DC_DestroyClippingRegion(PyObject *, PyObject *args, PyObject *kwargs) {
14828 PyObject *resultobj;
14829 wxDC *arg1 = (wxDC *) 0 ;
14830 PyObject * obj0 = 0 ;
14831 char *kwnames[] = {
14832 (char *) "self", NULL
14833 };
14834
14835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_DestroyClippingRegion",kwnames,&obj0)) goto fail;
14836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14837 if (SWIG_arg_fail(1)) SWIG_fail;
14838 {
14839 PyThreadState* __tstate = wxPyBeginAllowThreads();
14840 (arg1)->DestroyClippingRegion();
14841
14842 wxPyEndAllowThreads(__tstate);
14843 if (PyErr_Occurred()) SWIG_fail;
14844 }
14845 Py_INCREF(Py_None); resultobj = Py_None;
14846 return resultobj;
14847 fail:
14848 return NULL;
14849 }
14850
14851
14852 static PyObject *_wrap_DC_GetClippingBox(PyObject *, PyObject *args, PyObject *kwargs) {
14853 PyObject *resultobj;
14854 wxDC *arg1 = (wxDC *) 0 ;
14855 int *arg2 = (int *) 0 ;
14856 int *arg3 = (int *) 0 ;
14857 int *arg4 = (int *) 0 ;
14858 int *arg5 = (int *) 0 ;
14859 int temp2 ;
14860 int res2 = 0 ;
14861 int temp3 ;
14862 int res3 = 0 ;
14863 int temp4 ;
14864 int res4 = 0 ;
14865 int temp5 ;
14866 int res5 = 0 ;
14867 PyObject * obj0 = 0 ;
14868 char *kwnames[] = {
14869 (char *) "self", NULL
14870 };
14871
14872 arg2 = &temp2; res2 = SWIG_NEWOBJ;
14873 arg3 = &temp3; res3 = SWIG_NEWOBJ;
14874 arg4 = &temp4; res4 = SWIG_NEWOBJ;
14875 arg5 = &temp5; res5 = SWIG_NEWOBJ;
14876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingBox",kwnames,&obj0)) goto fail;
14877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14878 if (SWIG_arg_fail(1)) SWIG_fail;
14879 {
14880 PyThreadState* __tstate = wxPyBeginAllowThreads();
14881 ((wxDC const *)arg1)->GetClippingBox(arg2,arg3,arg4,arg5);
14882
14883 wxPyEndAllowThreads(__tstate);
14884 if (PyErr_Occurred()) SWIG_fail;
14885 }
14886 Py_INCREF(Py_None); resultobj = Py_None;
14887 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
14888 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
14889 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
14890 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
14891 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
14892 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
14893 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
14894 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
14895 return resultobj;
14896 fail:
14897 return NULL;
14898 }
14899
14900
14901 static PyObject *_wrap_DC_GetClippingRect(PyObject *, PyObject *args, PyObject *kwargs) {
14902 PyObject *resultobj;
14903 wxDC *arg1 = (wxDC *) 0 ;
14904 wxRect result;
14905 PyObject * obj0 = 0 ;
14906 char *kwnames[] = {
14907 (char *) "self", NULL
14908 };
14909
14910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetClippingRect",kwnames,&obj0)) goto fail;
14911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14912 if (SWIG_arg_fail(1)) SWIG_fail;
14913 {
14914 PyThreadState* __tstate = wxPyBeginAllowThreads();
14915 result = wxDC_GetClippingRect(arg1);
14916
14917 wxPyEndAllowThreads(__tstate);
14918 if (PyErr_Occurred()) SWIG_fail;
14919 }
14920 {
14921 wxRect * resultptr;
14922 resultptr = new wxRect((wxRect &)(result));
14923 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
14924 }
14925 return resultobj;
14926 fail:
14927 return NULL;
14928 }
14929
14930
14931 static PyObject *_wrap_DC_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
14932 PyObject *resultobj;
14933 wxDC *arg1 = (wxDC *) 0 ;
14934 int result;
14935 PyObject * obj0 = 0 ;
14936 char *kwnames[] = {
14937 (char *) "self", NULL
14938 };
14939
14940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharHeight",kwnames,&obj0)) goto fail;
14941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14942 if (SWIG_arg_fail(1)) SWIG_fail;
14943 {
14944 PyThreadState* __tstate = wxPyBeginAllowThreads();
14945 result = (int)((wxDC const *)arg1)->GetCharHeight();
14946
14947 wxPyEndAllowThreads(__tstate);
14948 if (PyErr_Occurred()) SWIG_fail;
14949 }
14950 {
14951 resultobj = SWIG_From_int((int)(result));
14952 }
14953 return resultobj;
14954 fail:
14955 return NULL;
14956 }
14957
14958
14959 static PyObject *_wrap_DC_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
14960 PyObject *resultobj;
14961 wxDC *arg1 = (wxDC *) 0 ;
14962 int result;
14963 PyObject * obj0 = 0 ;
14964 char *kwnames[] = {
14965 (char *) "self", NULL
14966 };
14967
14968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetCharWidth",kwnames,&obj0)) goto fail;
14969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
14970 if (SWIG_arg_fail(1)) SWIG_fail;
14971 {
14972 PyThreadState* __tstate = wxPyBeginAllowThreads();
14973 result = (int)((wxDC const *)arg1)->GetCharWidth();
14974
14975 wxPyEndAllowThreads(__tstate);
14976 if (PyErr_Occurred()) SWIG_fail;
14977 }
14978 {
14979 resultobj = SWIG_From_int((int)(result));
14980 }
14981 return resultobj;
14982 fail:
14983 return NULL;
14984 }
14985
14986
14987 static PyObject *_wrap_DC_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
14988 PyObject *resultobj;
14989 wxDC *arg1 = (wxDC *) 0 ;
14990 wxString *arg2 = 0 ;
14991 int *arg3 = (int *) 0 ;
14992 int *arg4 = (int *) 0 ;
14993 bool temp2 = false ;
14994 int temp3 ;
14995 int res3 = 0 ;
14996 int temp4 ;
14997 int res4 = 0 ;
14998 PyObject * obj0 = 0 ;
14999 PyObject * obj1 = 0 ;
15000 char *kwnames[] = {
15001 (char *) "self",(char *) "string", NULL
15002 };
15003
15004 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15005 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
15007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15008 if (SWIG_arg_fail(1)) SWIG_fail;
15009 {
15010 arg2 = wxString_in_helper(obj1);
15011 if (arg2 == NULL) SWIG_fail;
15012 temp2 = true;
15013 }
15014 {
15015 PyThreadState* __tstate = wxPyBeginAllowThreads();
15016 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
15017
15018 wxPyEndAllowThreads(__tstate);
15019 if (PyErr_Occurred()) SWIG_fail;
15020 }
15021 Py_INCREF(Py_None); resultobj = Py_None;
15022 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15023 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15024 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15025 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15026 {
15027 if (temp2)
15028 delete arg2;
15029 }
15030 return resultobj;
15031 fail:
15032 {
15033 if (temp2)
15034 delete arg2;
15035 }
15036 return NULL;
15037 }
15038
15039
15040 static PyObject *_wrap_DC_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15041 PyObject *resultobj;
15042 wxDC *arg1 = (wxDC *) 0 ;
15043 wxString *arg2 = 0 ;
15044 int *arg3 = (int *) 0 ;
15045 int *arg4 = (int *) 0 ;
15046 int *arg5 = (int *) 0 ;
15047 int *arg6 = (int *) 0 ;
15048 wxFont *arg7 = (wxFont *) NULL ;
15049 bool temp2 = false ;
15050 int temp3 ;
15051 int res3 = 0 ;
15052 int temp4 ;
15053 int res4 = 0 ;
15054 int temp5 ;
15055 int res5 = 0 ;
15056 int temp6 ;
15057 int res6 = 0 ;
15058 PyObject * obj0 = 0 ;
15059 PyObject * obj1 = 0 ;
15060 PyObject * obj2 = 0 ;
15061 char *kwnames[] = {
15062 (char *) "self",(char *) "string",(char *) "font", NULL
15063 };
15064
15065 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15066 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15067 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15068 arg6 = &temp6; res6 = SWIG_NEWOBJ;
15069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15071 if (SWIG_arg_fail(1)) SWIG_fail;
15072 {
15073 arg2 = wxString_in_helper(obj1);
15074 if (arg2 == NULL) SWIG_fail;
15075 temp2 = true;
15076 }
15077 if (obj2) {
15078 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15079 if (SWIG_arg_fail(7)) SWIG_fail;
15080 }
15081 {
15082 PyThreadState* __tstate = wxPyBeginAllowThreads();
15083 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7);
15084
15085 wxPyEndAllowThreads(__tstate);
15086 if (PyErr_Occurred()) SWIG_fail;
15087 }
15088 Py_INCREF(Py_None); resultobj = Py_None;
15089 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15090 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15091 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15092 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15093 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15094 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15095 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
15096 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
15097 {
15098 if (temp2)
15099 delete arg2;
15100 }
15101 return resultobj;
15102 fail:
15103 {
15104 if (temp2)
15105 delete arg2;
15106 }
15107 return NULL;
15108 }
15109
15110
15111 static PyObject *_wrap_DC_GetMultiLineTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15112 PyObject *resultobj;
15113 wxDC *arg1 = (wxDC *) 0 ;
15114 wxString *arg2 = 0 ;
15115 int *arg3 = (int *) 0 ;
15116 int *arg4 = (int *) 0 ;
15117 int *arg5 = (int *) 0 ;
15118 wxFont *arg6 = (wxFont *) NULL ;
15119 bool temp2 = false ;
15120 int temp3 ;
15121 int res3 = 0 ;
15122 int temp4 ;
15123 int res4 = 0 ;
15124 int temp5 ;
15125 int res5 = 0 ;
15126 PyObject * obj0 = 0 ;
15127 PyObject * obj1 = 0 ;
15128 PyObject * obj2 = 0 ;
15129 char *kwnames[] = {
15130 (char *) "self",(char *) "text",(char *) "font", NULL
15131 };
15132
15133 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15134 arg4 = &temp4; res4 = SWIG_NEWOBJ;
15135 arg5 = &temp5; res5 = SWIG_NEWOBJ;
15136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DC_GetMultiLineTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15138 if (SWIG_arg_fail(1)) SWIG_fail;
15139 {
15140 arg2 = wxString_in_helper(obj1);
15141 if (arg2 == NULL) SWIG_fail;
15142 temp2 = true;
15143 }
15144 if (obj2) {
15145 SWIG_Python_ConvertPtr(obj2, (void **)&arg6, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
15146 if (SWIG_arg_fail(6)) SWIG_fail;
15147 }
15148 {
15149 PyThreadState* __tstate = wxPyBeginAllowThreads();
15150 (arg1)->GetMultiLineTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6);
15151
15152 wxPyEndAllowThreads(__tstate);
15153 if (PyErr_Occurred()) SWIG_fail;
15154 }
15155 Py_INCREF(Py_None); resultobj = Py_None;
15156 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15157 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15158 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
15159 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
15160 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
15161 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
15162 {
15163 if (temp2)
15164 delete arg2;
15165 }
15166 return resultobj;
15167 fail:
15168 {
15169 if (temp2)
15170 delete arg2;
15171 }
15172 return NULL;
15173 }
15174
15175
15176 static PyObject *_wrap_DC_GetPartialTextExtents(PyObject *, PyObject *args, PyObject *kwargs) {
15177 PyObject *resultobj;
15178 wxDC *arg1 = (wxDC *) 0 ;
15179 wxString *arg2 = 0 ;
15180 wxArrayInt result;
15181 bool temp2 = false ;
15182 PyObject * obj0 = 0 ;
15183 PyObject * obj1 = 0 ;
15184 char *kwnames[] = {
15185 (char *) "self",(char *) "text", NULL
15186 };
15187
15188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_GetPartialTextExtents",kwnames,&obj0,&obj1)) goto fail;
15189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15190 if (SWIG_arg_fail(1)) SWIG_fail;
15191 {
15192 arg2 = wxString_in_helper(obj1);
15193 if (arg2 == NULL) SWIG_fail;
15194 temp2 = true;
15195 }
15196 {
15197 PyThreadState* __tstate = wxPyBeginAllowThreads();
15198 result = wxDC_GetPartialTextExtents(arg1,(wxString const &)*arg2);
15199
15200 wxPyEndAllowThreads(__tstate);
15201 if (PyErr_Occurred()) SWIG_fail;
15202 }
15203 {
15204 resultobj = PyList_New(0);
15205 size_t idx;
15206 for (idx = 0; idx < (&result)->GetCount(); idx += 1) {
15207 PyObject* val = PyInt_FromLong( (&result)->Item(idx) );
15208 PyList_Append(resultobj, val);
15209 Py_DECREF(val);
15210 }
15211 }
15212 {
15213 if (temp2)
15214 delete arg2;
15215 }
15216 return resultobj;
15217 fail:
15218 {
15219 if (temp2)
15220 delete arg2;
15221 }
15222 return NULL;
15223 }
15224
15225
15226 static PyObject *_wrap_DC_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
15227 PyObject *resultobj;
15228 wxDC *arg1 = (wxDC *) 0 ;
15229 wxSize result;
15230 PyObject * obj0 = 0 ;
15231 char *kwnames[] = {
15232 (char *) "self", NULL
15233 };
15234
15235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSize",kwnames,&obj0)) goto fail;
15236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15237 if (SWIG_arg_fail(1)) SWIG_fail;
15238 {
15239 PyThreadState* __tstate = wxPyBeginAllowThreads();
15240 result = (arg1)->GetSize();
15241
15242 wxPyEndAllowThreads(__tstate);
15243 if (PyErr_Occurred()) SWIG_fail;
15244 }
15245 {
15246 wxSize * resultptr;
15247 resultptr = new wxSize((wxSize &)(result));
15248 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15249 }
15250 return resultobj;
15251 fail:
15252 return NULL;
15253 }
15254
15255
15256 static PyObject *_wrap_DC_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
15257 PyObject *resultobj;
15258 wxDC *arg1 = (wxDC *) 0 ;
15259 int *arg2 = (int *) 0 ;
15260 int *arg3 = (int *) 0 ;
15261 int temp2 ;
15262 int res2 = 0 ;
15263 int temp3 ;
15264 int res3 = 0 ;
15265 PyObject * obj0 = 0 ;
15266 char *kwnames[] = {
15267 (char *) "self", NULL
15268 };
15269
15270 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15271 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeTuple",kwnames,&obj0)) goto fail;
15273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15274 if (SWIG_arg_fail(1)) SWIG_fail;
15275 {
15276 PyThreadState* __tstate = wxPyBeginAllowThreads();
15277 (arg1)->GetSize(arg2,arg3);
15278
15279 wxPyEndAllowThreads(__tstate);
15280 if (PyErr_Occurred()) SWIG_fail;
15281 }
15282 Py_INCREF(Py_None); resultobj = Py_None;
15283 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15284 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15285 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15286 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15287 return resultobj;
15288 fail:
15289 return NULL;
15290 }
15291
15292
15293 static PyObject *_wrap_DC_GetSizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
15294 PyObject *resultobj;
15295 wxDC *arg1 = (wxDC *) 0 ;
15296 wxSize result;
15297 PyObject * obj0 = 0 ;
15298 char *kwnames[] = {
15299 (char *) "self", NULL
15300 };
15301
15302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMM",kwnames,&obj0)) goto fail;
15303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15304 if (SWIG_arg_fail(1)) SWIG_fail;
15305 {
15306 PyThreadState* __tstate = wxPyBeginAllowThreads();
15307 result = ((wxDC const *)arg1)->GetSizeMM();
15308
15309 wxPyEndAllowThreads(__tstate);
15310 if (PyErr_Occurred()) SWIG_fail;
15311 }
15312 {
15313 wxSize * resultptr;
15314 resultptr = new wxSize((wxSize &)(result));
15315 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15316 }
15317 return resultobj;
15318 fail:
15319 return NULL;
15320 }
15321
15322
15323 static PyObject *_wrap_DC_GetSizeMMTuple(PyObject *, PyObject *args, PyObject *kwargs) {
15324 PyObject *resultobj;
15325 wxDC *arg1 = (wxDC *) 0 ;
15326 int *arg2 = (int *) 0 ;
15327 int *arg3 = (int *) 0 ;
15328 int temp2 ;
15329 int res2 = 0 ;
15330 int temp3 ;
15331 int res3 = 0 ;
15332 PyObject * obj0 = 0 ;
15333 char *kwnames[] = {
15334 (char *) "self", NULL
15335 };
15336
15337 arg2 = &temp2; res2 = SWIG_NEWOBJ;
15338 arg3 = &temp3; res3 = SWIG_NEWOBJ;
15339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetSizeMMTuple",kwnames,&obj0)) goto fail;
15340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15341 if (SWIG_arg_fail(1)) SWIG_fail;
15342 {
15343 PyThreadState* __tstate = wxPyBeginAllowThreads();
15344 ((wxDC const *)arg1)->GetSizeMM(arg2,arg3);
15345
15346 wxPyEndAllowThreads(__tstate);
15347 if (PyErr_Occurred()) SWIG_fail;
15348 }
15349 Py_INCREF(Py_None); resultobj = Py_None;
15350 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
15351 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
15352 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
15353 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
15354 return resultobj;
15355 fail:
15356 return NULL;
15357 }
15358
15359
15360 static PyObject *_wrap_DC_DeviceToLogicalX(PyObject *, PyObject *args, PyObject *kwargs) {
15361 PyObject *resultobj;
15362 wxDC *arg1 = (wxDC *) 0 ;
15363 int arg2 ;
15364 int result;
15365 PyObject * obj0 = 0 ;
15366 PyObject * obj1 = 0 ;
15367 char *kwnames[] = {
15368 (char *) "self",(char *) "x", NULL
15369 };
15370
15371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalX",kwnames,&obj0,&obj1)) goto fail;
15372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15373 if (SWIG_arg_fail(1)) SWIG_fail;
15374 {
15375 arg2 = (int)(SWIG_As_int(obj1));
15376 if (SWIG_arg_fail(2)) SWIG_fail;
15377 }
15378 {
15379 PyThreadState* __tstate = wxPyBeginAllowThreads();
15380 result = (int)((wxDC const *)arg1)->DeviceToLogicalX(arg2);
15381
15382 wxPyEndAllowThreads(__tstate);
15383 if (PyErr_Occurred()) SWIG_fail;
15384 }
15385 {
15386 resultobj = SWIG_From_int((int)(result));
15387 }
15388 return resultobj;
15389 fail:
15390 return NULL;
15391 }
15392
15393
15394 static PyObject *_wrap_DC_DeviceToLogicalY(PyObject *, PyObject *args, PyObject *kwargs) {
15395 PyObject *resultobj;
15396 wxDC *arg1 = (wxDC *) 0 ;
15397 int arg2 ;
15398 int result;
15399 PyObject * obj0 = 0 ;
15400 PyObject * obj1 = 0 ;
15401 char *kwnames[] = {
15402 (char *) "self",(char *) "y", NULL
15403 };
15404
15405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalY",kwnames,&obj0,&obj1)) goto fail;
15406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15407 if (SWIG_arg_fail(1)) SWIG_fail;
15408 {
15409 arg2 = (int)(SWIG_As_int(obj1));
15410 if (SWIG_arg_fail(2)) SWIG_fail;
15411 }
15412 {
15413 PyThreadState* __tstate = wxPyBeginAllowThreads();
15414 result = (int)((wxDC const *)arg1)->DeviceToLogicalY(arg2);
15415
15416 wxPyEndAllowThreads(__tstate);
15417 if (PyErr_Occurred()) SWIG_fail;
15418 }
15419 {
15420 resultobj = SWIG_From_int((int)(result));
15421 }
15422 return resultobj;
15423 fail:
15424 return NULL;
15425 }
15426
15427
15428 static PyObject *_wrap_DC_DeviceToLogicalXRel(PyObject *, PyObject *args, PyObject *kwargs) {
15429 PyObject *resultobj;
15430 wxDC *arg1 = (wxDC *) 0 ;
15431 int arg2 ;
15432 int result;
15433 PyObject * obj0 = 0 ;
15434 PyObject * obj1 = 0 ;
15435 char *kwnames[] = {
15436 (char *) "self",(char *) "x", NULL
15437 };
15438
15439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalXRel",kwnames,&obj0,&obj1)) goto fail;
15440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15441 if (SWIG_arg_fail(1)) SWIG_fail;
15442 {
15443 arg2 = (int)(SWIG_As_int(obj1));
15444 if (SWIG_arg_fail(2)) SWIG_fail;
15445 }
15446 {
15447 PyThreadState* __tstate = wxPyBeginAllowThreads();
15448 result = (int)((wxDC const *)arg1)->DeviceToLogicalXRel(arg2);
15449
15450 wxPyEndAllowThreads(__tstate);
15451 if (PyErr_Occurred()) SWIG_fail;
15452 }
15453 {
15454 resultobj = SWIG_From_int((int)(result));
15455 }
15456 return resultobj;
15457 fail:
15458 return NULL;
15459 }
15460
15461
15462 static PyObject *_wrap_DC_DeviceToLogicalYRel(PyObject *, PyObject *args, PyObject *kwargs) {
15463 PyObject *resultobj;
15464 wxDC *arg1 = (wxDC *) 0 ;
15465 int arg2 ;
15466 int result;
15467 PyObject * obj0 = 0 ;
15468 PyObject * obj1 = 0 ;
15469 char *kwnames[] = {
15470 (char *) "self",(char *) "y", NULL
15471 };
15472
15473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_DeviceToLogicalYRel",kwnames,&obj0,&obj1)) goto fail;
15474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15475 if (SWIG_arg_fail(1)) SWIG_fail;
15476 {
15477 arg2 = (int)(SWIG_As_int(obj1));
15478 if (SWIG_arg_fail(2)) SWIG_fail;
15479 }
15480 {
15481 PyThreadState* __tstate = wxPyBeginAllowThreads();
15482 result = (int)((wxDC const *)arg1)->DeviceToLogicalYRel(arg2);
15483
15484 wxPyEndAllowThreads(__tstate);
15485 if (PyErr_Occurred()) SWIG_fail;
15486 }
15487 {
15488 resultobj = SWIG_From_int((int)(result));
15489 }
15490 return resultobj;
15491 fail:
15492 return NULL;
15493 }
15494
15495
15496 static PyObject *_wrap_DC_LogicalToDeviceX(PyObject *, PyObject *args, PyObject *kwargs) {
15497 PyObject *resultobj;
15498 wxDC *arg1 = (wxDC *) 0 ;
15499 int arg2 ;
15500 int result;
15501 PyObject * obj0 = 0 ;
15502 PyObject * obj1 = 0 ;
15503 char *kwnames[] = {
15504 (char *) "self",(char *) "x", NULL
15505 };
15506
15507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceX",kwnames,&obj0,&obj1)) goto fail;
15508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15509 if (SWIG_arg_fail(1)) SWIG_fail;
15510 {
15511 arg2 = (int)(SWIG_As_int(obj1));
15512 if (SWIG_arg_fail(2)) SWIG_fail;
15513 }
15514 {
15515 PyThreadState* __tstate = wxPyBeginAllowThreads();
15516 result = (int)((wxDC const *)arg1)->LogicalToDeviceX(arg2);
15517
15518 wxPyEndAllowThreads(__tstate);
15519 if (PyErr_Occurred()) SWIG_fail;
15520 }
15521 {
15522 resultobj = SWIG_From_int((int)(result));
15523 }
15524 return resultobj;
15525 fail:
15526 return NULL;
15527 }
15528
15529
15530 static PyObject *_wrap_DC_LogicalToDeviceY(PyObject *, PyObject *args, PyObject *kwargs) {
15531 PyObject *resultobj;
15532 wxDC *arg1 = (wxDC *) 0 ;
15533 int arg2 ;
15534 int result;
15535 PyObject * obj0 = 0 ;
15536 PyObject * obj1 = 0 ;
15537 char *kwnames[] = {
15538 (char *) "self",(char *) "y", NULL
15539 };
15540
15541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceY",kwnames,&obj0,&obj1)) goto fail;
15542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15543 if (SWIG_arg_fail(1)) SWIG_fail;
15544 {
15545 arg2 = (int)(SWIG_As_int(obj1));
15546 if (SWIG_arg_fail(2)) SWIG_fail;
15547 }
15548 {
15549 PyThreadState* __tstate = wxPyBeginAllowThreads();
15550 result = (int)((wxDC const *)arg1)->LogicalToDeviceY(arg2);
15551
15552 wxPyEndAllowThreads(__tstate);
15553 if (PyErr_Occurred()) SWIG_fail;
15554 }
15555 {
15556 resultobj = SWIG_From_int((int)(result));
15557 }
15558 return resultobj;
15559 fail:
15560 return NULL;
15561 }
15562
15563
15564 static PyObject *_wrap_DC_LogicalToDeviceXRel(PyObject *, PyObject *args, PyObject *kwargs) {
15565 PyObject *resultobj;
15566 wxDC *arg1 = (wxDC *) 0 ;
15567 int arg2 ;
15568 int result;
15569 PyObject * obj0 = 0 ;
15570 PyObject * obj1 = 0 ;
15571 char *kwnames[] = {
15572 (char *) "self",(char *) "x", NULL
15573 };
15574
15575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceXRel",kwnames,&obj0,&obj1)) goto fail;
15576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15577 if (SWIG_arg_fail(1)) SWIG_fail;
15578 {
15579 arg2 = (int)(SWIG_As_int(obj1));
15580 if (SWIG_arg_fail(2)) SWIG_fail;
15581 }
15582 {
15583 PyThreadState* __tstate = wxPyBeginAllowThreads();
15584 result = (int)((wxDC const *)arg1)->LogicalToDeviceXRel(arg2);
15585
15586 wxPyEndAllowThreads(__tstate);
15587 if (PyErr_Occurred()) SWIG_fail;
15588 }
15589 {
15590 resultobj = SWIG_From_int((int)(result));
15591 }
15592 return resultobj;
15593 fail:
15594 return NULL;
15595 }
15596
15597
15598 static PyObject *_wrap_DC_LogicalToDeviceYRel(PyObject *, PyObject *args, PyObject *kwargs) {
15599 PyObject *resultobj;
15600 wxDC *arg1 = (wxDC *) 0 ;
15601 int arg2 ;
15602 int result;
15603 PyObject * obj0 = 0 ;
15604 PyObject * obj1 = 0 ;
15605 char *kwnames[] = {
15606 (char *) "self",(char *) "y", NULL
15607 };
15608
15609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_LogicalToDeviceYRel",kwnames,&obj0,&obj1)) goto fail;
15610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15611 if (SWIG_arg_fail(1)) SWIG_fail;
15612 {
15613 arg2 = (int)(SWIG_As_int(obj1));
15614 if (SWIG_arg_fail(2)) SWIG_fail;
15615 }
15616 {
15617 PyThreadState* __tstate = wxPyBeginAllowThreads();
15618 result = (int)((wxDC const *)arg1)->LogicalToDeviceYRel(arg2);
15619
15620 wxPyEndAllowThreads(__tstate);
15621 if (PyErr_Occurred()) SWIG_fail;
15622 }
15623 {
15624 resultobj = SWIG_From_int((int)(result));
15625 }
15626 return resultobj;
15627 fail:
15628 return NULL;
15629 }
15630
15631
15632 static PyObject *_wrap_DC_CanDrawBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
15633 PyObject *resultobj;
15634 wxDC *arg1 = (wxDC *) 0 ;
15635 bool result;
15636 PyObject * obj0 = 0 ;
15637 char *kwnames[] = {
15638 (char *) "self", NULL
15639 };
15640
15641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanDrawBitmap",kwnames,&obj0)) goto fail;
15642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15643 if (SWIG_arg_fail(1)) SWIG_fail;
15644 {
15645 PyThreadState* __tstate = wxPyBeginAllowThreads();
15646 result = (bool)((wxDC const *)arg1)->CanDrawBitmap();
15647
15648 wxPyEndAllowThreads(__tstate);
15649 if (PyErr_Occurred()) SWIG_fail;
15650 }
15651 {
15652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15653 }
15654 return resultobj;
15655 fail:
15656 return NULL;
15657 }
15658
15659
15660 static PyObject *_wrap_DC_CanGetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
15661 PyObject *resultobj;
15662 wxDC *arg1 = (wxDC *) 0 ;
15663 bool result;
15664 PyObject * obj0 = 0 ;
15665 char *kwnames[] = {
15666 (char *) "self", NULL
15667 };
15668
15669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_CanGetTextExtent",kwnames,&obj0)) goto fail;
15670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15671 if (SWIG_arg_fail(1)) SWIG_fail;
15672 {
15673 PyThreadState* __tstate = wxPyBeginAllowThreads();
15674 result = (bool)((wxDC const *)arg1)->CanGetTextExtent();
15675
15676 wxPyEndAllowThreads(__tstate);
15677 if (PyErr_Occurred()) SWIG_fail;
15678 }
15679 {
15680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15681 }
15682 return resultobj;
15683 fail:
15684 return NULL;
15685 }
15686
15687
15688 static PyObject *_wrap_DC_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
15689 PyObject *resultobj;
15690 wxDC *arg1 = (wxDC *) 0 ;
15691 int result;
15692 PyObject * obj0 = 0 ;
15693 char *kwnames[] = {
15694 (char *) "self", NULL
15695 };
15696
15697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDepth",kwnames,&obj0)) goto fail;
15698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15699 if (SWIG_arg_fail(1)) SWIG_fail;
15700 {
15701 PyThreadState* __tstate = wxPyBeginAllowThreads();
15702 result = (int)((wxDC const *)arg1)->GetDepth();
15703
15704 wxPyEndAllowThreads(__tstate);
15705 if (PyErr_Occurred()) SWIG_fail;
15706 }
15707 {
15708 resultobj = SWIG_From_int((int)(result));
15709 }
15710 return resultobj;
15711 fail:
15712 return NULL;
15713 }
15714
15715
15716 static PyObject *_wrap_DC_GetPPI(PyObject *, PyObject *args, PyObject *kwargs) {
15717 PyObject *resultobj;
15718 wxDC *arg1 = (wxDC *) 0 ;
15719 wxSize result;
15720 PyObject * obj0 = 0 ;
15721 char *kwnames[] = {
15722 (char *) "self", NULL
15723 };
15724
15725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPPI",kwnames,&obj0)) goto fail;
15726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15727 if (SWIG_arg_fail(1)) SWIG_fail;
15728 {
15729 PyThreadState* __tstate = wxPyBeginAllowThreads();
15730 result = ((wxDC const *)arg1)->GetPPI();
15731
15732 wxPyEndAllowThreads(__tstate);
15733 if (PyErr_Occurred()) SWIG_fail;
15734 }
15735 {
15736 wxSize * resultptr;
15737 resultptr = new wxSize((wxSize &)(result));
15738 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
15739 }
15740 return resultobj;
15741 fail:
15742 return NULL;
15743 }
15744
15745
15746 static PyObject *_wrap_DC_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
15747 PyObject *resultobj;
15748 wxDC *arg1 = (wxDC *) 0 ;
15749 bool result;
15750 PyObject * obj0 = 0 ;
15751 char *kwnames[] = {
15752 (char *) "self", NULL
15753 };
15754
15755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_Ok",kwnames,&obj0)) goto fail;
15756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15757 if (SWIG_arg_fail(1)) SWIG_fail;
15758 {
15759 PyThreadState* __tstate = wxPyBeginAllowThreads();
15760 result = (bool)((wxDC const *)arg1)->Ok();
15761
15762 wxPyEndAllowThreads(__tstate);
15763 if (PyErr_Occurred()) SWIG_fail;
15764 }
15765 {
15766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15767 }
15768 return resultobj;
15769 fail:
15770 return NULL;
15771 }
15772
15773
15774 static PyObject *_wrap_DC_GetBackgroundMode(PyObject *, PyObject *args, PyObject *kwargs) {
15775 PyObject *resultobj;
15776 wxDC *arg1 = (wxDC *) 0 ;
15777 int result;
15778 PyObject * obj0 = 0 ;
15779 char *kwnames[] = {
15780 (char *) "self", NULL
15781 };
15782
15783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackgroundMode",kwnames,&obj0)) goto fail;
15784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15785 if (SWIG_arg_fail(1)) SWIG_fail;
15786 {
15787 PyThreadState* __tstate = wxPyBeginAllowThreads();
15788 result = (int)((wxDC const *)arg1)->GetBackgroundMode();
15789
15790 wxPyEndAllowThreads(__tstate);
15791 if (PyErr_Occurred()) SWIG_fail;
15792 }
15793 {
15794 resultobj = SWIG_From_int((int)(result));
15795 }
15796 return resultobj;
15797 fail:
15798 return NULL;
15799 }
15800
15801
15802 static PyObject *_wrap_DC_GetBackground(PyObject *, PyObject *args, PyObject *kwargs) {
15803 PyObject *resultobj;
15804 wxDC *arg1 = (wxDC *) 0 ;
15805 wxBrush *result;
15806 PyObject * obj0 = 0 ;
15807 char *kwnames[] = {
15808 (char *) "self", NULL
15809 };
15810
15811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBackground",kwnames,&obj0)) goto fail;
15812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15813 if (SWIG_arg_fail(1)) SWIG_fail;
15814 {
15815 PyThreadState* __tstate = wxPyBeginAllowThreads();
15816 {
15817 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBackground();
15818 result = (wxBrush *) &_result_ref;
15819 }
15820
15821 wxPyEndAllowThreads(__tstate);
15822 if (PyErr_Occurred()) SWIG_fail;
15823 }
15824 {
15825 wxBrush* resultptr = new wxBrush(*result);
15826 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
15827 }
15828 return resultobj;
15829 fail:
15830 return NULL;
15831 }
15832
15833
15834 static PyObject *_wrap_DC_GetBrush(PyObject *, PyObject *args, PyObject *kwargs) {
15835 PyObject *resultobj;
15836 wxDC *arg1 = (wxDC *) 0 ;
15837 wxBrush *result;
15838 PyObject * obj0 = 0 ;
15839 char *kwnames[] = {
15840 (char *) "self", NULL
15841 };
15842
15843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBrush",kwnames,&obj0)) goto fail;
15844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15845 if (SWIG_arg_fail(1)) SWIG_fail;
15846 {
15847 PyThreadState* __tstate = wxPyBeginAllowThreads();
15848 {
15849 wxBrush const &_result_ref = ((wxDC const *)arg1)->GetBrush();
15850 result = (wxBrush *) &_result_ref;
15851 }
15852
15853 wxPyEndAllowThreads(__tstate);
15854 if (PyErr_Occurred()) SWIG_fail;
15855 }
15856 {
15857 wxBrush* resultptr = new wxBrush(*result);
15858 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBrush, 1);
15859 }
15860 return resultobj;
15861 fail:
15862 return NULL;
15863 }
15864
15865
15866 static PyObject *_wrap_DC_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
15867 PyObject *resultobj;
15868 wxDC *arg1 = (wxDC *) 0 ;
15869 wxFont *result;
15870 PyObject * obj0 = 0 ;
15871 char *kwnames[] = {
15872 (char *) "self", NULL
15873 };
15874
15875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetFont",kwnames,&obj0)) goto fail;
15876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15877 if (SWIG_arg_fail(1)) SWIG_fail;
15878 {
15879 PyThreadState* __tstate = wxPyBeginAllowThreads();
15880 {
15881 wxFont const &_result_ref = ((wxDC const *)arg1)->GetFont();
15882 result = (wxFont *) &_result_ref;
15883 }
15884
15885 wxPyEndAllowThreads(__tstate);
15886 if (PyErr_Occurred()) SWIG_fail;
15887 }
15888 {
15889 wxFont* resultptr = new wxFont(*result);
15890 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxFont, 1);
15891 }
15892 return resultobj;
15893 fail:
15894 return NULL;
15895 }
15896
15897
15898 static PyObject *_wrap_DC_GetPen(PyObject *, PyObject *args, PyObject *kwargs) {
15899 PyObject *resultobj;
15900 wxDC *arg1 = (wxDC *) 0 ;
15901 wxPen *result;
15902 PyObject * obj0 = 0 ;
15903 char *kwnames[] = {
15904 (char *) "self", NULL
15905 };
15906
15907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetPen",kwnames,&obj0)) goto fail;
15908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15909 if (SWIG_arg_fail(1)) SWIG_fail;
15910 {
15911 PyThreadState* __tstate = wxPyBeginAllowThreads();
15912 {
15913 wxPen const &_result_ref = ((wxDC const *)arg1)->GetPen();
15914 result = (wxPen *) &_result_ref;
15915 }
15916
15917 wxPyEndAllowThreads(__tstate);
15918 if (PyErr_Occurred()) SWIG_fail;
15919 }
15920 {
15921 wxPen* resultptr = new wxPen(*result);
15922 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxPen, 1);
15923 }
15924 return resultobj;
15925 fail:
15926 return NULL;
15927 }
15928
15929
15930 static PyObject *_wrap_DC_GetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
15931 PyObject *resultobj;
15932 wxDC *arg1 = (wxDC *) 0 ;
15933 wxColour *result;
15934 PyObject * obj0 = 0 ;
15935 char *kwnames[] = {
15936 (char *) "self", NULL
15937 };
15938
15939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextBackground",kwnames,&obj0)) goto fail;
15940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15941 if (SWIG_arg_fail(1)) SWIG_fail;
15942 {
15943 PyThreadState* __tstate = wxPyBeginAllowThreads();
15944 {
15945 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextBackground();
15946 result = (wxColour *) &_result_ref;
15947 }
15948
15949 wxPyEndAllowThreads(__tstate);
15950 if (PyErr_Occurred()) SWIG_fail;
15951 }
15952 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
15953 return resultobj;
15954 fail:
15955 return NULL;
15956 }
15957
15958
15959 static PyObject *_wrap_DC_GetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
15960 PyObject *resultobj;
15961 wxDC *arg1 = (wxDC *) 0 ;
15962 wxColour *result;
15963 PyObject * obj0 = 0 ;
15964 char *kwnames[] = {
15965 (char *) "self", NULL
15966 };
15967
15968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetTextForeground",kwnames,&obj0)) goto fail;
15969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
15970 if (SWIG_arg_fail(1)) SWIG_fail;
15971 {
15972 PyThreadState* __tstate = wxPyBeginAllowThreads();
15973 {
15974 wxColour const &_result_ref = ((wxDC const *)arg1)->GetTextForeground();
15975 result = (wxColour *) &_result_ref;
15976 }
15977
15978 wxPyEndAllowThreads(__tstate);
15979 if (PyErr_Occurred()) SWIG_fail;
15980 }
15981 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
15982 return resultobj;
15983 fail:
15984 return NULL;
15985 }
15986
15987
15988 static PyObject *_wrap_DC_SetTextForeground(PyObject *, PyObject *args, PyObject *kwargs) {
15989 PyObject *resultobj;
15990 wxDC *arg1 = (wxDC *) 0 ;
15991 wxColour *arg2 = 0 ;
15992 wxColour temp2 ;
15993 PyObject * obj0 = 0 ;
15994 PyObject * obj1 = 0 ;
15995 char *kwnames[] = {
15996 (char *) "self",(char *) "colour", NULL
15997 };
15998
15999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextForeground",kwnames,&obj0,&obj1)) goto fail;
16000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16001 if (SWIG_arg_fail(1)) SWIG_fail;
16002 {
16003 arg2 = &temp2;
16004 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16005 }
16006 {
16007 PyThreadState* __tstate = wxPyBeginAllowThreads();
16008 (arg1)->SetTextForeground((wxColour const &)*arg2);
16009
16010 wxPyEndAllowThreads(__tstate);
16011 if (PyErr_Occurred()) SWIG_fail;
16012 }
16013 Py_INCREF(Py_None); resultobj = Py_None;
16014 return resultobj;
16015 fail:
16016 return NULL;
16017 }
16018
16019
16020 static PyObject *_wrap_DC_SetTextBackground(PyObject *, PyObject *args, PyObject *kwargs) {
16021 PyObject *resultobj;
16022 wxDC *arg1 = (wxDC *) 0 ;
16023 wxColour *arg2 = 0 ;
16024 wxColour temp2 ;
16025 PyObject * obj0 = 0 ;
16026 PyObject * obj1 = 0 ;
16027 char *kwnames[] = {
16028 (char *) "self",(char *) "colour", NULL
16029 };
16030
16031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetTextBackground",kwnames,&obj0,&obj1)) goto fail;
16032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16033 if (SWIG_arg_fail(1)) SWIG_fail;
16034 {
16035 arg2 = &temp2;
16036 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
16037 }
16038 {
16039 PyThreadState* __tstate = wxPyBeginAllowThreads();
16040 (arg1)->SetTextBackground((wxColour const &)*arg2);
16041
16042 wxPyEndAllowThreads(__tstate);
16043 if (PyErr_Occurred()) SWIG_fail;
16044 }
16045 Py_INCREF(Py_None); resultobj = Py_None;
16046 return resultobj;
16047 fail:
16048 return NULL;
16049 }
16050
16051
16052 static PyObject *_wrap_DC_GetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16053 PyObject *resultobj;
16054 wxDC *arg1 = (wxDC *) 0 ;
16055 int result;
16056 PyObject * obj0 = 0 ;
16057 char *kwnames[] = {
16058 (char *) "self", NULL
16059 };
16060
16061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetMapMode",kwnames,&obj0)) goto fail;
16062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16063 if (SWIG_arg_fail(1)) SWIG_fail;
16064 {
16065 PyThreadState* __tstate = wxPyBeginAllowThreads();
16066 result = (int)((wxDC const *)arg1)->GetMapMode();
16067
16068 wxPyEndAllowThreads(__tstate);
16069 if (PyErr_Occurred()) SWIG_fail;
16070 }
16071 {
16072 resultobj = SWIG_From_int((int)(result));
16073 }
16074 return resultobj;
16075 fail:
16076 return NULL;
16077 }
16078
16079
16080 static PyObject *_wrap_DC_SetMapMode(PyObject *, PyObject *args, PyObject *kwargs) {
16081 PyObject *resultobj;
16082 wxDC *arg1 = (wxDC *) 0 ;
16083 int arg2 ;
16084 PyObject * obj0 = 0 ;
16085 PyObject * obj1 = 0 ;
16086 char *kwnames[] = {
16087 (char *) "self",(char *) "mode", NULL
16088 };
16089
16090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetMapMode",kwnames,&obj0,&obj1)) goto fail;
16091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16092 if (SWIG_arg_fail(1)) SWIG_fail;
16093 {
16094 arg2 = (int)(SWIG_As_int(obj1));
16095 if (SWIG_arg_fail(2)) SWIG_fail;
16096 }
16097 {
16098 PyThreadState* __tstate = wxPyBeginAllowThreads();
16099 (arg1)->SetMapMode(arg2);
16100
16101 wxPyEndAllowThreads(__tstate);
16102 if (PyErr_Occurred()) SWIG_fail;
16103 }
16104 Py_INCREF(Py_None); resultobj = Py_None;
16105 return resultobj;
16106 fail:
16107 return NULL;
16108 }
16109
16110
16111 static PyObject *_wrap_DC_GetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16112 PyObject *resultobj;
16113 wxDC *arg1 = (wxDC *) 0 ;
16114 double *arg2 = (double *) 0 ;
16115 double *arg3 = (double *) 0 ;
16116 double temp2 ;
16117 int res2 = 0 ;
16118 double temp3 ;
16119 int res3 = 0 ;
16120 PyObject * obj0 = 0 ;
16121 char *kwnames[] = {
16122 (char *) "self", NULL
16123 };
16124
16125 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16126 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetUserScale",kwnames,&obj0)) goto fail;
16128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16129 if (SWIG_arg_fail(1)) SWIG_fail;
16130 {
16131 PyThreadState* __tstate = wxPyBeginAllowThreads();
16132 ((wxDC const *)arg1)->GetUserScale(arg2,arg3);
16133
16134 wxPyEndAllowThreads(__tstate);
16135 if (PyErr_Occurred()) SWIG_fail;
16136 }
16137 Py_INCREF(Py_None); resultobj = Py_None;
16138 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16139 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16140 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16141 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16142 return resultobj;
16143 fail:
16144 return NULL;
16145 }
16146
16147
16148 static PyObject *_wrap_DC_SetUserScale(PyObject *, PyObject *args, PyObject *kwargs) {
16149 PyObject *resultobj;
16150 wxDC *arg1 = (wxDC *) 0 ;
16151 double arg2 ;
16152 double arg3 ;
16153 PyObject * obj0 = 0 ;
16154 PyObject * obj1 = 0 ;
16155 PyObject * obj2 = 0 ;
16156 char *kwnames[] = {
16157 (char *) "self",(char *) "x",(char *) "y", NULL
16158 };
16159
16160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetUserScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16162 if (SWIG_arg_fail(1)) SWIG_fail;
16163 {
16164 arg2 = (double)(SWIG_As_double(obj1));
16165 if (SWIG_arg_fail(2)) SWIG_fail;
16166 }
16167 {
16168 arg3 = (double)(SWIG_As_double(obj2));
16169 if (SWIG_arg_fail(3)) SWIG_fail;
16170 }
16171 {
16172 PyThreadState* __tstate = wxPyBeginAllowThreads();
16173 (arg1)->SetUserScale(arg2,arg3);
16174
16175 wxPyEndAllowThreads(__tstate);
16176 if (PyErr_Occurred()) SWIG_fail;
16177 }
16178 Py_INCREF(Py_None); resultobj = Py_None;
16179 return resultobj;
16180 fail:
16181 return NULL;
16182 }
16183
16184
16185 static PyObject *_wrap_DC_GetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16186 PyObject *resultobj;
16187 wxDC *arg1 = (wxDC *) 0 ;
16188 double *arg2 = (double *) 0 ;
16189 double *arg3 = (double *) 0 ;
16190 double temp2 ;
16191 int res2 = 0 ;
16192 double temp3 ;
16193 int res3 = 0 ;
16194 PyObject * obj0 = 0 ;
16195 char *kwnames[] = {
16196 (char *) "self", NULL
16197 };
16198
16199 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16200 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalScale",kwnames,&obj0)) goto fail;
16202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16203 if (SWIG_arg_fail(1)) SWIG_fail;
16204 {
16205 PyThreadState* __tstate = wxPyBeginAllowThreads();
16206 (arg1)->GetLogicalScale(arg2,arg3);
16207
16208 wxPyEndAllowThreads(__tstate);
16209 if (PyErr_Occurred()) SWIG_fail;
16210 }
16211 Py_INCREF(Py_None); resultobj = Py_None;
16212 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16213 SWIG_From_double((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, 0)));
16214 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16215 SWIG_From_double((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, 0)));
16216 return resultobj;
16217 fail:
16218 return NULL;
16219 }
16220
16221
16222 static PyObject *_wrap_DC_SetLogicalScale(PyObject *, PyObject *args, PyObject *kwargs) {
16223 PyObject *resultobj;
16224 wxDC *arg1 = (wxDC *) 0 ;
16225 double arg2 ;
16226 double arg3 ;
16227 PyObject * obj0 = 0 ;
16228 PyObject * obj1 = 0 ;
16229 PyObject * obj2 = 0 ;
16230 char *kwnames[] = {
16231 (char *) "self",(char *) "x",(char *) "y", NULL
16232 };
16233
16234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalScale",kwnames,&obj0,&obj1,&obj2)) goto fail;
16235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16236 if (SWIG_arg_fail(1)) SWIG_fail;
16237 {
16238 arg2 = (double)(SWIG_As_double(obj1));
16239 if (SWIG_arg_fail(2)) SWIG_fail;
16240 }
16241 {
16242 arg3 = (double)(SWIG_As_double(obj2));
16243 if (SWIG_arg_fail(3)) SWIG_fail;
16244 }
16245 {
16246 PyThreadState* __tstate = wxPyBeginAllowThreads();
16247 (arg1)->SetLogicalScale(arg2,arg3);
16248
16249 wxPyEndAllowThreads(__tstate);
16250 if (PyErr_Occurred()) SWIG_fail;
16251 }
16252 Py_INCREF(Py_None); resultobj = Py_None;
16253 return resultobj;
16254 fail:
16255 return NULL;
16256 }
16257
16258
16259 static PyObject *_wrap_DC_GetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16260 PyObject *resultobj;
16261 wxDC *arg1 = (wxDC *) 0 ;
16262 wxPoint result;
16263 PyObject * obj0 = 0 ;
16264 char *kwnames[] = {
16265 (char *) "self", NULL
16266 };
16267
16268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOrigin",kwnames,&obj0)) goto fail;
16269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16270 if (SWIG_arg_fail(1)) SWIG_fail;
16271 {
16272 PyThreadState* __tstate = wxPyBeginAllowThreads();
16273 result = ((wxDC const *)arg1)->GetLogicalOrigin();
16274
16275 wxPyEndAllowThreads(__tstate);
16276 if (PyErr_Occurred()) SWIG_fail;
16277 }
16278 {
16279 wxPoint * resultptr;
16280 resultptr = new wxPoint((wxPoint &)(result));
16281 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16282 }
16283 return resultobj;
16284 fail:
16285 return NULL;
16286 }
16287
16288
16289 static PyObject *_wrap_DC_GetLogicalOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16290 PyObject *resultobj;
16291 wxDC *arg1 = (wxDC *) 0 ;
16292 int *arg2 = (int *) 0 ;
16293 int *arg3 = (int *) 0 ;
16294 int temp2 ;
16295 int res2 = 0 ;
16296 int temp3 ;
16297 int res3 = 0 ;
16298 PyObject * obj0 = 0 ;
16299 char *kwnames[] = {
16300 (char *) "self", NULL
16301 };
16302
16303 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16304 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalOriginTuple",kwnames,&obj0)) goto fail;
16306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16307 if (SWIG_arg_fail(1)) SWIG_fail;
16308 {
16309 PyThreadState* __tstate = wxPyBeginAllowThreads();
16310 ((wxDC const *)arg1)->GetLogicalOrigin(arg2,arg3);
16311
16312 wxPyEndAllowThreads(__tstate);
16313 if (PyErr_Occurred()) SWIG_fail;
16314 }
16315 Py_INCREF(Py_None); resultobj = Py_None;
16316 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16317 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16318 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16319 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16320 return resultobj;
16321 fail:
16322 return NULL;
16323 }
16324
16325
16326 static PyObject *_wrap_DC_SetLogicalOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16327 PyObject *resultobj;
16328 wxDC *arg1 = (wxDC *) 0 ;
16329 int arg2 ;
16330 int arg3 ;
16331 PyObject * obj0 = 0 ;
16332 PyObject * obj1 = 0 ;
16333 PyObject * obj2 = 0 ;
16334 char *kwnames[] = {
16335 (char *) "self",(char *) "x",(char *) "y", NULL
16336 };
16337
16338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetLogicalOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
16339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16340 if (SWIG_arg_fail(1)) SWIG_fail;
16341 {
16342 arg2 = (int)(SWIG_As_int(obj1));
16343 if (SWIG_arg_fail(2)) SWIG_fail;
16344 }
16345 {
16346 arg3 = (int)(SWIG_As_int(obj2));
16347 if (SWIG_arg_fail(3)) SWIG_fail;
16348 }
16349 {
16350 PyThreadState* __tstate = wxPyBeginAllowThreads();
16351 (arg1)->SetLogicalOrigin(arg2,arg3);
16352
16353 wxPyEndAllowThreads(__tstate);
16354 if (PyErr_Occurred()) SWIG_fail;
16355 }
16356 Py_INCREF(Py_None); resultobj = Py_None;
16357 return resultobj;
16358 fail:
16359 return NULL;
16360 }
16361
16362
16363 static PyObject *_wrap_DC_SetLogicalOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16364 PyObject *resultobj;
16365 wxDC *arg1 = (wxDC *) 0 ;
16366 wxPoint *arg2 = 0 ;
16367 wxPoint temp2 ;
16368 PyObject * obj0 = 0 ;
16369 PyObject * obj1 = 0 ;
16370 char *kwnames[] = {
16371 (char *) "self",(char *) "point", NULL
16372 };
16373
16374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalOriginPoint",kwnames,&obj0,&obj1)) goto fail;
16375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16376 if (SWIG_arg_fail(1)) SWIG_fail;
16377 {
16378 arg2 = &temp2;
16379 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16380 }
16381 {
16382 PyThreadState* __tstate = wxPyBeginAllowThreads();
16383 wxDC_SetLogicalOriginPoint(arg1,(wxPoint const &)*arg2);
16384
16385 wxPyEndAllowThreads(__tstate);
16386 if (PyErr_Occurred()) SWIG_fail;
16387 }
16388 Py_INCREF(Py_None); resultobj = Py_None;
16389 return resultobj;
16390 fail:
16391 return NULL;
16392 }
16393
16394
16395 static PyObject *_wrap_DC_GetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16396 PyObject *resultobj;
16397 wxDC *arg1 = (wxDC *) 0 ;
16398 wxPoint result;
16399 PyObject * obj0 = 0 ;
16400 char *kwnames[] = {
16401 (char *) "self", NULL
16402 };
16403
16404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOrigin",kwnames,&obj0)) goto fail;
16405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16406 if (SWIG_arg_fail(1)) SWIG_fail;
16407 {
16408 PyThreadState* __tstate = wxPyBeginAllowThreads();
16409 result = ((wxDC const *)arg1)->GetDeviceOrigin();
16410
16411 wxPyEndAllowThreads(__tstate);
16412 if (PyErr_Occurred()) SWIG_fail;
16413 }
16414 {
16415 wxPoint * resultptr;
16416 resultptr = new wxPoint((wxPoint &)(result));
16417 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16418 }
16419 return resultobj;
16420 fail:
16421 return NULL;
16422 }
16423
16424
16425 static PyObject *_wrap_DC_GetDeviceOriginTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16426 PyObject *resultobj;
16427 wxDC *arg1 = (wxDC *) 0 ;
16428 int *arg2 = (int *) 0 ;
16429 int *arg3 = (int *) 0 ;
16430 int temp2 ;
16431 int res2 = 0 ;
16432 int temp3 ;
16433 int res3 = 0 ;
16434 PyObject * obj0 = 0 ;
16435 char *kwnames[] = {
16436 (char *) "self", NULL
16437 };
16438
16439 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16440 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetDeviceOriginTuple",kwnames,&obj0)) goto fail;
16442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16443 if (SWIG_arg_fail(1)) SWIG_fail;
16444 {
16445 PyThreadState* __tstate = wxPyBeginAllowThreads();
16446 ((wxDC const *)arg1)->GetDeviceOrigin(arg2,arg3);
16447
16448 wxPyEndAllowThreads(__tstate);
16449 if (PyErr_Occurred()) SWIG_fail;
16450 }
16451 Py_INCREF(Py_None); resultobj = Py_None;
16452 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16453 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16454 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16455 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16456 return resultobj;
16457 fail:
16458 return NULL;
16459 }
16460
16461
16462 static PyObject *_wrap_DC_SetDeviceOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16463 PyObject *resultobj;
16464 wxDC *arg1 = (wxDC *) 0 ;
16465 int arg2 ;
16466 int arg3 ;
16467 PyObject * obj0 = 0 ;
16468 PyObject * obj1 = 0 ;
16469 PyObject * obj2 = 0 ;
16470 char *kwnames[] = {
16471 (char *) "self",(char *) "x",(char *) "y", NULL
16472 };
16473
16474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetDeviceOrigin",kwnames,&obj0,&obj1,&obj2)) goto fail;
16475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16476 if (SWIG_arg_fail(1)) SWIG_fail;
16477 {
16478 arg2 = (int)(SWIG_As_int(obj1));
16479 if (SWIG_arg_fail(2)) SWIG_fail;
16480 }
16481 {
16482 arg3 = (int)(SWIG_As_int(obj2));
16483 if (SWIG_arg_fail(3)) SWIG_fail;
16484 }
16485 {
16486 PyThreadState* __tstate = wxPyBeginAllowThreads();
16487 (arg1)->SetDeviceOrigin(arg2,arg3);
16488
16489 wxPyEndAllowThreads(__tstate);
16490 if (PyErr_Occurred()) SWIG_fail;
16491 }
16492 Py_INCREF(Py_None); resultobj = Py_None;
16493 return resultobj;
16494 fail:
16495 return NULL;
16496 }
16497
16498
16499 static PyObject *_wrap_DC_SetDeviceOriginPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16500 PyObject *resultobj;
16501 wxDC *arg1 = (wxDC *) 0 ;
16502 wxPoint *arg2 = 0 ;
16503 wxPoint temp2 ;
16504 PyObject * obj0 = 0 ;
16505 PyObject * obj1 = 0 ;
16506 char *kwnames[] = {
16507 (char *) "self",(char *) "point", NULL
16508 };
16509
16510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetDeviceOriginPoint",kwnames,&obj0,&obj1)) goto fail;
16511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16512 if (SWIG_arg_fail(1)) SWIG_fail;
16513 {
16514 arg2 = &temp2;
16515 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16516 }
16517 {
16518 PyThreadState* __tstate = wxPyBeginAllowThreads();
16519 wxDC_SetDeviceOriginPoint(arg1,(wxPoint const &)*arg2);
16520
16521 wxPyEndAllowThreads(__tstate);
16522 if (PyErr_Occurred()) SWIG_fail;
16523 }
16524 Py_INCREF(Py_None); resultobj = Py_None;
16525 return resultobj;
16526 fail:
16527 return NULL;
16528 }
16529
16530
16531 static PyObject *_wrap_DC_SetAxisOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16532 PyObject *resultobj;
16533 wxDC *arg1 = (wxDC *) 0 ;
16534 bool arg2 ;
16535 bool arg3 ;
16536 PyObject * obj0 = 0 ;
16537 PyObject * obj1 = 0 ;
16538 PyObject * obj2 = 0 ;
16539 char *kwnames[] = {
16540 (char *) "self",(char *) "xLeftRight",(char *) "yBottomUp", NULL
16541 };
16542
16543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_SetAxisOrientation",kwnames,&obj0,&obj1,&obj2)) goto fail;
16544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16545 if (SWIG_arg_fail(1)) SWIG_fail;
16546 {
16547 arg2 = (bool)(SWIG_As_bool(obj1));
16548 if (SWIG_arg_fail(2)) SWIG_fail;
16549 }
16550 {
16551 arg3 = (bool)(SWIG_As_bool(obj2));
16552 if (SWIG_arg_fail(3)) SWIG_fail;
16553 }
16554 {
16555 PyThreadState* __tstate = wxPyBeginAllowThreads();
16556 (arg1)->SetAxisOrientation(arg2,arg3);
16557
16558 wxPyEndAllowThreads(__tstate);
16559 if (PyErr_Occurred()) SWIG_fail;
16560 }
16561 Py_INCREF(Py_None); resultobj = Py_None;
16562 return resultobj;
16563 fail:
16564 return NULL;
16565 }
16566
16567
16568 static PyObject *_wrap_DC_GetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
16569 PyObject *resultobj;
16570 wxDC *arg1 = (wxDC *) 0 ;
16571 int result;
16572 PyObject * obj0 = 0 ;
16573 char *kwnames[] = {
16574 (char *) "self", NULL
16575 };
16576
16577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetLogicalFunction",kwnames,&obj0)) goto fail;
16578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16579 if (SWIG_arg_fail(1)) SWIG_fail;
16580 {
16581 PyThreadState* __tstate = wxPyBeginAllowThreads();
16582 result = (int)((wxDC const *)arg1)->GetLogicalFunction();
16583
16584 wxPyEndAllowThreads(__tstate);
16585 if (PyErr_Occurred()) SWIG_fail;
16586 }
16587 {
16588 resultobj = SWIG_From_int((int)(result));
16589 }
16590 return resultobj;
16591 fail:
16592 return NULL;
16593 }
16594
16595
16596 static PyObject *_wrap_DC_SetLogicalFunction(PyObject *, PyObject *args, PyObject *kwargs) {
16597 PyObject *resultobj;
16598 wxDC *arg1 = (wxDC *) 0 ;
16599 int arg2 ;
16600 PyObject * obj0 = 0 ;
16601 PyObject * obj1 = 0 ;
16602 char *kwnames[] = {
16603 (char *) "self",(char *) "function", NULL
16604 };
16605
16606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_SetLogicalFunction",kwnames,&obj0,&obj1)) goto fail;
16607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16608 if (SWIG_arg_fail(1)) SWIG_fail;
16609 {
16610 arg2 = (int)(SWIG_As_int(obj1));
16611 if (SWIG_arg_fail(2)) SWIG_fail;
16612 }
16613 {
16614 PyThreadState* __tstate = wxPyBeginAllowThreads();
16615 (arg1)->SetLogicalFunction(arg2);
16616
16617 wxPyEndAllowThreads(__tstate);
16618 if (PyErr_Occurred()) SWIG_fail;
16619 }
16620 Py_INCREF(Py_None); resultobj = Py_None;
16621 return resultobj;
16622 fail:
16623 return NULL;
16624 }
16625
16626
16627 static PyObject *_wrap_DC_ComputeScaleAndOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
16628 PyObject *resultobj;
16629 wxDC *arg1 = (wxDC *) 0 ;
16630 PyObject * obj0 = 0 ;
16631 char *kwnames[] = {
16632 (char *) "self", NULL
16633 };
16634
16635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ComputeScaleAndOrigin",kwnames,&obj0)) goto fail;
16636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16637 if (SWIG_arg_fail(1)) SWIG_fail;
16638 {
16639 PyThreadState* __tstate = wxPyBeginAllowThreads();
16640 (arg1)->ComputeScaleAndOrigin();
16641
16642 wxPyEndAllowThreads(__tstate);
16643 if (PyErr_Occurred()) SWIG_fail;
16644 }
16645 Py_INCREF(Py_None); resultobj = Py_None;
16646 return resultobj;
16647 fail:
16648 return NULL;
16649 }
16650
16651
16652 static PyObject *_wrap_DC_CalcBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16653 PyObject *resultobj;
16654 wxDC *arg1 = (wxDC *) 0 ;
16655 int arg2 ;
16656 int arg3 ;
16657 PyObject * obj0 = 0 ;
16658 PyObject * obj1 = 0 ;
16659 PyObject * obj2 = 0 ;
16660 char *kwnames[] = {
16661 (char *) "self",(char *) "x",(char *) "y", NULL
16662 };
16663
16664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DC_CalcBoundingBox",kwnames,&obj0,&obj1,&obj2)) goto fail;
16665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16666 if (SWIG_arg_fail(1)) SWIG_fail;
16667 {
16668 arg2 = (int)(SWIG_As_int(obj1));
16669 if (SWIG_arg_fail(2)) SWIG_fail;
16670 }
16671 {
16672 arg3 = (int)(SWIG_As_int(obj2));
16673 if (SWIG_arg_fail(3)) SWIG_fail;
16674 }
16675 {
16676 PyThreadState* __tstate = wxPyBeginAllowThreads();
16677 (arg1)->CalcBoundingBox(arg2,arg3);
16678
16679 wxPyEndAllowThreads(__tstate);
16680 if (PyErr_Occurred()) SWIG_fail;
16681 }
16682 Py_INCREF(Py_None); resultobj = Py_None;
16683 return resultobj;
16684 fail:
16685 return NULL;
16686 }
16687
16688
16689 static PyObject *_wrap_DC_CalcBoundingBoxPoint(PyObject *, PyObject *args, PyObject *kwargs) {
16690 PyObject *resultobj;
16691 wxDC *arg1 = (wxDC *) 0 ;
16692 wxPoint *arg2 = 0 ;
16693 wxPoint temp2 ;
16694 PyObject * obj0 = 0 ;
16695 PyObject * obj1 = 0 ;
16696 char *kwnames[] = {
16697 (char *) "self",(char *) "point", NULL
16698 };
16699
16700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DC_CalcBoundingBoxPoint",kwnames,&obj0,&obj1)) goto fail;
16701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16702 if (SWIG_arg_fail(1)) SWIG_fail;
16703 {
16704 arg2 = &temp2;
16705 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16706 }
16707 {
16708 PyThreadState* __tstate = wxPyBeginAllowThreads();
16709 wxDC_CalcBoundingBoxPoint(arg1,(wxPoint const &)*arg2);
16710
16711 wxPyEndAllowThreads(__tstate);
16712 if (PyErr_Occurred()) SWIG_fail;
16713 }
16714 Py_INCREF(Py_None); resultobj = Py_None;
16715 return resultobj;
16716 fail:
16717 return NULL;
16718 }
16719
16720
16721 static PyObject *_wrap_DC_ResetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16722 PyObject *resultobj;
16723 wxDC *arg1 = (wxDC *) 0 ;
16724 PyObject * obj0 = 0 ;
16725 char *kwnames[] = {
16726 (char *) "self", NULL
16727 };
16728
16729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_ResetBoundingBox",kwnames,&obj0)) goto fail;
16730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16731 if (SWIG_arg_fail(1)) SWIG_fail;
16732 {
16733 PyThreadState* __tstate = wxPyBeginAllowThreads();
16734 (arg1)->ResetBoundingBox();
16735
16736 wxPyEndAllowThreads(__tstate);
16737 if (PyErr_Occurred()) SWIG_fail;
16738 }
16739 Py_INCREF(Py_None); resultobj = Py_None;
16740 return resultobj;
16741 fail:
16742 return NULL;
16743 }
16744
16745
16746 static PyObject *_wrap_DC_MinX(PyObject *, PyObject *args, PyObject *kwargs) {
16747 PyObject *resultobj;
16748 wxDC *arg1 = (wxDC *) 0 ;
16749 int result;
16750 PyObject * obj0 = 0 ;
16751 char *kwnames[] = {
16752 (char *) "self", NULL
16753 };
16754
16755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinX",kwnames,&obj0)) goto fail;
16756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16757 if (SWIG_arg_fail(1)) SWIG_fail;
16758 {
16759 PyThreadState* __tstate = wxPyBeginAllowThreads();
16760 result = (int)((wxDC const *)arg1)->MinX();
16761
16762 wxPyEndAllowThreads(__tstate);
16763 if (PyErr_Occurred()) SWIG_fail;
16764 }
16765 {
16766 resultobj = SWIG_From_int((int)(result));
16767 }
16768 return resultobj;
16769 fail:
16770 return NULL;
16771 }
16772
16773
16774 static PyObject *_wrap_DC_MaxX(PyObject *, PyObject *args, PyObject *kwargs) {
16775 PyObject *resultobj;
16776 wxDC *arg1 = (wxDC *) 0 ;
16777 int result;
16778 PyObject * obj0 = 0 ;
16779 char *kwnames[] = {
16780 (char *) "self", NULL
16781 };
16782
16783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxX",kwnames,&obj0)) goto fail;
16784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16785 if (SWIG_arg_fail(1)) SWIG_fail;
16786 {
16787 PyThreadState* __tstate = wxPyBeginAllowThreads();
16788 result = (int)((wxDC const *)arg1)->MaxX();
16789
16790 wxPyEndAllowThreads(__tstate);
16791 if (PyErr_Occurred()) SWIG_fail;
16792 }
16793 {
16794 resultobj = SWIG_From_int((int)(result));
16795 }
16796 return resultobj;
16797 fail:
16798 return NULL;
16799 }
16800
16801
16802 static PyObject *_wrap_DC_MinY(PyObject *, PyObject *args, PyObject *kwargs) {
16803 PyObject *resultobj;
16804 wxDC *arg1 = (wxDC *) 0 ;
16805 int result;
16806 PyObject * obj0 = 0 ;
16807 char *kwnames[] = {
16808 (char *) "self", NULL
16809 };
16810
16811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MinY",kwnames,&obj0)) goto fail;
16812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16813 if (SWIG_arg_fail(1)) SWIG_fail;
16814 {
16815 PyThreadState* __tstate = wxPyBeginAllowThreads();
16816 result = (int)((wxDC const *)arg1)->MinY();
16817
16818 wxPyEndAllowThreads(__tstate);
16819 if (PyErr_Occurred()) SWIG_fail;
16820 }
16821 {
16822 resultobj = SWIG_From_int((int)(result));
16823 }
16824 return resultobj;
16825 fail:
16826 return NULL;
16827 }
16828
16829
16830 static PyObject *_wrap_DC_MaxY(PyObject *, PyObject *args, PyObject *kwargs) {
16831 PyObject *resultobj;
16832 wxDC *arg1 = (wxDC *) 0 ;
16833 int result;
16834 PyObject * obj0 = 0 ;
16835 char *kwnames[] = {
16836 (char *) "self", NULL
16837 };
16838
16839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_MaxY",kwnames,&obj0)) goto fail;
16840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16841 if (SWIG_arg_fail(1)) SWIG_fail;
16842 {
16843 PyThreadState* __tstate = wxPyBeginAllowThreads();
16844 result = (int)((wxDC const *)arg1)->MaxY();
16845
16846 wxPyEndAllowThreads(__tstate);
16847 if (PyErr_Occurred()) SWIG_fail;
16848 }
16849 {
16850 resultobj = SWIG_From_int((int)(result));
16851 }
16852 return resultobj;
16853 fail:
16854 return NULL;
16855 }
16856
16857
16858 static PyObject *_wrap_DC_GetBoundingBox(PyObject *, PyObject *args, PyObject *kwargs) {
16859 PyObject *resultobj;
16860 wxDC *arg1 = (wxDC *) 0 ;
16861 int *arg2 = (int *) 0 ;
16862 int *arg3 = (int *) 0 ;
16863 int *arg4 = (int *) 0 ;
16864 int *arg5 = (int *) 0 ;
16865 int temp2 ;
16866 int res2 = 0 ;
16867 int temp3 ;
16868 int res3 = 0 ;
16869 int temp4 ;
16870 int res4 = 0 ;
16871 int temp5 ;
16872 int res5 = 0 ;
16873 PyObject * obj0 = 0 ;
16874 char *kwnames[] = {
16875 (char *) "self", NULL
16876 };
16877
16878 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16879 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16880 arg4 = &temp4; res4 = SWIG_NEWOBJ;
16881 arg5 = &temp5; res5 = SWIG_NEWOBJ;
16882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DC_GetBoundingBox",kwnames,&obj0)) goto fail;
16883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16884 if (SWIG_arg_fail(1)) SWIG_fail;
16885 {
16886 PyThreadState* __tstate = wxPyBeginAllowThreads();
16887 wxDC_GetBoundingBox(arg1,arg2,arg3,arg4,arg5);
16888
16889 wxPyEndAllowThreads(__tstate);
16890 if (PyErr_Occurred()) SWIG_fail;
16891 }
16892 Py_INCREF(Py_None); resultobj = Py_None;
16893 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16894 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
16895 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16896 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
16897 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
16898 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
16899 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
16900 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
16901 return resultobj;
16902 fail:
16903 return NULL;
16904 }
16905
16906
16907 static PyObject *_wrap_DC__DrawPointList(PyObject *, PyObject *args, PyObject *kwargs) {
16908 PyObject *resultobj;
16909 wxDC *arg1 = (wxDC *) 0 ;
16910 PyObject *arg2 = (PyObject *) 0 ;
16911 PyObject *arg3 = (PyObject *) 0 ;
16912 PyObject *arg4 = (PyObject *) 0 ;
16913 PyObject *result;
16914 PyObject * obj0 = 0 ;
16915 PyObject * obj1 = 0 ;
16916 PyObject * obj2 = 0 ;
16917 PyObject * obj3 = 0 ;
16918 char *kwnames[] = {
16919 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
16920 };
16921
16922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPointList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16924 if (SWIG_arg_fail(1)) SWIG_fail;
16925 arg2 = obj1;
16926 arg3 = obj2;
16927 arg4 = obj3;
16928 {
16929 PyThreadState* __tstate = wxPyBeginAllowThreads();
16930 result = (PyObject *)wxDC__DrawPointList(arg1,arg2,arg3,arg4);
16931
16932 wxPyEndAllowThreads(__tstate);
16933 if (PyErr_Occurred()) SWIG_fail;
16934 }
16935 resultobj = result;
16936 return resultobj;
16937 fail:
16938 return NULL;
16939 }
16940
16941
16942 static PyObject *_wrap_DC__DrawLineList(PyObject *, PyObject *args, PyObject *kwargs) {
16943 PyObject *resultobj;
16944 wxDC *arg1 = (wxDC *) 0 ;
16945 PyObject *arg2 = (PyObject *) 0 ;
16946 PyObject *arg3 = (PyObject *) 0 ;
16947 PyObject *arg4 = (PyObject *) 0 ;
16948 PyObject *result;
16949 PyObject * obj0 = 0 ;
16950 PyObject * obj1 = 0 ;
16951 PyObject * obj2 = 0 ;
16952 PyObject * obj3 = 0 ;
16953 char *kwnames[] = {
16954 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
16955 };
16956
16957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawLineList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16959 if (SWIG_arg_fail(1)) SWIG_fail;
16960 arg2 = obj1;
16961 arg3 = obj2;
16962 arg4 = obj3;
16963 {
16964 PyThreadState* __tstate = wxPyBeginAllowThreads();
16965 result = (PyObject *)wxDC__DrawLineList(arg1,arg2,arg3,arg4);
16966
16967 wxPyEndAllowThreads(__tstate);
16968 if (PyErr_Occurred()) SWIG_fail;
16969 }
16970 resultobj = result;
16971 return resultobj;
16972 fail:
16973 return NULL;
16974 }
16975
16976
16977 static PyObject *_wrap_DC__DrawRectangleList(PyObject *, PyObject *args, PyObject *kwargs) {
16978 PyObject *resultobj;
16979 wxDC *arg1 = (wxDC *) 0 ;
16980 PyObject *arg2 = (PyObject *) 0 ;
16981 PyObject *arg3 = (PyObject *) 0 ;
16982 PyObject *arg4 = (PyObject *) 0 ;
16983 PyObject *result;
16984 PyObject * obj0 = 0 ;
16985 PyObject * obj1 = 0 ;
16986 PyObject * obj2 = 0 ;
16987 PyObject * obj3 = 0 ;
16988 char *kwnames[] = {
16989 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
16990 };
16991
16992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawRectangleList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16994 if (SWIG_arg_fail(1)) SWIG_fail;
16995 arg2 = obj1;
16996 arg3 = obj2;
16997 arg4 = obj3;
16998 {
16999 PyThreadState* __tstate = wxPyBeginAllowThreads();
17000 result = (PyObject *)wxDC__DrawRectangleList(arg1,arg2,arg3,arg4);
17001
17002 wxPyEndAllowThreads(__tstate);
17003 if (PyErr_Occurred()) SWIG_fail;
17004 }
17005 resultobj = result;
17006 return resultobj;
17007 fail:
17008 return NULL;
17009 }
17010
17011
17012 static PyObject *_wrap_DC__DrawEllipseList(PyObject *, PyObject *args, PyObject *kwargs) {
17013 PyObject *resultobj;
17014 wxDC *arg1 = (wxDC *) 0 ;
17015 PyObject *arg2 = (PyObject *) 0 ;
17016 PyObject *arg3 = (PyObject *) 0 ;
17017 PyObject *arg4 = (PyObject *) 0 ;
17018 PyObject *result;
17019 PyObject * obj0 = 0 ;
17020 PyObject * obj1 = 0 ;
17021 PyObject * obj2 = 0 ;
17022 PyObject * obj3 = 0 ;
17023 char *kwnames[] = {
17024 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17025 };
17026
17027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawEllipseList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17029 if (SWIG_arg_fail(1)) SWIG_fail;
17030 arg2 = obj1;
17031 arg3 = obj2;
17032 arg4 = obj3;
17033 {
17034 PyThreadState* __tstate = wxPyBeginAllowThreads();
17035 result = (PyObject *)wxDC__DrawEllipseList(arg1,arg2,arg3,arg4);
17036
17037 wxPyEndAllowThreads(__tstate);
17038 if (PyErr_Occurred()) SWIG_fail;
17039 }
17040 resultobj = result;
17041 return resultobj;
17042 fail:
17043 return NULL;
17044 }
17045
17046
17047 static PyObject *_wrap_DC__DrawPolygonList(PyObject *, PyObject *args, PyObject *kwargs) {
17048 PyObject *resultobj;
17049 wxDC *arg1 = (wxDC *) 0 ;
17050 PyObject *arg2 = (PyObject *) 0 ;
17051 PyObject *arg3 = (PyObject *) 0 ;
17052 PyObject *arg4 = (PyObject *) 0 ;
17053 PyObject *result;
17054 PyObject * obj0 = 0 ;
17055 PyObject * obj1 = 0 ;
17056 PyObject * obj2 = 0 ;
17057 PyObject * obj3 = 0 ;
17058 char *kwnames[] = {
17059 (char *) "self",(char *) "pyCoords",(char *) "pyPens",(char *) "pyBrushes", NULL
17060 };
17061
17062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DC__DrawPolygonList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17064 if (SWIG_arg_fail(1)) SWIG_fail;
17065 arg2 = obj1;
17066 arg3 = obj2;
17067 arg4 = obj3;
17068 {
17069 PyThreadState* __tstate = wxPyBeginAllowThreads();
17070 result = (PyObject *)wxDC__DrawPolygonList(arg1,arg2,arg3,arg4);
17071
17072 wxPyEndAllowThreads(__tstate);
17073 if (PyErr_Occurred()) SWIG_fail;
17074 }
17075 resultobj = result;
17076 return resultobj;
17077 fail:
17078 return NULL;
17079 }
17080
17081
17082 static PyObject *_wrap_DC__DrawTextList(PyObject *, PyObject *args, PyObject *kwargs) {
17083 PyObject *resultobj;
17084 wxDC *arg1 = (wxDC *) 0 ;
17085 PyObject *arg2 = (PyObject *) 0 ;
17086 PyObject *arg3 = (PyObject *) 0 ;
17087 PyObject *arg4 = (PyObject *) 0 ;
17088 PyObject *arg5 = (PyObject *) 0 ;
17089 PyObject *result;
17090 PyObject * obj0 = 0 ;
17091 PyObject * obj1 = 0 ;
17092 PyObject * obj2 = 0 ;
17093 PyObject * obj3 = 0 ;
17094 PyObject * obj4 = 0 ;
17095 char *kwnames[] = {
17096 (char *) "self",(char *) "textList",(char *) "pyPoints",(char *) "foregroundList",(char *) "backgroundList", NULL
17097 };
17098
17099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:DC__DrawTextList",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
17100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17101 if (SWIG_arg_fail(1)) SWIG_fail;
17102 arg2 = obj1;
17103 arg3 = obj2;
17104 arg4 = obj3;
17105 arg5 = obj4;
17106 {
17107 PyThreadState* __tstate = wxPyBeginAllowThreads();
17108 result = (PyObject *)wxDC__DrawTextList(arg1,arg2,arg3,arg4,arg5);
17109
17110 wxPyEndAllowThreads(__tstate);
17111 if (PyErr_Occurred()) SWIG_fail;
17112 }
17113 resultobj = result;
17114 return resultobj;
17115 fail:
17116 return NULL;
17117 }
17118
17119
17120 static PyObject * DC_swigregister(PyObject *, PyObject *args) {
17121 PyObject *obj;
17122 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17123 SWIG_TypeClientData(SWIGTYPE_p_wxDC, obj);
17124 Py_INCREF(obj);
17125 return Py_BuildValue((char *)"");
17126 }
17127 static PyObject *_wrap_new_MemoryDC(PyObject *, PyObject *args, PyObject *kwargs) {
17128 PyObject *resultobj;
17129 wxMemoryDC *result;
17130 char *kwnames[] = {
17131 NULL
17132 };
17133
17134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryDC",kwnames)) goto fail;
17135 {
17136 if (!wxPyCheckForApp()) SWIG_fail;
17137 PyThreadState* __tstate = wxPyBeginAllowThreads();
17138 result = (wxMemoryDC *)new wxMemoryDC();
17139
17140 wxPyEndAllowThreads(__tstate);
17141 if (PyErr_Occurred()) SWIG_fail;
17142 }
17143 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17144 return resultobj;
17145 fail:
17146 return NULL;
17147 }
17148
17149
17150 static PyObject *_wrap_new_MemoryDCFromDC(PyObject *, PyObject *args, PyObject *kwargs) {
17151 PyObject *resultobj;
17152 wxDC *arg1 = (wxDC *) 0 ;
17153 wxMemoryDC *result;
17154 PyObject * obj0 = 0 ;
17155 char *kwnames[] = {
17156 (char *) "oldDC", NULL
17157 };
17158
17159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_MemoryDCFromDC",kwnames,&obj0)) goto fail;
17160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17161 if (SWIG_arg_fail(1)) SWIG_fail;
17162 {
17163 if (!wxPyCheckForApp()) SWIG_fail;
17164 PyThreadState* __tstate = wxPyBeginAllowThreads();
17165 result = (wxMemoryDC *)new wxMemoryDC(arg1);
17166
17167 wxPyEndAllowThreads(__tstate);
17168 if (PyErr_Occurred()) SWIG_fail;
17169 }
17170 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryDC, 1);
17171 return resultobj;
17172 fail:
17173 return NULL;
17174 }
17175
17176
17177 static PyObject *_wrap_MemoryDC_SelectObject(PyObject *, PyObject *args, PyObject *kwargs) {
17178 PyObject *resultobj;
17179 wxMemoryDC *arg1 = (wxMemoryDC *) 0 ;
17180 wxBitmap *arg2 = 0 ;
17181 PyObject * obj0 = 0 ;
17182 PyObject * obj1 = 0 ;
17183 char *kwnames[] = {
17184 (char *) "self",(char *) "bitmap", NULL
17185 };
17186
17187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryDC_SelectObject",kwnames,&obj0,&obj1)) goto fail;
17188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryDC, SWIG_POINTER_EXCEPTION | 0);
17189 if (SWIG_arg_fail(1)) SWIG_fail;
17190 {
17191 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17192 if (SWIG_arg_fail(2)) SWIG_fail;
17193 if (arg2 == NULL) {
17194 SWIG_null_ref("wxBitmap");
17195 }
17196 if (SWIG_arg_fail(2)) SWIG_fail;
17197 }
17198 {
17199 PyThreadState* __tstate = wxPyBeginAllowThreads();
17200 (arg1)->SelectObject((wxBitmap const &)*arg2);
17201
17202 wxPyEndAllowThreads(__tstate);
17203 if (PyErr_Occurred()) SWIG_fail;
17204 }
17205 Py_INCREF(Py_None); resultobj = Py_None;
17206 return resultobj;
17207 fail:
17208 return NULL;
17209 }
17210
17211
17212 static PyObject * MemoryDC_swigregister(PyObject *, PyObject *args) {
17213 PyObject *obj;
17214 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17215 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryDC, obj);
17216 Py_INCREF(obj);
17217 return Py_BuildValue((char *)"");
17218 }
17219 static PyObject *_wrap_new_BufferedDC__SWIG_0(PyObject *, PyObject *args) {
17220 PyObject *resultobj;
17221 wxDC *arg1 = (wxDC *) 0 ;
17222 wxBitmap *arg2 = 0 ;
17223 wxBufferedDC *result;
17224 PyObject * obj0 = 0 ;
17225 PyObject * obj1 = 0 ;
17226
17227 if(!PyArg_ParseTuple(args,(char *)"OO:new_BufferedDC",&obj0,&obj1)) goto fail;
17228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17229 if (SWIG_arg_fail(1)) SWIG_fail;
17230 {
17231 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17232 if (SWIG_arg_fail(2)) SWIG_fail;
17233 if (arg2 == NULL) {
17234 SWIG_null_ref("wxBitmap");
17235 }
17236 if (SWIG_arg_fail(2)) SWIG_fail;
17237 }
17238 {
17239 if (!wxPyCheckForApp()) SWIG_fail;
17240 PyThreadState* __tstate = wxPyBeginAllowThreads();
17241 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxBitmap const &)*arg2);
17242
17243 wxPyEndAllowThreads(__tstate);
17244 if (PyErr_Occurred()) SWIG_fail;
17245 }
17246 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
17247 return resultobj;
17248 fail:
17249 return NULL;
17250 }
17251
17252
17253 static PyObject *_wrap_new_BufferedDC__SWIG_1(PyObject *, PyObject *args) {
17254 PyObject *resultobj;
17255 wxDC *arg1 = (wxDC *) 0 ;
17256 wxSize *arg2 = 0 ;
17257 wxBufferedDC *result;
17258 wxSize temp2 ;
17259 PyObject * obj0 = 0 ;
17260 PyObject * obj1 = 0 ;
17261
17262 if(!PyArg_ParseTuple(args,(char *)"OO:new_BufferedDC",&obj0,&obj1)) goto fail;
17263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17264 if (SWIG_arg_fail(1)) SWIG_fail;
17265 {
17266 arg2 = &temp2;
17267 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
17268 }
17269 {
17270 if (!wxPyCheckForApp()) SWIG_fail;
17271 PyThreadState* __tstate = wxPyBeginAllowThreads();
17272 result = (wxBufferedDC *)new wxBufferedDC(arg1,(wxSize const &)*arg2);
17273
17274 wxPyEndAllowThreads(__tstate);
17275 if (PyErr_Occurred()) SWIG_fail;
17276 }
17277 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedDC, 1);
17278 return resultobj;
17279 fail:
17280 return NULL;
17281 }
17282
17283
17284 static PyObject *_wrap_new_BufferedDC(PyObject *self, PyObject *args) {
17285 int argc;
17286 PyObject *argv[3];
17287 int ii;
17288
17289 argc = PyObject_Length(args);
17290 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
17291 argv[ii] = PyTuple_GetItem(args,ii);
17292 }
17293 if (argc == 2) {
17294 int _v;
17295 {
17296 void *ptr;
17297 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
17298 _v = 0;
17299 PyErr_Clear();
17300 } else {
17301 _v = 1;
17302 }
17303 }
17304 if (_v) {
17305 {
17306 void *ptr = 0;
17307 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxBitmap, 0) == -1) {
17308 _v = 0;
17309 PyErr_Clear();
17310 } else {
17311 _v = (ptr != 0);
17312 }
17313 }
17314 if (_v) {
17315 return _wrap_new_BufferedDC__SWIG_0(self,args);
17316 }
17317 }
17318 }
17319 if (argc == 2) {
17320 int _v;
17321 {
17322 void *ptr;
17323 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDC, 0) == -1) {
17324 _v = 0;
17325 PyErr_Clear();
17326 } else {
17327 _v = 1;
17328 }
17329 }
17330 if (_v) {
17331 {
17332 _v = wxPySimple_typecheck(argv[1], wxT("wxSize"), 2);
17333 }
17334 if (_v) {
17335 return _wrap_new_BufferedDC__SWIG_1(self,args);
17336 }
17337 }
17338 }
17339
17340 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_BufferedDC'");
17341 return NULL;
17342 }
17343
17344
17345 static PyObject *_wrap_delete_BufferedDC(PyObject *, PyObject *args, PyObject *kwargs) {
17346 PyObject *resultobj;
17347 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
17348 PyObject * obj0 = 0 ;
17349 char *kwnames[] = {
17350 (char *) "self", NULL
17351 };
17352
17353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BufferedDC",kwnames,&obj0)) goto fail;
17354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
17355 if (SWIG_arg_fail(1)) SWIG_fail;
17356 {
17357 PyThreadState* __tstate = wxPyBeginAllowThreads();
17358 delete arg1;
17359
17360 wxPyEndAllowThreads(__tstate);
17361 if (PyErr_Occurred()) SWIG_fail;
17362 }
17363 Py_INCREF(Py_None); resultobj = Py_None;
17364 return resultobj;
17365 fail:
17366 return NULL;
17367 }
17368
17369
17370 static PyObject *_wrap_BufferedDC_UnMask(PyObject *, PyObject *args, PyObject *kwargs) {
17371 PyObject *resultobj;
17372 wxBufferedDC *arg1 = (wxBufferedDC *) 0 ;
17373 PyObject * obj0 = 0 ;
17374 char *kwnames[] = {
17375 (char *) "self", NULL
17376 };
17377
17378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BufferedDC_UnMask",kwnames,&obj0)) goto fail;
17379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBufferedDC, SWIG_POINTER_EXCEPTION | 0);
17380 if (SWIG_arg_fail(1)) SWIG_fail;
17381 {
17382 PyThreadState* __tstate = wxPyBeginAllowThreads();
17383 (arg1)->UnMask();
17384
17385 wxPyEndAllowThreads(__tstate);
17386 if (PyErr_Occurred()) SWIG_fail;
17387 }
17388 Py_INCREF(Py_None); resultobj = Py_None;
17389 return resultobj;
17390 fail:
17391 return NULL;
17392 }
17393
17394
17395 static PyObject * BufferedDC_swigregister(PyObject *, PyObject *args) {
17396 PyObject *obj;
17397 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17398 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedDC, obj);
17399 Py_INCREF(obj);
17400 return Py_BuildValue((char *)"");
17401 }
17402 static PyObject *_wrap_new_BufferedPaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
17403 PyObject *resultobj;
17404 wxWindow *arg1 = (wxWindow *) 0 ;
17405 wxBitmap const &arg2_defvalue = wxNullBitmap ;
17406 wxBitmap *arg2 = (wxBitmap *) &arg2_defvalue ;
17407 wxBufferedPaintDC *result;
17408 PyObject * obj0 = 0 ;
17409 PyObject * obj1 = 0 ;
17410 char *kwnames[] = {
17411 (char *) "window",(char *) "buffer", NULL
17412 };
17413
17414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BufferedPaintDC",kwnames,&obj0,&obj1)) goto fail;
17415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17416 if (SWIG_arg_fail(1)) SWIG_fail;
17417 if (obj1) {
17418 {
17419 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
17420 if (SWIG_arg_fail(2)) SWIG_fail;
17421 if (arg2 == NULL) {
17422 SWIG_null_ref("wxBitmap");
17423 }
17424 if (SWIG_arg_fail(2)) SWIG_fail;
17425 }
17426 }
17427 {
17428 if (!wxPyCheckForApp()) SWIG_fail;
17429 PyThreadState* __tstate = wxPyBeginAllowThreads();
17430 result = (wxBufferedPaintDC *)new wxBufferedPaintDC(arg1,(wxBitmap const &)*arg2);
17431
17432 wxPyEndAllowThreads(__tstate);
17433 if (PyErr_Occurred()) SWIG_fail;
17434 }
17435 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBufferedPaintDC, 1);
17436 return resultobj;
17437 fail:
17438 return NULL;
17439 }
17440
17441
17442 static PyObject * BufferedPaintDC_swigregister(PyObject *, PyObject *args) {
17443 PyObject *obj;
17444 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17445 SWIG_TypeClientData(SWIGTYPE_p_wxBufferedPaintDC, obj);
17446 Py_INCREF(obj);
17447 return Py_BuildValue((char *)"");
17448 }
17449 static PyObject *_wrap_new_ScreenDC(PyObject *, PyObject *args, PyObject *kwargs) {
17450 PyObject *resultobj;
17451 wxScreenDC *result;
17452 char *kwnames[] = {
17453 NULL
17454 };
17455
17456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ScreenDC",kwnames)) goto fail;
17457 {
17458 if (!wxPyCheckForApp()) SWIG_fail;
17459 PyThreadState* __tstate = wxPyBeginAllowThreads();
17460 result = (wxScreenDC *)new wxScreenDC();
17461
17462 wxPyEndAllowThreads(__tstate);
17463 if (PyErr_Occurred()) SWIG_fail;
17464 }
17465 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScreenDC, 1);
17466 return resultobj;
17467 fail:
17468 return NULL;
17469 }
17470
17471
17472 static PyObject *_wrap_ScreenDC_StartDrawingOnTopWin(PyObject *, PyObject *args, PyObject *kwargs) {
17473 PyObject *resultobj;
17474 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17475 wxWindow *arg2 = (wxWindow *) 0 ;
17476 bool result;
17477 PyObject * obj0 = 0 ;
17478 PyObject * obj1 = 0 ;
17479 char *kwnames[] = {
17480 (char *) "self",(char *) "window", NULL
17481 };
17482
17483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScreenDC_StartDrawingOnTopWin",kwnames,&obj0,&obj1)) goto fail;
17484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17485 if (SWIG_arg_fail(1)) SWIG_fail;
17486 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17487 if (SWIG_arg_fail(2)) SWIG_fail;
17488 {
17489 PyThreadState* __tstate = wxPyBeginAllowThreads();
17490 result = (bool)(arg1)->StartDrawingOnTop(arg2);
17491
17492 wxPyEndAllowThreads(__tstate);
17493 if (PyErr_Occurred()) SWIG_fail;
17494 }
17495 {
17496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17497 }
17498 return resultobj;
17499 fail:
17500 return NULL;
17501 }
17502
17503
17504 static PyObject *_wrap_ScreenDC_StartDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
17505 PyObject *resultobj;
17506 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17507 wxRect *arg2 = (wxRect *) NULL ;
17508 bool result;
17509 PyObject * obj0 = 0 ;
17510 PyObject * obj1 = 0 ;
17511 char *kwnames[] = {
17512 (char *) "self",(char *) "rect", NULL
17513 };
17514
17515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ScreenDC_StartDrawingOnTop",kwnames,&obj0,&obj1)) goto fail;
17516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17517 if (SWIG_arg_fail(1)) SWIG_fail;
17518 if (obj1) {
17519 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
17520 if (SWIG_arg_fail(2)) SWIG_fail;
17521 }
17522 {
17523 PyThreadState* __tstate = wxPyBeginAllowThreads();
17524 result = (bool)(arg1)->StartDrawingOnTop(arg2);
17525
17526 wxPyEndAllowThreads(__tstate);
17527 if (PyErr_Occurred()) SWIG_fail;
17528 }
17529 {
17530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17531 }
17532 return resultobj;
17533 fail:
17534 return NULL;
17535 }
17536
17537
17538 static PyObject *_wrap_ScreenDC_EndDrawingOnTop(PyObject *, PyObject *args, PyObject *kwargs) {
17539 PyObject *resultobj;
17540 wxScreenDC *arg1 = (wxScreenDC *) 0 ;
17541 bool result;
17542 PyObject * obj0 = 0 ;
17543 char *kwnames[] = {
17544 (char *) "self", NULL
17545 };
17546
17547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScreenDC_EndDrawingOnTop",kwnames,&obj0)) goto fail;
17548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScreenDC, SWIG_POINTER_EXCEPTION | 0);
17549 if (SWIG_arg_fail(1)) SWIG_fail;
17550 {
17551 PyThreadState* __tstate = wxPyBeginAllowThreads();
17552 result = (bool)(arg1)->EndDrawingOnTop();
17553
17554 wxPyEndAllowThreads(__tstate);
17555 if (PyErr_Occurred()) SWIG_fail;
17556 }
17557 {
17558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17559 }
17560 return resultobj;
17561 fail:
17562 return NULL;
17563 }
17564
17565
17566 static PyObject * ScreenDC_swigregister(PyObject *, PyObject *args) {
17567 PyObject *obj;
17568 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17569 SWIG_TypeClientData(SWIGTYPE_p_wxScreenDC, obj);
17570 Py_INCREF(obj);
17571 return Py_BuildValue((char *)"");
17572 }
17573 static PyObject *_wrap_new_ClientDC(PyObject *, PyObject *args, PyObject *kwargs) {
17574 PyObject *resultobj;
17575 wxWindow *arg1 = (wxWindow *) 0 ;
17576 wxClientDC *result;
17577 PyObject * obj0 = 0 ;
17578 char *kwnames[] = {
17579 (char *) "win", NULL
17580 };
17581
17582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ClientDC",kwnames,&obj0)) goto fail;
17583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17584 if (SWIG_arg_fail(1)) SWIG_fail;
17585 {
17586 if (!wxPyCheckForApp()) SWIG_fail;
17587 PyThreadState* __tstate = wxPyBeginAllowThreads();
17588 result = (wxClientDC *)new wxClientDC(arg1);
17589
17590 wxPyEndAllowThreads(__tstate);
17591 if (PyErr_Occurred()) SWIG_fail;
17592 }
17593 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClientDC, 1);
17594 return resultobj;
17595 fail:
17596 return NULL;
17597 }
17598
17599
17600 static PyObject * ClientDC_swigregister(PyObject *, PyObject *args) {
17601 PyObject *obj;
17602 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17603 SWIG_TypeClientData(SWIGTYPE_p_wxClientDC, obj);
17604 Py_INCREF(obj);
17605 return Py_BuildValue((char *)"");
17606 }
17607 static PyObject *_wrap_new_PaintDC(PyObject *, PyObject *args, PyObject *kwargs) {
17608 PyObject *resultobj;
17609 wxWindow *arg1 = (wxWindow *) 0 ;
17610 wxPaintDC *result;
17611 PyObject * obj0 = 0 ;
17612 char *kwnames[] = {
17613 (char *) "win", NULL
17614 };
17615
17616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PaintDC",kwnames,&obj0)) goto fail;
17617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17618 if (SWIG_arg_fail(1)) SWIG_fail;
17619 {
17620 if (!wxPyCheckForApp()) SWIG_fail;
17621 PyThreadState* __tstate = wxPyBeginAllowThreads();
17622 result = (wxPaintDC *)new wxPaintDC(arg1);
17623
17624 wxPyEndAllowThreads(__tstate);
17625 if (PyErr_Occurred()) SWIG_fail;
17626 }
17627 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintDC, 1);
17628 return resultobj;
17629 fail:
17630 return NULL;
17631 }
17632
17633
17634 static PyObject * PaintDC_swigregister(PyObject *, PyObject *args) {
17635 PyObject *obj;
17636 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17637 SWIG_TypeClientData(SWIGTYPE_p_wxPaintDC, obj);
17638 Py_INCREF(obj);
17639 return Py_BuildValue((char *)"");
17640 }
17641 static PyObject *_wrap_new_WindowDC(PyObject *, PyObject *args, PyObject *kwargs) {
17642 PyObject *resultobj;
17643 wxWindow *arg1 = (wxWindow *) 0 ;
17644 wxWindowDC *result;
17645 PyObject * obj0 = 0 ;
17646 char *kwnames[] = {
17647 (char *) "win", NULL
17648 };
17649
17650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_WindowDC",kwnames,&obj0)) goto fail;
17651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
17652 if (SWIG_arg_fail(1)) SWIG_fail;
17653 {
17654 if (!wxPyCheckForApp()) SWIG_fail;
17655 PyThreadState* __tstate = wxPyBeginAllowThreads();
17656 result = (wxWindowDC *)new wxWindowDC(arg1);
17657
17658 wxPyEndAllowThreads(__tstate);
17659 if (PyErr_Occurred()) SWIG_fail;
17660 }
17661 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDC, 1);
17662 return resultobj;
17663 fail:
17664 return NULL;
17665 }
17666
17667
17668 static PyObject * WindowDC_swigregister(PyObject *, PyObject *args) {
17669 PyObject *obj;
17670 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17671 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDC, obj);
17672 Py_INCREF(obj);
17673 return Py_BuildValue((char *)"");
17674 }
17675 static PyObject *_wrap_new_MirrorDC(PyObject *, PyObject *args, PyObject *kwargs) {
17676 PyObject *resultobj;
17677 wxDC *arg1 = 0 ;
17678 bool arg2 ;
17679 wxMirrorDC *result;
17680 PyObject * obj0 = 0 ;
17681 PyObject * obj1 = 0 ;
17682 char *kwnames[] = {
17683 (char *) "dc",(char *) "mirror", NULL
17684 };
17685
17686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_MirrorDC",kwnames,&obj0,&obj1)) goto fail;
17687 {
17688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17689 if (SWIG_arg_fail(1)) SWIG_fail;
17690 if (arg1 == NULL) {
17691 SWIG_null_ref("wxDC");
17692 }
17693 if (SWIG_arg_fail(1)) SWIG_fail;
17694 }
17695 {
17696 arg2 = (bool)(SWIG_As_bool(obj1));
17697 if (SWIG_arg_fail(2)) SWIG_fail;
17698 }
17699 {
17700 if (!wxPyCheckForApp()) SWIG_fail;
17701 PyThreadState* __tstate = wxPyBeginAllowThreads();
17702 result = (wxMirrorDC *)new wxMirrorDC(*arg1,arg2);
17703
17704 wxPyEndAllowThreads(__tstate);
17705 if (PyErr_Occurred()) SWIG_fail;
17706 }
17707 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMirrorDC, 1);
17708 return resultobj;
17709 fail:
17710 return NULL;
17711 }
17712
17713
17714 static PyObject * MirrorDC_swigregister(PyObject *, PyObject *args) {
17715 PyObject *obj;
17716 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17717 SWIG_TypeClientData(SWIGTYPE_p_wxMirrorDC, obj);
17718 Py_INCREF(obj);
17719 return Py_BuildValue((char *)"");
17720 }
17721 static PyObject *_wrap_new_PostScriptDC(PyObject *, PyObject *args, PyObject *kwargs) {
17722 PyObject *resultobj;
17723 wxPrintData *arg1 = 0 ;
17724 wxPostScriptDC *result;
17725 PyObject * obj0 = 0 ;
17726 char *kwnames[] = {
17727 (char *) "printData", NULL
17728 };
17729
17730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PostScriptDC",kwnames,&obj0)) goto fail;
17731 {
17732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
17733 if (SWIG_arg_fail(1)) SWIG_fail;
17734 if (arg1 == NULL) {
17735 SWIG_null_ref("wxPrintData");
17736 }
17737 if (SWIG_arg_fail(1)) SWIG_fail;
17738 }
17739 {
17740 if (!wxPyCheckForApp()) SWIG_fail;
17741 PyThreadState* __tstate = wxPyBeginAllowThreads();
17742 result = (wxPostScriptDC *)new wxPostScriptDC((wxPrintData const &)*arg1);
17743
17744 wxPyEndAllowThreads(__tstate);
17745 if (PyErr_Occurred()) SWIG_fail;
17746 }
17747 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPostScriptDC, 1);
17748 return resultobj;
17749 fail:
17750 return NULL;
17751 }
17752
17753
17754 static PyObject *_wrap_PostScriptDC_GetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
17755 PyObject *resultobj;
17756 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
17757 wxPrintData *result;
17758 PyObject * obj0 = 0 ;
17759 char *kwnames[] = {
17760 (char *) "self", NULL
17761 };
17762
17763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_GetPrintData",kwnames,&obj0)) goto fail;
17764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
17765 if (SWIG_arg_fail(1)) SWIG_fail;
17766 {
17767 PyThreadState* __tstate = wxPyBeginAllowThreads();
17768 {
17769 wxPrintData &_result_ref = (arg1)->GetPrintData();
17770 result = (wxPrintData *) &_result_ref;
17771 }
17772
17773 wxPyEndAllowThreads(__tstate);
17774 if (PyErr_Occurred()) SWIG_fail;
17775 }
17776 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrintData, 0);
17777 return resultobj;
17778 fail:
17779 return NULL;
17780 }
17781
17782
17783 static PyObject *_wrap_PostScriptDC_SetPrintData(PyObject *, PyObject *args, PyObject *kwargs) {
17784 PyObject *resultobj;
17785 wxPostScriptDC *arg1 = (wxPostScriptDC *) 0 ;
17786 wxPrintData *arg2 = 0 ;
17787 PyObject * obj0 = 0 ;
17788 PyObject * obj1 = 0 ;
17789 char *kwnames[] = {
17790 (char *) "self",(char *) "data", NULL
17791 };
17792
17793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostScriptDC_SetPrintData",kwnames,&obj0,&obj1)) goto fail;
17794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPostScriptDC, SWIG_POINTER_EXCEPTION | 0);
17795 if (SWIG_arg_fail(1)) SWIG_fail;
17796 {
17797 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
17798 if (SWIG_arg_fail(2)) SWIG_fail;
17799 if (arg2 == NULL) {
17800 SWIG_null_ref("wxPrintData");
17801 }
17802 if (SWIG_arg_fail(2)) SWIG_fail;
17803 }
17804 {
17805 PyThreadState* __tstate = wxPyBeginAllowThreads();
17806 (arg1)->SetPrintData((wxPrintData const &)*arg2);
17807
17808 wxPyEndAllowThreads(__tstate);
17809 if (PyErr_Occurred()) SWIG_fail;
17810 }
17811 Py_INCREF(Py_None); resultobj = Py_None;
17812 return resultobj;
17813 fail:
17814 return NULL;
17815 }
17816
17817
17818 static PyObject *_wrap_PostScriptDC_SetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
17819 PyObject *resultobj;
17820 int arg1 ;
17821 PyObject * obj0 = 0 ;
17822 char *kwnames[] = {
17823 (char *) "ppi", NULL
17824 };
17825
17826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PostScriptDC_SetResolution",kwnames,&obj0)) goto fail;
17827 {
17828 arg1 = (int)(SWIG_As_int(obj0));
17829 if (SWIG_arg_fail(1)) SWIG_fail;
17830 }
17831 {
17832 PyThreadState* __tstate = wxPyBeginAllowThreads();
17833 wxPostScriptDC::SetResolution(arg1);
17834
17835 wxPyEndAllowThreads(__tstate);
17836 if (PyErr_Occurred()) SWIG_fail;
17837 }
17838 Py_INCREF(Py_None); resultobj = Py_None;
17839 return resultobj;
17840 fail:
17841 return NULL;
17842 }
17843
17844
17845 static PyObject *_wrap_PostScriptDC_GetResolution(PyObject *, PyObject *args, PyObject *kwargs) {
17846 PyObject *resultobj;
17847 int result;
17848 char *kwnames[] = {
17849 NULL
17850 };
17851
17852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PostScriptDC_GetResolution",kwnames)) goto fail;
17853 {
17854 PyThreadState* __tstate = wxPyBeginAllowThreads();
17855 result = (int)wxPostScriptDC::GetResolution();
17856
17857 wxPyEndAllowThreads(__tstate);
17858 if (PyErr_Occurred()) SWIG_fail;
17859 }
17860 {
17861 resultobj = SWIG_From_int((int)(result));
17862 }
17863 return resultobj;
17864 fail:
17865 return NULL;
17866 }
17867
17868
17869 static PyObject * PostScriptDC_swigregister(PyObject *, PyObject *args) {
17870 PyObject *obj;
17871 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17872 SWIG_TypeClientData(SWIGTYPE_p_wxPostScriptDC, obj);
17873 Py_INCREF(obj);
17874 return Py_BuildValue((char *)"");
17875 }
17876 static PyObject *_wrap_new_MetaFile(PyObject *, PyObject *args, PyObject *kwargs) {
17877 PyObject *resultobj;
17878 wxString const &arg1_defvalue = wxPyEmptyString ;
17879 wxString *arg1 = (wxString *) &arg1_defvalue ;
17880 wxMetaFile *result;
17881 bool temp1 = false ;
17882 PyObject * obj0 = 0 ;
17883 char *kwnames[] = {
17884 (char *) "filename", NULL
17885 };
17886
17887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MetaFile",kwnames,&obj0)) goto fail;
17888 if (obj0) {
17889 {
17890 arg1 = wxString_in_helper(obj0);
17891 if (arg1 == NULL) SWIG_fail;
17892 temp1 = true;
17893 }
17894 }
17895 {
17896 if (!wxPyCheckForApp()) SWIG_fail;
17897 PyThreadState* __tstate = wxPyBeginAllowThreads();
17898 result = (wxMetaFile *)new wxMetaFile((wxString const &)*arg1);
17899
17900 wxPyEndAllowThreads(__tstate);
17901 if (PyErr_Occurred()) SWIG_fail;
17902 }
17903 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFile, 1);
17904 {
17905 if (temp1)
17906 delete arg1;
17907 }
17908 return resultobj;
17909 fail:
17910 {
17911 if (temp1)
17912 delete arg1;
17913 }
17914 return NULL;
17915 }
17916
17917
17918 static PyObject * MetaFile_swigregister(PyObject *, PyObject *args) {
17919 PyObject *obj;
17920 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17921 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFile, obj);
17922 Py_INCREF(obj);
17923 return Py_BuildValue((char *)"");
17924 }
17925 static PyObject *_wrap_new_MetaFileDC(PyObject *, PyObject *args, PyObject *kwargs) {
17926 PyObject *resultobj;
17927 wxString const &arg1_defvalue = wxPyEmptyString ;
17928 wxString *arg1 = (wxString *) &arg1_defvalue ;
17929 int arg2 = (int) 0 ;
17930 int arg3 = (int) 0 ;
17931 wxString const &arg4_defvalue = wxPyEmptyString ;
17932 wxString *arg4 = (wxString *) &arg4_defvalue ;
17933 wxMetaFileDC *result;
17934 bool temp1 = false ;
17935 bool temp4 = false ;
17936 PyObject * obj0 = 0 ;
17937 PyObject * obj1 = 0 ;
17938 PyObject * obj2 = 0 ;
17939 PyObject * obj3 = 0 ;
17940 char *kwnames[] = {
17941 (char *) "filename",(char *) "width",(char *) "height",(char *) "description", NULL
17942 };
17943
17944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_MetaFileDC",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
17945 if (obj0) {
17946 {
17947 arg1 = wxString_in_helper(obj0);
17948 if (arg1 == NULL) SWIG_fail;
17949 temp1 = true;
17950 }
17951 }
17952 if (obj1) {
17953 {
17954 arg2 = (int)(SWIG_As_int(obj1));
17955 if (SWIG_arg_fail(2)) SWIG_fail;
17956 }
17957 }
17958 if (obj2) {
17959 {
17960 arg3 = (int)(SWIG_As_int(obj2));
17961 if (SWIG_arg_fail(3)) SWIG_fail;
17962 }
17963 }
17964 if (obj3) {
17965 {
17966 arg4 = wxString_in_helper(obj3);
17967 if (arg4 == NULL) SWIG_fail;
17968 temp4 = true;
17969 }
17970 }
17971 {
17972 if (!wxPyCheckForApp()) SWIG_fail;
17973 PyThreadState* __tstate = wxPyBeginAllowThreads();
17974 result = (wxMetaFileDC *)new wxMetaFileDC((wxString const &)*arg1,arg2,arg3,(wxString const &)*arg4);
17975
17976 wxPyEndAllowThreads(__tstate);
17977 if (PyErr_Occurred()) SWIG_fail;
17978 }
17979 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetaFileDC, 1);
17980 {
17981 if (temp1)
17982 delete arg1;
17983 }
17984 {
17985 if (temp4)
17986 delete arg4;
17987 }
17988 return resultobj;
17989 fail:
17990 {
17991 if (temp1)
17992 delete arg1;
17993 }
17994 {
17995 if (temp4)
17996 delete arg4;
17997 }
17998 return NULL;
17999 }
18000
18001
18002 static PyObject * MetaFileDC_swigregister(PyObject *, PyObject *args) {
18003 PyObject *obj;
18004 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18005 SWIG_TypeClientData(SWIGTYPE_p_wxMetaFileDC, obj);
18006 Py_INCREF(obj);
18007 return Py_BuildValue((char *)"");
18008 }
18009 static PyObject *_wrap_new_PrinterDC(PyObject *, PyObject *args, PyObject *kwargs) {
18010 PyObject *resultobj;
18011 wxPrintData *arg1 = 0 ;
18012 wxPrinterDC *result;
18013 PyObject * obj0 = 0 ;
18014 char *kwnames[] = {
18015 (char *) "printData", NULL
18016 };
18017
18018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PrinterDC",kwnames,&obj0)) goto fail;
18019 {
18020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPrintData, SWIG_POINTER_EXCEPTION | 0);
18021 if (SWIG_arg_fail(1)) SWIG_fail;
18022 if (arg1 == NULL) {
18023 SWIG_null_ref("wxPrintData");
18024 }
18025 if (SWIG_arg_fail(1)) SWIG_fail;
18026 }
18027 {
18028 if (!wxPyCheckForApp()) SWIG_fail;
18029 PyThreadState* __tstate = wxPyBeginAllowThreads();
18030 result = (wxPrinterDC *)new wxPrinterDC((wxPrintData const &)*arg1);
18031
18032 wxPyEndAllowThreads(__tstate);
18033 if (PyErr_Occurred()) SWIG_fail;
18034 }
18035 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPrinterDC, 1);
18036 return resultobj;
18037 fail:
18038 return NULL;
18039 }
18040
18041
18042 static PyObject * PrinterDC_swigregister(PyObject *, PyObject *args) {
18043 PyObject *obj;
18044 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18045 SWIG_TypeClientData(SWIGTYPE_p_wxPrinterDC, obj);
18046 Py_INCREF(obj);
18047 return Py_BuildValue((char *)"");
18048 }
18049 static PyObject *_wrap_new_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
18050 PyObject *resultobj;
18051 int arg1 ;
18052 int arg2 ;
18053 int arg3 = (int) true ;
18054 int arg4 = (int) 1 ;
18055 wxImageList *result;
18056 PyObject * obj0 = 0 ;
18057 PyObject * obj1 = 0 ;
18058 PyObject * obj2 = 0 ;
18059 PyObject * obj3 = 0 ;
18060 char *kwnames[] = {
18061 (char *) "width",(char *) "height",(char *) "mask",(char *) "initialCount", NULL
18062 };
18063
18064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_ImageList",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
18065 {
18066 arg1 = (int)(SWIG_As_int(obj0));
18067 if (SWIG_arg_fail(1)) SWIG_fail;
18068 }
18069 {
18070 arg2 = (int)(SWIG_As_int(obj1));
18071 if (SWIG_arg_fail(2)) SWIG_fail;
18072 }
18073 if (obj2) {
18074 {
18075 arg3 = (int)(SWIG_As_int(obj2));
18076 if (SWIG_arg_fail(3)) SWIG_fail;
18077 }
18078 }
18079 if (obj3) {
18080 {
18081 arg4 = (int)(SWIG_As_int(obj3));
18082 if (SWIG_arg_fail(4)) SWIG_fail;
18083 }
18084 }
18085 {
18086 if (!wxPyCheckForApp()) SWIG_fail;
18087 PyThreadState* __tstate = wxPyBeginAllowThreads();
18088 result = (wxImageList *)new wxImageList(arg1,arg2,arg3,arg4);
18089
18090 wxPyEndAllowThreads(__tstate);
18091 if (PyErr_Occurred()) SWIG_fail;
18092 }
18093 {
18094 resultobj = wxPyMake_wxObject(result, 1);
18095 }
18096 return resultobj;
18097 fail:
18098 return NULL;
18099 }
18100
18101
18102 static PyObject *_wrap_delete_ImageList(PyObject *, PyObject *args, PyObject *kwargs) {
18103 PyObject *resultobj;
18104 wxImageList *arg1 = (wxImageList *) 0 ;
18105 PyObject * obj0 = 0 ;
18106 char *kwnames[] = {
18107 (char *) "self", NULL
18108 };
18109
18110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ImageList",kwnames,&obj0)) goto fail;
18111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18112 if (SWIG_arg_fail(1)) SWIG_fail;
18113 {
18114 PyThreadState* __tstate = wxPyBeginAllowThreads();
18115 delete arg1;
18116
18117 wxPyEndAllowThreads(__tstate);
18118 if (PyErr_Occurred()) SWIG_fail;
18119 }
18120 Py_INCREF(Py_None); resultobj = Py_None;
18121 return resultobj;
18122 fail:
18123 return NULL;
18124 }
18125
18126
18127 static PyObject *_wrap_ImageList_Add(PyObject *, PyObject *args, PyObject *kwargs) {
18128 PyObject *resultobj;
18129 wxImageList *arg1 = (wxImageList *) 0 ;
18130 wxBitmap *arg2 = 0 ;
18131 wxBitmap const &arg3_defvalue = wxNullBitmap ;
18132 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
18133 int result;
18134 PyObject * obj0 = 0 ;
18135 PyObject * obj1 = 0 ;
18136 PyObject * obj2 = 0 ;
18137 char *kwnames[] = {
18138 (char *) "self",(char *) "bitmap",(char *) "mask", NULL
18139 };
18140
18141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ImageList_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
18142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18143 if (SWIG_arg_fail(1)) SWIG_fail;
18144 {
18145 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18146 if (SWIG_arg_fail(2)) SWIG_fail;
18147 if (arg2 == NULL) {
18148 SWIG_null_ref("wxBitmap");
18149 }
18150 if (SWIG_arg_fail(2)) SWIG_fail;
18151 }
18152 if (obj2) {
18153 {
18154 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18155 if (SWIG_arg_fail(3)) SWIG_fail;
18156 if (arg3 == NULL) {
18157 SWIG_null_ref("wxBitmap");
18158 }
18159 if (SWIG_arg_fail(3)) SWIG_fail;
18160 }
18161 }
18162 {
18163 PyThreadState* __tstate = wxPyBeginAllowThreads();
18164 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
18165
18166 wxPyEndAllowThreads(__tstate);
18167 if (PyErr_Occurred()) SWIG_fail;
18168 }
18169 {
18170 resultobj = SWIG_From_int((int)(result));
18171 }
18172 return resultobj;
18173 fail:
18174 return NULL;
18175 }
18176
18177
18178 static PyObject *_wrap_ImageList_AddWithColourMask(PyObject *, PyObject *args, PyObject *kwargs) {
18179 PyObject *resultobj;
18180 wxImageList *arg1 = (wxImageList *) 0 ;
18181 wxBitmap *arg2 = 0 ;
18182 wxColour *arg3 = 0 ;
18183 int result;
18184 wxColour temp3 ;
18185 PyObject * obj0 = 0 ;
18186 PyObject * obj1 = 0 ;
18187 PyObject * obj2 = 0 ;
18188 char *kwnames[] = {
18189 (char *) "self",(char *) "bitmap",(char *) "maskColour", NULL
18190 };
18191
18192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_AddWithColourMask",kwnames,&obj0,&obj1,&obj2)) goto fail;
18193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18194 if (SWIG_arg_fail(1)) SWIG_fail;
18195 {
18196 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18197 if (SWIG_arg_fail(2)) SWIG_fail;
18198 if (arg2 == NULL) {
18199 SWIG_null_ref("wxBitmap");
18200 }
18201 if (SWIG_arg_fail(2)) SWIG_fail;
18202 }
18203 {
18204 arg3 = &temp3;
18205 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
18206 }
18207 {
18208 PyThreadState* __tstate = wxPyBeginAllowThreads();
18209 result = (int)(arg1)->Add((wxBitmap const &)*arg2,(wxColour const &)*arg3);
18210
18211 wxPyEndAllowThreads(__tstate);
18212 if (PyErr_Occurred()) SWIG_fail;
18213 }
18214 {
18215 resultobj = SWIG_From_int((int)(result));
18216 }
18217 return resultobj;
18218 fail:
18219 return NULL;
18220 }
18221
18222
18223 static PyObject *_wrap_ImageList_AddIcon(PyObject *, PyObject *args, PyObject *kwargs) {
18224 PyObject *resultobj;
18225 wxImageList *arg1 = (wxImageList *) 0 ;
18226 wxIcon *arg2 = 0 ;
18227 int result;
18228 PyObject * obj0 = 0 ;
18229 PyObject * obj1 = 0 ;
18230 char *kwnames[] = {
18231 (char *) "self",(char *) "icon", NULL
18232 };
18233
18234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_AddIcon",kwnames,&obj0,&obj1)) goto fail;
18235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18236 if (SWIG_arg_fail(1)) SWIG_fail;
18237 {
18238 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
18239 if (SWIG_arg_fail(2)) SWIG_fail;
18240 if (arg2 == NULL) {
18241 SWIG_null_ref("wxIcon");
18242 }
18243 if (SWIG_arg_fail(2)) SWIG_fail;
18244 }
18245 {
18246 PyThreadState* __tstate = wxPyBeginAllowThreads();
18247 result = (int)(arg1)->Add((wxIcon const &)*arg2);
18248
18249 wxPyEndAllowThreads(__tstate);
18250 if (PyErr_Occurred()) SWIG_fail;
18251 }
18252 {
18253 resultobj = SWIG_From_int((int)(result));
18254 }
18255 return resultobj;
18256 fail:
18257 return NULL;
18258 }
18259
18260
18261 static PyObject *_wrap_ImageList_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
18262 PyObject *resultobj;
18263 wxImageList *arg1 = (wxImageList *) 0 ;
18264 int arg2 ;
18265 wxBitmap *arg3 = 0 ;
18266 bool result;
18267 PyObject * obj0 = 0 ;
18268 PyObject * obj1 = 0 ;
18269 PyObject * obj2 = 0 ;
18270 char *kwnames[] = {
18271 (char *) "self",(char *) "index",(char *) "bitmap", NULL
18272 };
18273
18274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageList_Replace",kwnames,&obj0,&obj1,&obj2)) goto fail;
18275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18276 if (SWIG_arg_fail(1)) SWIG_fail;
18277 {
18278 arg2 = (int)(SWIG_As_int(obj1));
18279 if (SWIG_arg_fail(2)) SWIG_fail;
18280 }
18281 {
18282 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
18283 if (SWIG_arg_fail(3)) SWIG_fail;
18284 if (arg3 == NULL) {
18285 SWIG_null_ref("wxBitmap");
18286 }
18287 if (SWIG_arg_fail(3)) SWIG_fail;
18288 }
18289 {
18290 PyThreadState* __tstate = wxPyBeginAllowThreads();
18291 result = (bool)(arg1)->Replace(arg2,(wxBitmap const &)*arg3);
18292
18293 wxPyEndAllowThreads(__tstate);
18294 if (PyErr_Occurred()) SWIG_fail;
18295 }
18296 {
18297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18298 }
18299 return resultobj;
18300 fail:
18301 return NULL;
18302 }
18303
18304
18305 static PyObject *_wrap_ImageList_Draw(PyObject *, PyObject *args, PyObject *kwargs) {
18306 PyObject *resultobj;
18307 wxImageList *arg1 = (wxImageList *) 0 ;
18308 int arg2 ;
18309 wxDC *arg3 = 0 ;
18310 int arg4 ;
18311 int arg5 ;
18312 int arg6 = (int) wxIMAGELIST_DRAW_NORMAL ;
18313 bool arg7 = (bool) (bool)false ;
18314 bool result;
18315 PyObject * obj0 = 0 ;
18316 PyObject * obj1 = 0 ;
18317 PyObject * obj2 = 0 ;
18318 PyObject * obj3 = 0 ;
18319 PyObject * obj4 = 0 ;
18320 PyObject * obj5 = 0 ;
18321 PyObject * obj6 = 0 ;
18322 char *kwnames[] = {
18323 (char *) "self",(char *) "index",(char *) "dc",(char *) "x",(char *) "x",(char *) "flags",(char *) "solidBackground", NULL
18324 };
18325
18326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OO:ImageList_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
18327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18328 if (SWIG_arg_fail(1)) SWIG_fail;
18329 {
18330 arg2 = (int)(SWIG_As_int(obj1));
18331 if (SWIG_arg_fail(2)) SWIG_fail;
18332 }
18333 {
18334 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
18335 if (SWIG_arg_fail(3)) SWIG_fail;
18336 if (arg3 == NULL) {
18337 SWIG_null_ref("wxDC");
18338 }
18339 if (SWIG_arg_fail(3)) SWIG_fail;
18340 }
18341 {
18342 arg4 = (int)(SWIG_As_int(obj3));
18343 if (SWIG_arg_fail(4)) SWIG_fail;
18344 }
18345 {
18346 arg5 = (int)(SWIG_As_int(obj4));
18347 if (SWIG_arg_fail(5)) SWIG_fail;
18348 }
18349 if (obj5) {
18350 {
18351 arg6 = (int)(SWIG_As_int(obj5));
18352 if (SWIG_arg_fail(6)) SWIG_fail;
18353 }
18354 }
18355 if (obj6) {
18356 {
18357 arg7 = (bool const)(SWIG_As_bool(obj6));
18358 if (SWIG_arg_fail(7)) SWIG_fail;
18359 }
18360 }
18361 {
18362 PyThreadState* __tstate = wxPyBeginAllowThreads();
18363 result = (bool)(arg1)->Draw(arg2,*arg3,arg4,arg5,arg6,arg7);
18364
18365 wxPyEndAllowThreads(__tstate);
18366 if (PyErr_Occurred()) SWIG_fail;
18367 }
18368 {
18369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18370 }
18371 return resultobj;
18372 fail:
18373 return NULL;
18374 }
18375
18376
18377 static PyObject *_wrap_ImageList_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
18378 PyObject *resultobj;
18379 wxImageList *arg1 = (wxImageList *) 0 ;
18380 int result;
18381 PyObject * obj0 = 0 ;
18382 char *kwnames[] = {
18383 (char *) "self", NULL
18384 };
18385
18386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_GetImageCount",kwnames,&obj0)) goto fail;
18387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18388 if (SWIG_arg_fail(1)) SWIG_fail;
18389 {
18390 PyThreadState* __tstate = wxPyBeginAllowThreads();
18391 result = (int)(arg1)->GetImageCount();
18392
18393 wxPyEndAllowThreads(__tstate);
18394 if (PyErr_Occurred()) SWIG_fail;
18395 }
18396 {
18397 resultobj = SWIG_From_int((int)(result));
18398 }
18399 return resultobj;
18400 fail:
18401 return NULL;
18402 }
18403
18404
18405 static PyObject *_wrap_ImageList_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
18406 PyObject *resultobj;
18407 wxImageList *arg1 = (wxImageList *) 0 ;
18408 int arg2 ;
18409 bool result;
18410 PyObject * obj0 = 0 ;
18411 PyObject * obj1 = 0 ;
18412 char *kwnames[] = {
18413 (char *) "self",(char *) "index", NULL
18414 };
18415
18416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_Remove",kwnames,&obj0,&obj1)) goto fail;
18417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18418 if (SWIG_arg_fail(1)) SWIG_fail;
18419 {
18420 arg2 = (int)(SWIG_As_int(obj1));
18421 if (SWIG_arg_fail(2)) SWIG_fail;
18422 }
18423 {
18424 PyThreadState* __tstate = wxPyBeginAllowThreads();
18425 result = (bool)(arg1)->Remove(arg2);
18426
18427 wxPyEndAllowThreads(__tstate);
18428 if (PyErr_Occurred()) SWIG_fail;
18429 }
18430 {
18431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18432 }
18433 return resultobj;
18434 fail:
18435 return NULL;
18436 }
18437
18438
18439 static PyObject *_wrap_ImageList_RemoveAll(PyObject *, PyObject *args, PyObject *kwargs) {
18440 PyObject *resultobj;
18441 wxImageList *arg1 = (wxImageList *) 0 ;
18442 bool result;
18443 PyObject * obj0 = 0 ;
18444 char *kwnames[] = {
18445 (char *) "self", NULL
18446 };
18447
18448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageList_RemoveAll",kwnames,&obj0)) goto fail;
18449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18450 if (SWIG_arg_fail(1)) SWIG_fail;
18451 {
18452 PyThreadState* __tstate = wxPyBeginAllowThreads();
18453 result = (bool)(arg1)->RemoveAll();
18454
18455 wxPyEndAllowThreads(__tstate);
18456 if (PyErr_Occurred()) SWIG_fail;
18457 }
18458 {
18459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18460 }
18461 return resultobj;
18462 fail:
18463 return NULL;
18464 }
18465
18466
18467 static PyObject *_wrap_ImageList_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18468 PyObject *resultobj;
18469 wxImageList *arg1 = (wxImageList *) 0 ;
18470 int arg2 ;
18471 int *arg3 = 0 ;
18472 int *arg4 = 0 ;
18473 int temp3 ;
18474 int res3 = 0 ;
18475 int temp4 ;
18476 int res4 = 0 ;
18477 PyObject * obj0 = 0 ;
18478 PyObject * obj1 = 0 ;
18479 char *kwnames[] = {
18480 (char *) "self",(char *) "index", NULL
18481 };
18482
18483 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18484 arg4 = &temp4; res4 = SWIG_NEWOBJ;
18485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageList_GetSize",kwnames,&obj0,&obj1)) goto fail;
18486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageList, SWIG_POINTER_EXCEPTION | 0);
18487 if (SWIG_arg_fail(1)) SWIG_fail;
18488 {
18489 arg2 = (int)(SWIG_As_int(obj1));
18490 if (SWIG_arg_fail(2)) SWIG_fail;
18491 }
18492 {
18493 PyThreadState* __tstate = wxPyBeginAllowThreads();
18494 (arg1)->GetSize(arg2,*arg3,*arg4);
18495
18496 wxPyEndAllowThreads(__tstate);
18497 if (PyErr_Occurred()) SWIG_fail;
18498 }
18499 Py_INCREF(Py_None); resultobj = Py_None;
18500 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18501 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
18502 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
18503 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
18504 return resultobj;
18505 fail:
18506 return NULL;
18507 }
18508
18509
18510 static PyObject * ImageList_swigregister(PyObject *, PyObject *args) {
18511 PyObject *obj;
18512 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18513 SWIG_TypeClientData(SWIGTYPE_p_wxImageList, obj);
18514 Py_INCREF(obj);
18515 return Py_BuildValue((char *)"");
18516 }
18517 static int _wrap_NORMAL_FONT_set(PyObject *) {
18518 PyErr_SetString(PyExc_TypeError,"Variable NORMAL_FONT is read-only.");
18519 return 1;
18520 }
18521
18522
18523 static PyObject *_wrap_NORMAL_FONT_get(void) {
18524 PyObject *pyobj;
18525
18526 pyobj = SWIG_NewPointerObj((void *)(wxNORMAL_FONT), SWIGTYPE_p_wxFont, 0);
18527 return pyobj;
18528 }
18529
18530
18531 static int _wrap_SMALL_FONT_set(PyObject *) {
18532 PyErr_SetString(PyExc_TypeError,"Variable SMALL_FONT is read-only.");
18533 return 1;
18534 }
18535
18536
18537 static PyObject *_wrap_SMALL_FONT_get(void) {
18538 PyObject *pyobj;
18539
18540 pyobj = SWIG_NewPointerObj((void *)(wxSMALL_FONT), SWIGTYPE_p_wxFont, 0);
18541 return pyobj;
18542 }
18543
18544
18545 static int _wrap_ITALIC_FONT_set(PyObject *) {
18546 PyErr_SetString(PyExc_TypeError,"Variable ITALIC_FONT is read-only.");
18547 return 1;
18548 }
18549
18550
18551 static PyObject *_wrap_ITALIC_FONT_get(void) {
18552 PyObject *pyobj;
18553
18554 pyobj = SWIG_NewPointerObj((void *)(wxITALIC_FONT), SWIGTYPE_p_wxFont, 0);
18555 return pyobj;
18556 }
18557
18558
18559 static int _wrap_SWISS_FONT_set(PyObject *) {
18560 PyErr_SetString(PyExc_TypeError,"Variable SWISS_FONT is read-only.");
18561 return 1;
18562 }
18563
18564
18565 static PyObject *_wrap_SWISS_FONT_get(void) {
18566 PyObject *pyobj;
18567
18568 pyobj = SWIG_NewPointerObj((void *)(wxSWISS_FONT), SWIGTYPE_p_wxFont, 0);
18569 return pyobj;
18570 }
18571
18572
18573 static int _wrap_RED_PEN_set(PyObject *) {
18574 PyErr_SetString(PyExc_TypeError,"Variable RED_PEN is read-only.");
18575 return 1;
18576 }
18577
18578
18579 static PyObject *_wrap_RED_PEN_get(void) {
18580 PyObject *pyobj;
18581
18582 pyobj = SWIG_NewPointerObj((void *)(wxRED_PEN), SWIGTYPE_p_wxPen, 0);
18583 return pyobj;
18584 }
18585
18586
18587 static int _wrap_CYAN_PEN_set(PyObject *) {
18588 PyErr_SetString(PyExc_TypeError,"Variable CYAN_PEN is read-only.");
18589 return 1;
18590 }
18591
18592
18593 static PyObject *_wrap_CYAN_PEN_get(void) {
18594 PyObject *pyobj;
18595
18596 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_PEN), SWIGTYPE_p_wxPen, 0);
18597 return pyobj;
18598 }
18599
18600
18601 static int _wrap_GREEN_PEN_set(PyObject *) {
18602 PyErr_SetString(PyExc_TypeError,"Variable GREEN_PEN is read-only.");
18603 return 1;
18604 }
18605
18606
18607 static PyObject *_wrap_GREEN_PEN_get(void) {
18608 PyObject *pyobj;
18609
18610 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_PEN), SWIGTYPE_p_wxPen, 0);
18611 return pyobj;
18612 }
18613
18614
18615 static int _wrap_BLACK_PEN_set(PyObject *) {
18616 PyErr_SetString(PyExc_TypeError,"Variable BLACK_PEN is read-only.");
18617 return 1;
18618 }
18619
18620
18621 static PyObject *_wrap_BLACK_PEN_get(void) {
18622 PyObject *pyobj;
18623
18624 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_PEN), SWIGTYPE_p_wxPen, 0);
18625 return pyobj;
18626 }
18627
18628
18629 static int _wrap_WHITE_PEN_set(PyObject *) {
18630 PyErr_SetString(PyExc_TypeError,"Variable WHITE_PEN is read-only.");
18631 return 1;
18632 }
18633
18634
18635 static PyObject *_wrap_WHITE_PEN_get(void) {
18636 PyObject *pyobj;
18637
18638 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_PEN), SWIGTYPE_p_wxPen, 0);
18639 return pyobj;
18640 }
18641
18642
18643 static int _wrap_TRANSPARENT_PEN_set(PyObject *) {
18644 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_PEN is read-only.");
18645 return 1;
18646 }
18647
18648
18649 static PyObject *_wrap_TRANSPARENT_PEN_get(void) {
18650 PyObject *pyobj;
18651
18652 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_PEN), SWIGTYPE_p_wxPen, 0);
18653 return pyobj;
18654 }
18655
18656
18657 static int _wrap_BLACK_DASHED_PEN_set(PyObject *) {
18658 PyErr_SetString(PyExc_TypeError,"Variable BLACK_DASHED_PEN is read-only.");
18659 return 1;
18660 }
18661
18662
18663 static PyObject *_wrap_BLACK_DASHED_PEN_get(void) {
18664 PyObject *pyobj;
18665
18666 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_DASHED_PEN), SWIGTYPE_p_wxPen, 0);
18667 return pyobj;
18668 }
18669
18670
18671 static int _wrap_GREY_PEN_set(PyObject *) {
18672 PyErr_SetString(PyExc_TypeError,"Variable GREY_PEN is read-only.");
18673 return 1;
18674 }
18675
18676
18677 static PyObject *_wrap_GREY_PEN_get(void) {
18678 PyObject *pyobj;
18679
18680 pyobj = SWIG_NewPointerObj((void *)(wxGREY_PEN), SWIGTYPE_p_wxPen, 0);
18681 return pyobj;
18682 }
18683
18684
18685 static int _wrap_MEDIUM_GREY_PEN_set(PyObject *) {
18686 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_PEN is read-only.");
18687 return 1;
18688 }
18689
18690
18691 static PyObject *_wrap_MEDIUM_GREY_PEN_get(void) {
18692 PyObject *pyobj;
18693
18694 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_PEN), SWIGTYPE_p_wxPen, 0);
18695 return pyobj;
18696 }
18697
18698
18699 static int _wrap_LIGHT_GREY_PEN_set(PyObject *) {
18700 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_PEN is read-only.");
18701 return 1;
18702 }
18703
18704
18705 static PyObject *_wrap_LIGHT_GREY_PEN_get(void) {
18706 PyObject *pyobj;
18707
18708 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_PEN), SWIGTYPE_p_wxPen, 0);
18709 return pyobj;
18710 }
18711
18712
18713 static int _wrap_BLUE_BRUSH_set(PyObject *) {
18714 PyErr_SetString(PyExc_TypeError,"Variable BLUE_BRUSH is read-only.");
18715 return 1;
18716 }
18717
18718
18719 static PyObject *_wrap_BLUE_BRUSH_get(void) {
18720 PyObject *pyobj;
18721
18722 pyobj = SWIG_NewPointerObj((void *)(wxBLUE_BRUSH), SWIGTYPE_p_wxBrush, 0);
18723 return pyobj;
18724 }
18725
18726
18727 static int _wrap_GREEN_BRUSH_set(PyObject *) {
18728 PyErr_SetString(PyExc_TypeError,"Variable GREEN_BRUSH is read-only.");
18729 return 1;
18730 }
18731
18732
18733 static PyObject *_wrap_GREEN_BRUSH_get(void) {
18734 PyObject *pyobj;
18735
18736 pyobj = SWIG_NewPointerObj((void *)(wxGREEN_BRUSH), SWIGTYPE_p_wxBrush, 0);
18737 return pyobj;
18738 }
18739
18740
18741 static int _wrap_WHITE_BRUSH_set(PyObject *) {
18742 PyErr_SetString(PyExc_TypeError,"Variable WHITE_BRUSH is read-only.");
18743 return 1;
18744 }
18745
18746
18747 static PyObject *_wrap_WHITE_BRUSH_get(void) {
18748 PyObject *pyobj;
18749
18750 pyobj = SWIG_NewPointerObj((void *)(wxWHITE_BRUSH), SWIGTYPE_p_wxBrush, 0);
18751 return pyobj;
18752 }
18753
18754
18755 static int _wrap_BLACK_BRUSH_set(PyObject *) {
18756 PyErr_SetString(PyExc_TypeError,"Variable BLACK_BRUSH is read-only.");
18757 return 1;
18758 }
18759
18760
18761 static PyObject *_wrap_BLACK_BRUSH_get(void) {
18762 PyObject *pyobj;
18763
18764 pyobj = SWIG_NewPointerObj((void *)(wxBLACK_BRUSH), SWIGTYPE_p_wxBrush, 0);
18765 return pyobj;
18766 }
18767
18768
18769 static int _wrap_TRANSPARENT_BRUSH_set(PyObject *) {
18770 PyErr_SetString(PyExc_TypeError,"Variable TRANSPARENT_BRUSH is read-only.");
18771 return 1;
18772 }
18773
18774
18775 static PyObject *_wrap_TRANSPARENT_BRUSH_get(void) {
18776 PyObject *pyobj;
18777
18778 pyobj = SWIG_NewPointerObj((void *)(wxTRANSPARENT_BRUSH), SWIGTYPE_p_wxBrush, 0);
18779 return pyobj;
18780 }
18781
18782
18783 static int _wrap_CYAN_BRUSH_set(PyObject *) {
18784 PyErr_SetString(PyExc_TypeError,"Variable CYAN_BRUSH is read-only.");
18785 return 1;
18786 }
18787
18788
18789 static PyObject *_wrap_CYAN_BRUSH_get(void) {
18790 PyObject *pyobj;
18791
18792 pyobj = SWIG_NewPointerObj((void *)(wxCYAN_BRUSH), SWIGTYPE_p_wxBrush, 0);
18793 return pyobj;
18794 }
18795
18796
18797 static int _wrap_RED_BRUSH_set(PyObject *) {
18798 PyErr_SetString(PyExc_TypeError,"Variable RED_BRUSH is read-only.");
18799 return 1;
18800 }
18801
18802
18803 static PyObject *_wrap_RED_BRUSH_get(void) {
18804 PyObject *pyobj;
18805
18806 pyobj = SWIG_NewPointerObj((void *)(wxRED_BRUSH), SWIGTYPE_p_wxBrush, 0);
18807 return pyobj;
18808 }
18809
18810
18811 static int _wrap_GREY_BRUSH_set(PyObject *) {
18812 PyErr_SetString(PyExc_TypeError,"Variable GREY_BRUSH is read-only.");
18813 return 1;
18814 }
18815
18816
18817 static PyObject *_wrap_GREY_BRUSH_get(void) {
18818 PyObject *pyobj;
18819
18820 pyobj = SWIG_NewPointerObj((void *)(wxGREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
18821 return pyobj;
18822 }
18823
18824
18825 static int _wrap_MEDIUM_GREY_BRUSH_set(PyObject *) {
18826 PyErr_SetString(PyExc_TypeError,"Variable MEDIUM_GREY_BRUSH is read-only.");
18827 return 1;
18828 }
18829
18830
18831 static PyObject *_wrap_MEDIUM_GREY_BRUSH_get(void) {
18832 PyObject *pyobj;
18833
18834 pyobj = SWIG_NewPointerObj((void *)(wxMEDIUM_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
18835 return pyobj;
18836 }
18837
18838
18839 static int _wrap_LIGHT_GREY_BRUSH_set(PyObject *) {
18840 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY_BRUSH is read-only.");
18841 return 1;
18842 }
18843
18844
18845 static PyObject *_wrap_LIGHT_GREY_BRUSH_get(void) {
18846 PyObject *pyobj;
18847
18848 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY_BRUSH), SWIGTYPE_p_wxBrush, 0);
18849 return pyobj;
18850 }
18851
18852
18853 static int _wrap_BLACK_set(PyObject *) {
18854 PyErr_SetString(PyExc_TypeError,"Variable BLACK is read-only.");
18855 return 1;
18856 }
18857
18858
18859 static PyObject *_wrap_BLACK_get(void) {
18860 PyObject *pyobj;
18861
18862 pyobj = SWIG_NewPointerObj((void *)(wxBLACK), SWIGTYPE_p_wxColour, 0);
18863 return pyobj;
18864 }
18865
18866
18867 static int _wrap_WHITE_set(PyObject *) {
18868 PyErr_SetString(PyExc_TypeError,"Variable WHITE is read-only.");
18869 return 1;
18870 }
18871
18872
18873 static PyObject *_wrap_WHITE_get(void) {
18874 PyObject *pyobj;
18875
18876 pyobj = SWIG_NewPointerObj((void *)(wxWHITE), SWIGTYPE_p_wxColour, 0);
18877 return pyobj;
18878 }
18879
18880
18881 static int _wrap_RED_set(PyObject *) {
18882 PyErr_SetString(PyExc_TypeError,"Variable RED is read-only.");
18883 return 1;
18884 }
18885
18886
18887 static PyObject *_wrap_RED_get(void) {
18888 PyObject *pyobj;
18889
18890 pyobj = SWIG_NewPointerObj((void *)(wxRED), SWIGTYPE_p_wxColour, 0);
18891 return pyobj;
18892 }
18893
18894
18895 static int _wrap_BLUE_set(PyObject *) {
18896 PyErr_SetString(PyExc_TypeError,"Variable BLUE is read-only.");
18897 return 1;
18898 }
18899
18900
18901 static PyObject *_wrap_BLUE_get(void) {
18902 PyObject *pyobj;
18903
18904 pyobj = SWIG_NewPointerObj((void *)(wxBLUE), SWIGTYPE_p_wxColour, 0);
18905 return pyobj;
18906 }
18907
18908
18909 static int _wrap_GREEN_set(PyObject *) {
18910 PyErr_SetString(PyExc_TypeError,"Variable GREEN is read-only.");
18911 return 1;
18912 }
18913
18914
18915 static PyObject *_wrap_GREEN_get(void) {
18916 PyObject *pyobj;
18917
18918 pyobj = SWIG_NewPointerObj((void *)(wxGREEN), SWIGTYPE_p_wxColour, 0);
18919 return pyobj;
18920 }
18921
18922
18923 static int _wrap_CYAN_set(PyObject *) {
18924 PyErr_SetString(PyExc_TypeError,"Variable CYAN is read-only.");
18925 return 1;
18926 }
18927
18928
18929 static PyObject *_wrap_CYAN_get(void) {
18930 PyObject *pyobj;
18931
18932 pyobj = SWIG_NewPointerObj((void *)(wxCYAN), SWIGTYPE_p_wxColour, 0);
18933 return pyobj;
18934 }
18935
18936
18937 static int _wrap_LIGHT_GREY_set(PyObject *) {
18938 PyErr_SetString(PyExc_TypeError,"Variable LIGHT_GREY is read-only.");
18939 return 1;
18940 }
18941
18942
18943 static PyObject *_wrap_LIGHT_GREY_get(void) {
18944 PyObject *pyobj;
18945
18946 pyobj = SWIG_NewPointerObj((void *)(wxLIGHT_GREY), SWIGTYPE_p_wxColour, 0);
18947 return pyobj;
18948 }
18949
18950
18951 static int _wrap_STANDARD_CURSOR_set(PyObject *) {
18952 PyErr_SetString(PyExc_TypeError,"Variable STANDARD_CURSOR is read-only.");
18953 return 1;
18954 }
18955
18956
18957 static PyObject *_wrap_STANDARD_CURSOR_get(void) {
18958 PyObject *pyobj;
18959
18960 pyobj = SWIG_NewPointerObj((void *)(wxSTANDARD_CURSOR), SWIGTYPE_p_wxCursor, 0);
18961 return pyobj;
18962 }
18963
18964
18965 static int _wrap_HOURGLASS_CURSOR_set(PyObject *) {
18966 PyErr_SetString(PyExc_TypeError,"Variable HOURGLASS_CURSOR is read-only.");
18967 return 1;
18968 }
18969
18970
18971 static PyObject *_wrap_HOURGLASS_CURSOR_get(void) {
18972 PyObject *pyobj;
18973
18974 pyobj = SWIG_NewPointerObj((void *)(wxHOURGLASS_CURSOR), SWIGTYPE_p_wxCursor, 0);
18975 return pyobj;
18976 }
18977
18978
18979 static int _wrap_CROSS_CURSOR_set(PyObject *) {
18980 PyErr_SetString(PyExc_TypeError,"Variable CROSS_CURSOR is read-only.");
18981 return 1;
18982 }
18983
18984
18985 static PyObject *_wrap_CROSS_CURSOR_get(void) {
18986 PyObject *pyobj;
18987
18988 pyobj = SWIG_NewPointerObj((void *)(wxCROSS_CURSOR), SWIGTYPE_p_wxCursor, 0);
18989 return pyobj;
18990 }
18991
18992
18993 static int _wrap_NullBitmap_set(PyObject *) {
18994 PyErr_SetString(PyExc_TypeError,"Variable NullBitmap is read-only.");
18995 return 1;
18996 }
18997
18998
18999 static PyObject *_wrap_NullBitmap_get(void) {
19000 PyObject *pyobj;
19001
19002 pyobj = SWIG_NewPointerObj((void *)(&wxNullBitmap), SWIGTYPE_p_wxBitmap, 0);
19003 return pyobj;
19004 }
19005
19006
19007 static int _wrap_NullIcon_set(PyObject *) {
19008 PyErr_SetString(PyExc_TypeError,"Variable NullIcon is read-only.");
19009 return 1;
19010 }
19011
19012
19013 static PyObject *_wrap_NullIcon_get(void) {
19014 PyObject *pyobj;
19015
19016 pyobj = SWIG_NewPointerObj((void *)(&wxNullIcon), SWIGTYPE_p_wxIcon, 0);
19017 return pyobj;
19018 }
19019
19020
19021 static int _wrap_NullCursor_set(PyObject *) {
19022 PyErr_SetString(PyExc_TypeError,"Variable NullCursor is read-only.");
19023 return 1;
19024 }
19025
19026
19027 static PyObject *_wrap_NullCursor_get(void) {
19028 PyObject *pyobj;
19029
19030 pyobj = SWIG_NewPointerObj((void *)(&wxNullCursor), SWIGTYPE_p_wxCursor, 0);
19031 return pyobj;
19032 }
19033
19034
19035 static int _wrap_NullPen_set(PyObject *) {
19036 PyErr_SetString(PyExc_TypeError,"Variable NullPen is read-only.");
19037 return 1;
19038 }
19039
19040
19041 static PyObject *_wrap_NullPen_get(void) {
19042 PyObject *pyobj;
19043
19044 pyobj = SWIG_NewPointerObj((void *)(&wxNullPen), SWIGTYPE_p_wxPen, 0);
19045 return pyobj;
19046 }
19047
19048
19049 static int _wrap_NullBrush_set(PyObject *) {
19050 PyErr_SetString(PyExc_TypeError,"Variable NullBrush is read-only.");
19051 return 1;
19052 }
19053
19054
19055 static PyObject *_wrap_NullBrush_get(void) {
19056 PyObject *pyobj;
19057
19058 pyobj = SWIG_NewPointerObj((void *)(&wxNullBrush), SWIGTYPE_p_wxBrush, 0);
19059 return pyobj;
19060 }
19061
19062
19063 static int _wrap_NullPalette_set(PyObject *) {
19064 PyErr_SetString(PyExc_TypeError,"Variable NullPalette is read-only.");
19065 return 1;
19066 }
19067
19068
19069 static PyObject *_wrap_NullPalette_get(void) {
19070 PyObject *pyobj;
19071
19072 pyobj = SWIG_NewPointerObj((void *)(&wxNullPalette), SWIGTYPE_p_wxPalette, 0);
19073 return pyobj;
19074 }
19075
19076
19077 static int _wrap_NullFont_set(PyObject *) {
19078 PyErr_SetString(PyExc_TypeError,"Variable NullFont is read-only.");
19079 return 1;
19080 }
19081
19082
19083 static PyObject *_wrap_NullFont_get(void) {
19084 PyObject *pyobj;
19085
19086 pyobj = SWIG_NewPointerObj((void *)(&wxNullFont), SWIGTYPE_p_wxFont, 0);
19087 return pyobj;
19088 }
19089
19090
19091 static int _wrap_NullColour_set(PyObject *) {
19092 PyErr_SetString(PyExc_TypeError,"Variable NullColour is read-only.");
19093 return 1;
19094 }
19095
19096
19097 static PyObject *_wrap_NullColour_get(void) {
19098 PyObject *pyobj;
19099
19100 pyobj = SWIG_NewPointerObj((void *)(&wxNullColour), SWIGTYPE_p_wxColour, 0);
19101 return pyobj;
19102 }
19103
19104
19105 static PyObject *_wrap_PenList_AddPen(PyObject *, PyObject *args, PyObject *kwargs) {
19106 PyObject *resultobj;
19107 wxPenList *arg1 = (wxPenList *) 0 ;
19108 wxPen *arg2 = (wxPen *) 0 ;
19109 PyObject * obj0 = 0 ;
19110 PyObject * obj1 = 0 ;
19111 char *kwnames[] = {
19112 (char *) "self",(char *) "pen", NULL
19113 };
19114
19115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_AddPen",kwnames,&obj0,&obj1)) goto fail;
19116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19117 if (SWIG_arg_fail(1)) SWIG_fail;
19118 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
19119 if (SWIG_arg_fail(2)) SWIG_fail;
19120 {
19121 PyThreadState* __tstate = wxPyBeginAllowThreads();
19122 (arg1)->AddPen(arg2);
19123
19124 wxPyEndAllowThreads(__tstate);
19125 if (PyErr_Occurred()) SWIG_fail;
19126 }
19127 Py_INCREF(Py_None); resultobj = Py_None;
19128 return resultobj;
19129 fail:
19130 return NULL;
19131 }
19132
19133
19134 static PyObject *_wrap_PenList_FindOrCreatePen(PyObject *, PyObject *args, PyObject *kwargs) {
19135 PyObject *resultobj;
19136 wxPenList *arg1 = (wxPenList *) 0 ;
19137 wxColour *arg2 = 0 ;
19138 int arg3 ;
19139 int arg4 ;
19140 wxPen *result;
19141 wxColour temp2 ;
19142 PyObject * obj0 = 0 ;
19143 PyObject * obj1 = 0 ;
19144 PyObject * obj2 = 0 ;
19145 PyObject * obj3 = 0 ;
19146 char *kwnames[] = {
19147 (char *) "self",(char *) "colour",(char *) "width",(char *) "style", NULL
19148 };
19149
19150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PenList_FindOrCreatePen",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19152 if (SWIG_arg_fail(1)) SWIG_fail;
19153 {
19154 arg2 = &temp2;
19155 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19156 }
19157 {
19158 arg3 = (int)(SWIG_As_int(obj2));
19159 if (SWIG_arg_fail(3)) SWIG_fail;
19160 }
19161 {
19162 arg4 = (int)(SWIG_As_int(obj3));
19163 if (SWIG_arg_fail(4)) SWIG_fail;
19164 }
19165 {
19166 PyThreadState* __tstate = wxPyBeginAllowThreads();
19167 result = (wxPen *)(arg1)->FindOrCreatePen((wxColour const &)*arg2,arg3,arg4);
19168
19169 wxPyEndAllowThreads(__tstate);
19170 if (PyErr_Occurred()) SWIG_fail;
19171 }
19172 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPen, 0);
19173 return resultobj;
19174 fail:
19175 return NULL;
19176 }
19177
19178
19179 static PyObject *_wrap_PenList_RemovePen(PyObject *, PyObject *args, PyObject *kwargs) {
19180 PyObject *resultobj;
19181 wxPenList *arg1 = (wxPenList *) 0 ;
19182 wxPen *arg2 = (wxPen *) 0 ;
19183 PyObject * obj0 = 0 ;
19184 PyObject * obj1 = 0 ;
19185 char *kwnames[] = {
19186 (char *) "self",(char *) "pen", NULL
19187 };
19188
19189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PenList_RemovePen",kwnames,&obj0,&obj1)) goto fail;
19190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19191 if (SWIG_arg_fail(1)) SWIG_fail;
19192 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPen, SWIG_POINTER_EXCEPTION | 0);
19193 if (SWIG_arg_fail(2)) SWIG_fail;
19194 {
19195 PyThreadState* __tstate = wxPyBeginAllowThreads();
19196 (arg1)->RemovePen(arg2);
19197
19198 wxPyEndAllowThreads(__tstate);
19199 if (PyErr_Occurred()) SWIG_fail;
19200 }
19201 Py_INCREF(Py_None); resultobj = Py_None;
19202 return resultobj;
19203 fail:
19204 return NULL;
19205 }
19206
19207
19208 static PyObject *_wrap_PenList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
19209 PyObject *resultobj;
19210 wxPenList *arg1 = (wxPenList *) 0 ;
19211 int result;
19212 PyObject * obj0 = 0 ;
19213 char *kwnames[] = {
19214 (char *) "self", NULL
19215 };
19216
19217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PenList_GetCount",kwnames,&obj0)) goto fail;
19218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPenList, SWIG_POINTER_EXCEPTION | 0);
19219 if (SWIG_arg_fail(1)) SWIG_fail;
19220 {
19221 PyThreadState* __tstate = wxPyBeginAllowThreads();
19222 result = (int)(arg1)->GetCount();
19223
19224 wxPyEndAllowThreads(__tstate);
19225 if (PyErr_Occurred()) SWIG_fail;
19226 }
19227 {
19228 resultobj = SWIG_From_int((int)(result));
19229 }
19230 return resultobj;
19231 fail:
19232 return NULL;
19233 }
19234
19235
19236 static PyObject * PenList_swigregister(PyObject *, PyObject *args) {
19237 PyObject *obj;
19238 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19239 SWIG_TypeClientData(SWIGTYPE_p_wxPenList, obj);
19240 Py_INCREF(obj);
19241 return Py_BuildValue((char *)"");
19242 }
19243 static PyObject *_wrap_BrushList_AddBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19244 PyObject *resultobj;
19245 wxBrushList *arg1 = (wxBrushList *) 0 ;
19246 wxBrush *arg2 = (wxBrush *) 0 ;
19247 PyObject * obj0 = 0 ;
19248 PyObject * obj1 = 0 ;
19249 char *kwnames[] = {
19250 (char *) "self",(char *) "brush", NULL
19251 };
19252
19253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_AddBrush",kwnames,&obj0,&obj1)) goto fail;
19254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19255 if (SWIG_arg_fail(1)) SWIG_fail;
19256 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
19257 if (SWIG_arg_fail(2)) SWIG_fail;
19258 {
19259 PyThreadState* __tstate = wxPyBeginAllowThreads();
19260 (arg1)->AddBrush(arg2);
19261
19262 wxPyEndAllowThreads(__tstate);
19263 if (PyErr_Occurred()) SWIG_fail;
19264 }
19265 Py_INCREF(Py_None); resultobj = Py_None;
19266 return resultobj;
19267 fail:
19268 return NULL;
19269 }
19270
19271
19272 static PyObject *_wrap_BrushList_FindOrCreateBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19273 PyObject *resultobj;
19274 wxBrushList *arg1 = (wxBrushList *) 0 ;
19275 wxColour *arg2 = 0 ;
19276 int arg3 ;
19277 wxBrush *result;
19278 wxColour temp2 ;
19279 PyObject * obj0 = 0 ;
19280 PyObject * obj1 = 0 ;
19281 PyObject * obj2 = 0 ;
19282 char *kwnames[] = {
19283 (char *) "self",(char *) "colour",(char *) "style", NULL
19284 };
19285
19286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:BrushList_FindOrCreateBrush",kwnames,&obj0,&obj1,&obj2)) goto fail;
19287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19288 if (SWIG_arg_fail(1)) SWIG_fail;
19289 {
19290 arg2 = &temp2;
19291 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19292 }
19293 {
19294 arg3 = (int)(SWIG_As_int(obj2));
19295 if (SWIG_arg_fail(3)) SWIG_fail;
19296 }
19297 {
19298 PyThreadState* __tstate = wxPyBeginAllowThreads();
19299 result = (wxBrush *)(arg1)->FindOrCreateBrush((wxColour const &)*arg2,arg3);
19300
19301 wxPyEndAllowThreads(__tstate);
19302 if (PyErr_Occurred()) SWIG_fail;
19303 }
19304 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBrush, 0);
19305 return resultobj;
19306 fail:
19307 return NULL;
19308 }
19309
19310
19311 static PyObject *_wrap_BrushList_RemoveBrush(PyObject *, PyObject *args, PyObject *kwargs) {
19312 PyObject *resultobj;
19313 wxBrushList *arg1 = (wxBrushList *) 0 ;
19314 wxBrush *arg2 = (wxBrush *) 0 ;
19315 PyObject * obj0 = 0 ;
19316 PyObject * obj1 = 0 ;
19317 char *kwnames[] = {
19318 (char *) "self",(char *) "brush", NULL
19319 };
19320
19321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BrushList_RemoveBrush",kwnames,&obj0,&obj1)) goto fail;
19322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19323 if (SWIG_arg_fail(1)) SWIG_fail;
19324 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBrush, SWIG_POINTER_EXCEPTION | 0);
19325 if (SWIG_arg_fail(2)) SWIG_fail;
19326 {
19327 PyThreadState* __tstate = wxPyBeginAllowThreads();
19328 (arg1)->RemoveBrush(arg2);
19329
19330 wxPyEndAllowThreads(__tstate);
19331 if (PyErr_Occurred()) SWIG_fail;
19332 }
19333 Py_INCREF(Py_None); resultobj = Py_None;
19334 return resultobj;
19335 fail:
19336 return NULL;
19337 }
19338
19339
19340 static PyObject *_wrap_BrushList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
19341 PyObject *resultobj;
19342 wxBrushList *arg1 = (wxBrushList *) 0 ;
19343 int result;
19344 PyObject * obj0 = 0 ;
19345 char *kwnames[] = {
19346 (char *) "self", NULL
19347 };
19348
19349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BrushList_GetCount",kwnames,&obj0)) goto fail;
19350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBrushList, SWIG_POINTER_EXCEPTION | 0);
19351 if (SWIG_arg_fail(1)) SWIG_fail;
19352 {
19353 PyThreadState* __tstate = wxPyBeginAllowThreads();
19354 result = (int)(arg1)->GetCount();
19355
19356 wxPyEndAllowThreads(__tstate);
19357 if (PyErr_Occurred()) SWIG_fail;
19358 }
19359 {
19360 resultobj = SWIG_From_int((int)(result));
19361 }
19362 return resultobj;
19363 fail:
19364 return NULL;
19365 }
19366
19367
19368 static PyObject * BrushList_swigregister(PyObject *, PyObject *args) {
19369 PyObject *obj;
19370 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19371 SWIG_TypeClientData(SWIGTYPE_p_wxBrushList, obj);
19372 Py_INCREF(obj);
19373 return Py_BuildValue((char *)"");
19374 }
19375 static PyObject *_wrap_new_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
19376 PyObject *resultobj;
19377 wxColourDatabase *result;
19378 char *kwnames[] = {
19379 NULL
19380 };
19381
19382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ColourDatabase",kwnames)) goto fail;
19383 {
19384 if (!wxPyCheckForApp()) SWIG_fail;
19385 PyThreadState* __tstate = wxPyBeginAllowThreads();
19386 result = (wxColourDatabase *)new wxColourDatabase();
19387
19388 wxPyEndAllowThreads(__tstate);
19389 if (PyErr_Occurred()) SWIG_fail;
19390 }
19391 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColourDatabase, 1);
19392 return resultobj;
19393 fail:
19394 return NULL;
19395 }
19396
19397
19398 static PyObject *_wrap_delete_ColourDatabase(PyObject *, PyObject *args, PyObject *kwargs) {
19399 PyObject *resultobj;
19400 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19401 PyObject * obj0 = 0 ;
19402 char *kwnames[] = {
19403 (char *) "self", NULL
19404 };
19405
19406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ColourDatabase",kwnames,&obj0)) goto fail;
19407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19408 if (SWIG_arg_fail(1)) SWIG_fail;
19409 {
19410 PyThreadState* __tstate = wxPyBeginAllowThreads();
19411 delete arg1;
19412
19413 wxPyEndAllowThreads(__tstate);
19414 if (PyErr_Occurred()) SWIG_fail;
19415 }
19416 Py_INCREF(Py_None); resultobj = Py_None;
19417 return resultobj;
19418 fail:
19419 return NULL;
19420 }
19421
19422
19423 static PyObject *_wrap_ColourDatabase_Find(PyObject *, PyObject *args, PyObject *kwargs) {
19424 PyObject *resultobj;
19425 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19426 wxString *arg2 = 0 ;
19427 wxColour result;
19428 bool temp2 = false ;
19429 PyObject * obj0 = 0 ;
19430 PyObject * obj1 = 0 ;
19431 char *kwnames[] = {
19432 (char *) "self",(char *) "name", NULL
19433 };
19434
19435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_Find",kwnames,&obj0,&obj1)) goto fail;
19436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19437 if (SWIG_arg_fail(1)) SWIG_fail;
19438 {
19439 arg2 = wxString_in_helper(obj1);
19440 if (arg2 == NULL) SWIG_fail;
19441 temp2 = true;
19442 }
19443 {
19444 PyThreadState* __tstate = wxPyBeginAllowThreads();
19445 result = ((wxColourDatabase const *)arg1)->Find((wxString const &)*arg2);
19446
19447 wxPyEndAllowThreads(__tstate);
19448 if (PyErr_Occurred()) SWIG_fail;
19449 }
19450 {
19451 wxColour * resultptr;
19452 resultptr = new wxColour((wxColour &)(result));
19453 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
19454 }
19455 {
19456 if (temp2)
19457 delete arg2;
19458 }
19459 return resultobj;
19460 fail:
19461 {
19462 if (temp2)
19463 delete arg2;
19464 }
19465 return NULL;
19466 }
19467
19468
19469 static PyObject *_wrap_ColourDatabase_FindName(PyObject *, PyObject *args, PyObject *kwargs) {
19470 PyObject *resultobj;
19471 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19472 wxColour *arg2 = 0 ;
19473 wxString result;
19474 wxColour temp2 ;
19475 PyObject * obj0 = 0 ;
19476 PyObject * obj1 = 0 ;
19477 char *kwnames[] = {
19478 (char *) "self",(char *) "colour", NULL
19479 };
19480
19481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ColourDatabase_FindName",kwnames,&obj0,&obj1)) goto fail;
19482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19483 if (SWIG_arg_fail(1)) SWIG_fail;
19484 {
19485 arg2 = &temp2;
19486 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
19487 }
19488 {
19489 PyThreadState* __tstate = wxPyBeginAllowThreads();
19490 result = ((wxColourDatabase const *)arg1)->FindName((wxColour const &)*arg2);
19491
19492 wxPyEndAllowThreads(__tstate);
19493 if (PyErr_Occurred()) SWIG_fail;
19494 }
19495 {
19496 #if wxUSE_UNICODE
19497 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19498 #else
19499 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19500 #endif
19501 }
19502 return resultobj;
19503 fail:
19504 return NULL;
19505 }
19506
19507
19508 static PyObject *_wrap_ColourDatabase_AddColour(PyObject *, PyObject *args, PyObject *kwargs) {
19509 PyObject *resultobj;
19510 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19511 wxString *arg2 = 0 ;
19512 wxColour *arg3 = 0 ;
19513 bool temp2 = false ;
19514 wxColour temp3 ;
19515 PyObject * obj0 = 0 ;
19516 PyObject * obj1 = 0 ;
19517 PyObject * obj2 = 0 ;
19518 char *kwnames[] = {
19519 (char *) "self",(char *) "name",(char *) "colour", NULL
19520 };
19521
19522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ColourDatabase_AddColour",kwnames,&obj0,&obj1,&obj2)) goto fail;
19523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19524 if (SWIG_arg_fail(1)) SWIG_fail;
19525 {
19526 arg2 = wxString_in_helper(obj1);
19527 if (arg2 == NULL) SWIG_fail;
19528 temp2 = true;
19529 }
19530 {
19531 arg3 = &temp3;
19532 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
19533 }
19534 {
19535 PyThreadState* __tstate = wxPyBeginAllowThreads();
19536 (arg1)->AddColour((wxString const &)*arg2,(wxColour const &)*arg3);
19537
19538 wxPyEndAllowThreads(__tstate);
19539 if (PyErr_Occurred()) SWIG_fail;
19540 }
19541 Py_INCREF(Py_None); resultobj = Py_None;
19542 {
19543 if (temp2)
19544 delete arg2;
19545 }
19546 return resultobj;
19547 fail:
19548 {
19549 if (temp2)
19550 delete arg2;
19551 }
19552 return NULL;
19553 }
19554
19555
19556 static PyObject *_wrap_ColourDatabase_Append(PyObject *, PyObject *args, PyObject *kwargs) {
19557 PyObject *resultobj;
19558 wxColourDatabase *arg1 = (wxColourDatabase *) 0 ;
19559 wxString *arg2 = 0 ;
19560 int arg3 ;
19561 int arg4 ;
19562 int arg5 ;
19563 bool temp2 = false ;
19564 PyObject * obj0 = 0 ;
19565 PyObject * obj1 = 0 ;
19566 PyObject * obj2 = 0 ;
19567 PyObject * obj3 = 0 ;
19568 PyObject * obj4 = 0 ;
19569 char *kwnames[] = {
19570 (char *) "self",(char *) "name",(char *) "red",(char *) "green",(char *) "blue", NULL
19571 };
19572
19573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:ColourDatabase_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxColourDatabase, SWIG_POINTER_EXCEPTION | 0);
19575 if (SWIG_arg_fail(1)) SWIG_fail;
19576 {
19577 arg2 = wxString_in_helper(obj1);
19578 if (arg2 == NULL) SWIG_fail;
19579 temp2 = true;
19580 }
19581 {
19582 arg3 = (int)(SWIG_As_int(obj2));
19583 if (SWIG_arg_fail(3)) SWIG_fail;
19584 }
19585 {
19586 arg4 = (int)(SWIG_As_int(obj3));
19587 if (SWIG_arg_fail(4)) SWIG_fail;
19588 }
19589 {
19590 arg5 = (int)(SWIG_As_int(obj4));
19591 if (SWIG_arg_fail(5)) SWIG_fail;
19592 }
19593 {
19594 PyThreadState* __tstate = wxPyBeginAllowThreads();
19595 wxColourDatabase_Append(arg1,(wxString const &)*arg2,arg3,arg4,arg5);
19596
19597 wxPyEndAllowThreads(__tstate);
19598 if (PyErr_Occurred()) SWIG_fail;
19599 }
19600 Py_INCREF(Py_None); resultobj = Py_None;
19601 {
19602 if (temp2)
19603 delete arg2;
19604 }
19605 return resultobj;
19606 fail:
19607 {
19608 if (temp2)
19609 delete arg2;
19610 }
19611 return NULL;
19612 }
19613
19614
19615 static PyObject * ColourDatabase_swigregister(PyObject *, PyObject *args) {
19616 PyObject *obj;
19617 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19618 SWIG_TypeClientData(SWIGTYPE_p_wxColourDatabase, obj);
19619 Py_INCREF(obj);
19620 return Py_BuildValue((char *)"");
19621 }
19622 static PyObject *_wrap_FontList_AddFont(PyObject *, PyObject *args, PyObject *kwargs) {
19623 PyObject *resultobj;
19624 wxFontList *arg1 = (wxFontList *) 0 ;
19625 wxFont *arg2 = (wxFont *) 0 ;
19626 PyObject * obj0 = 0 ;
19627 PyObject * obj1 = 0 ;
19628 char *kwnames[] = {
19629 (char *) "self",(char *) "font", NULL
19630 };
19631
19632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_AddFont",kwnames,&obj0,&obj1)) goto fail;
19633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
19634 if (SWIG_arg_fail(1)) SWIG_fail;
19635 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
19636 if (SWIG_arg_fail(2)) SWIG_fail;
19637 {
19638 PyThreadState* __tstate = wxPyBeginAllowThreads();
19639 (arg1)->AddFont(arg2);
19640
19641 wxPyEndAllowThreads(__tstate);
19642 if (PyErr_Occurred()) SWIG_fail;
19643 }
19644 Py_INCREF(Py_None); resultobj = Py_None;
19645 return resultobj;
19646 fail:
19647 return NULL;
19648 }
19649
19650
19651 static PyObject *_wrap_FontList_FindOrCreateFont(PyObject *, PyObject *args, PyObject *kwargs) {
19652 PyObject *resultobj;
19653 wxFontList *arg1 = (wxFontList *) 0 ;
19654 int arg2 ;
19655 int arg3 ;
19656 int arg4 ;
19657 int arg5 ;
19658 bool arg6 = (bool) false ;
19659 wxString const &arg7_defvalue = wxPyEmptyString ;
19660 wxString *arg7 = (wxString *) &arg7_defvalue ;
19661 wxFontEncoding arg8 = (wxFontEncoding) wxFONTENCODING_DEFAULT ;
19662 wxFont *result;
19663 bool temp7 = false ;
19664 PyObject * obj0 = 0 ;
19665 PyObject * obj1 = 0 ;
19666 PyObject * obj2 = 0 ;
19667 PyObject * obj3 = 0 ;
19668 PyObject * obj4 = 0 ;
19669 PyObject * obj5 = 0 ;
19670 PyObject * obj6 = 0 ;
19671 PyObject * obj7 = 0 ;
19672 char *kwnames[] = {
19673 (char *) "self",(char *) "point_size",(char *) "family",(char *) "style",(char *) "weight",(char *) "underline",(char *) "facename",(char *) "encoding", NULL
19674 };
19675
19676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:FontList_FindOrCreateFont",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
19677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
19678 if (SWIG_arg_fail(1)) SWIG_fail;
19679 {
19680 arg2 = (int)(SWIG_As_int(obj1));
19681 if (SWIG_arg_fail(2)) SWIG_fail;
19682 }
19683 {
19684 arg3 = (int)(SWIG_As_int(obj2));
19685 if (SWIG_arg_fail(3)) SWIG_fail;
19686 }
19687 {
19688 arg4 = (int)(SWIG_As_int(obj3));
19689 if (SWIG_arg_fail(4)) SWIG_fail;
19690 }
19691 {
19692 arg5 = (int)(SWIG_As_int(obj4));
19693 if (SWIG_arg_fail(5)) SWIG_fail;
19694 }
19695 if (obj5) {
19696 {
19697 arg6 = (bool)(SWIG_As_bool(obj5));
19698 if (SWIG_arg_fail(6)) SWIG_fail;
19699 }
19700 }
19701 if (obj6) {
19702 {
19703 arg7 = wxString_in_helper(obj6);
19704 if (arg7 == NULL) SWIG_fail;
19705 temp7 = true;
19706 }
19707 }
19708 if (obj7) {
19709 {
19710 arg8 = (wxFontEncoding)(SWIG_As_int(obj7));
19711 if (SWIG_arg_fail(8)) SWIG_fail;
19712 }
19713 }
19714 {
19715 PyThreadState* __tstate = wxPyBeginAllowThreads();
19716 result = (wxFont *)(arg1)->FindOrCreateFont(arg2,arg3,arg4,arg5,arg6,(wxString const &)*arg7,(wxFontEncoding )arg8);
19717
19718 wxPyEndAllowThreads(__tstate);
19719 if (PyErr_Occurred()) SWIG_fail;
19720 }
19721 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
19722 {
19723 if (temp7)
19724 delete arg7;
19725 }
19726 return resultobj;
19727 fail:
19728 {
19729 if (temp7)
19730 delete arg7;
19731 }
19732 return NULL;
19733 }
19734
19735
19736 static PyObject *_wrap_FontList_RemoveFont(PyObject *, PyObject *args, PyObject *kwargs) {
19737 PyObject *resultobj;
19738 wxFontList *arg1 = (wxFontList *) 0 ;
19739 wxFont *arg2 = (wxFont *) 0 ;
19740 PyObject * obj0 = 0 ;
19741 PyObject * obj1 = 0 ;
19742 char *kwnames[] = {
19743 (char *) "self",(char *) "font", NULL
19744 };
19745
19746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FontList_RemoveFont",kwnames,&obj0,&obj1)) goto fail;
19747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
19748 if (SWIG_arg_fail(1)) SWIG_fail;
19749 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
19750 if (SWIG_arg_fail(2)) SWIG_fail;
19751 {
19752 PyThreadState* __tstate = wxPyBeginAllowThreads();
19753 (arg1)->RemoveFont(arg2);
19754
19755 wxPyEndAllowThreads(__tstate);
19756 if (PyErr_Occurred()) SWIG_fail;
19757 }
19758 Py_INCREF(Py_None); resultobj = Py_None;
19759 return resultobj;
19760 fail:
19761 return NULL;
19762 }
19763
19764
19765 static PyObject *_wrap_FontList_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
19766 PyObject *resultobj;
19767 wxFontList *arg1 = (wxFontList *) 0 ;
19768 int result;
19769 PyObject * obj0 = 0 ;
19770 char *kwnames[] = {
19771 (char *) "self", NULL
19772 };
19773
19774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FontList_GetCount",kwnames,&obj0)) goto fail;
19775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFontList, SWIG_POINTER_EXCEPTION | 0);
19776 if (SWIG_arg_fail(1)) SWIG_fail;
19777 {
19778 PyThreadState* __tstate = wxPyBeginAllowThreads();
19779 result = (int)(arg1)->GetCount();
19780
19781 wxPyEndAllowThreads(__tstate);
19782 if (PyErr_Occurred()) SWIG_fail;
19783 }
19784 {
19785 resultobj = SWIG_From_int((int)(result));
19786 }
19787 return resultobj;
19788 fail:
19789 return NULL;
19790 }
19791
19792
19793 static PyObject * FontList_swigregister(PyObject *, PyObject *args) {
19794 PyObject *obj;
19795 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19796 SWIG_TypeClientData(SWIGTYPE_p_wxFontList, obj);
19797 Py_INCREF(obj);
19798 return Py_BuildValue((char *)"");
19799 }
19800 static int _wrap_TheFontList_set(PyObject *) {
19801 PyErr_SetString(PyExc_TypeError,"Variable TheFontList is read-only.");
19802 return 1;
19803 }
19804
19805
19806 static PyObject *_wrap_TheFontList_get(void) {
19807 PyObject *pyobj;
19808
19809 pyobj = SWIG_NewPointerObj((void *)(wxTheFontList), SWIGTYPE_p_wxFontList, 0);
19810 return pyobj;
19811 }
19812
19813
19814 static int _wrap_ThePenList_set(PyObject *) {
19815 PyErr_SetString(PyExc_TypeError,"Variable ThePenList is read-only.");
19816 return 1;
19817 }
19818
19819
19820 static PyObject *_wrap_ThePenList_get(void) {
19821 PyObject *pyobj;
19822
19823 pyobj = SWIG_NewPointerObj((void *)(wxThePenList), SWIGTYPE_p_wxPenList, 0);
19824 return pyobj;
19825 }
19826
19827
19828 static int _wrap_TheBrushList_set(PyObject *) {
19829 PyErr_SetString(PyExc_TypeError,"Variable TheBrushList is read-only.");
19830 return 1;
19831 }
19832
19833
19834 static PyObject *_wrap_TheBrushList_get(void) {
19835 PyObject *pyobj;
19836
19837 pyobj = SWIG_NewPointerObj((void *)(wxTheBrushList), SWIGTYPE_p_wxBrushList, 0);
19838 return pyobj;
19839 }
19840
19841
19842 static int _wrap_TheColourDatabase_set(PyObject *) {
19843 PyErr_SetString(PyExc_TypeError,"Variable TheColourDatabase is read-only.");
19844 return 1;
19845 }
19846
19847
19848 static PyObject *_wrap_TheColourDatabase_get(void) {
19849 PyObject *pyobj;
19850
19851 pyobj = SWIG_NewPointerObj((void *)(wxTheColourDatabase), SWIGTYPE_p_wxColourDatabase, 0);
19852 return pyobj;
19853 }
19854
19855
19856 static PyObject *_wrap_new_Effects(PyObject *, PyObject *args, PyObject *kwargs) {
19857 PyObject *resultobj;
19858 wxEffects *result;
19859 char *kwnames[] = {
19860 NULL
19861 };
19862
19863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Effects",kwnames)) goto fail;
19864 {
19865 PyThreadState* __tstate = wxPyBeginAllowThreads();
19866 result = (wxEffects *)new wxEffects();
19867
19868 wxPyEndAllowThreads(__tstate);
19869 if (PyErr_Occurred()) SWIG_fail;
19870 }
19871 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEffects, 1);
19872 return resultobj;
19873 fail:
19874 return NULL;
19875 }
19876
19877
19878 static PyObject *_wrap_Effects_GetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
19879 PyObject *resultobj;
19880 wxEffects *arg1 = (wxEffects *) 0 ;
19881 wxColour result;
19882 PyObject * obj0 = 0 ;
19883 char *kwnames[] = {
19884 (char *) "self", NULL
19885 };
19886
19887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetHighlightColour",kwnames,&obj0)) goto fail;
19888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
19889 if (SWIG_arg_fail(1)) SWIG_fail;
19890 {
19891 PyThreadState* __tstate = wxPyBeginAllowThreads();
19892 result = ((wxEffects const *)arg1)->GetHighlightColour();
19893
19894 wxPyEndAllowThreads(__tstate);
19895 if (PyErr_Occurred()) SWIG_fail;
19896 }
19897 {
19898 wxColour * resultptr;
19899 resultptr = new wxColour((wxColour &)(result));
19900 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
19901 }
19902 return resultobj;
19903 fail:
19904 return NULL;
19905 }
19906
19907
19908 static PyObject *_wrap_Effects_GetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
19909 PyObject *resultobj;
19910 wxEffects *arg1 = (wxEffects *) 0 ;
19911 wxColour result;
19912 PyObject * obj0 = 0 ;
19913 char *kwnames[] = {
19914 (char *) "self", NULL
19915 };
19916
19917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetLightShadow",kwnames,&obj0)) goto fail;
19918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
19919 if (SWIG_arg_fail(1)) SWIG_fail;
19920 {
19921 PyThreadState* __tstate = wxPyBeginAllowThreads();
19922 result = ((wxEffects const *)arg1)->GetLightShadow();
19923
19924 wxPyEndAllowThreads(__tstate);
19925 if (PyErr_Occurred()) SWIG_fail;
19926 }
19927 {
19928 wxColour * resultptr;
19929 resultptr = new wxColour((wxColour &)(result));
19930 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
19931 }
19932 return resultobj;
19933 fail:
19934 return NULL;
19935 }
19936
19937
19938 static PyObject *_wrap_Effects_GetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
19939 PyObject *resultobj;
19940 wxEffects *arg1 = (wxEffects *) 0 ;
19941 wxColour result;
19942 PyObject * obj0 = 0 ;
19943 char *kwnames[] = {
19944 (char *) "self", NULL
19945 };
19946
19947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetFaceColour",kwnames,&obj0)) goto fail;
19948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
19949 if (SWIG_arg_fail(1)) SWIG_fail;
19950 {
19951 PyThreadState* __tstate = wxPyBeginAllowThreads();
19952 result = ((wxEffects const *)arg1)->GetFaceColour();
19953
19954 wxPyEndAllowThreads(__tstate);
19955 if (PyErr_Occurred()) SWIG_fail;
19956 }
19957 {
19958 wxColour * resultptr;
19959 resultptr = new wxColour((wxColour &)(result));
19960 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
19961 }
19962 return resultobj;
19963 fail:
19964 return NULL;
19965 }
19966
19967
19968 static PyObject *_wrap_Effects_GetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
19969 PyObject *resultobj;
19970 wxEffects *arg1 = (wxEffects *) 0 ;
19971 wxColour result;
19972 PyObject * obj0 = 0 ;
19973 char *kwnames[] = {
19974 (char *) "self", NULL
19975 };
19976
19977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetMediumShadow",kwnames,&obj0)) goto fail;
19978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
19979 if (SWIG_arg_fail(1)) SWIG_fail;
19980 {
19981 PyThreadState* __tstate = wxPyBeginAllowThreads();
19982 result = ((wxEffects const *)arg1)->GetMediumShadow();
19983
19984 wxPyEndAllowThreads(__tstate);
19985 if (PyErr_Occurred()) SWIG_fail;
19986 }
19987 {
19988 wxColour * resultptr;
19989 resultptr = new wxColour((wxColour &)(result));
19990 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
19991 }
19992 return resultobj;
19993 fail:
19994 return NULL;
19995 }
19996
19997
19998 static PyObject *_wrap_Effects_GetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
19999 PyObject *resultobj;
20000 wxEffects *arg1 = (wxEffects *) 0 ;
20001 wxColour result;
20002 PyObject * obj0 = 0 ;
20003 char *kwnames[] = {
20004 (char *) "self", NULL
20005 };
20006
20007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Effects_GetDarkShadow",kwnames,&obj0)) goto fail;
20008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20009 if (SWIG_arg_fail(1)) SWIG_fail;
20010 {
20011 PyThreadState* __tstate = wxPyBeginAllowThreads();
20012 result = ((wxEffects const *)arg1)->GetDarkShadow();
20013
20014 wxPyEndAllowThreads(__tstate);
20015 if (PyErr_Occurred()) SWIG_fail;
20016 }
20017 {
20018 wxColour * resultptr;
20019 resultptr = new wxColour((wxColour &)(result));
20020 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
20021 }
20022 return resultobj;
20023 fail:
20024 return NULL;
20025 }
20026
20027
20028 static PyObject *_wrap_Effects_SetHighlightColour(PyObject *, PyObject *args, PyObject *kwargs) {
20029 PyObject *resultobj;
20030 wxEffects *arg1 = (wxEffects *) 0 ;
20031 wxColour *arg2 = 0 ;
20032 wxColour temp2 ;
20033 PyObject * obj0 = 0 ;
20034 PyObject * obj1 = 0 ;
20035 char *kwnames[] = {
20036 (char *) "self",(char *) "c", NULL
20037 };
20038
20039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetHighlightColour",kwnames,&obj0,&obj1)) goto fail;
20040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20041 if (SWIG_arg_fail(1)) SWIG_fail;
20042 {
20043 arg2 = &temp2;
20044 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20045 }
20046 {
20047 PyThreadState* __tstate = wxPyBeginAllowThreads();
20048 (arg1)->SetHighlightColour((wxColour const &)*arg2);
20049
20050 wxPyEndAllowThreads(__tstate);
20051 if (PyErr_Occurred()) SWIG_fail;
20052 }
20053 Py_INCREF(Py_None); resultobj = Py_None;
20054 return resultobj;
20055 fail:
20056 return NULL;
20057 }
20058
20059
20060 static PyObject *_wrap_Effects_SetLightShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20061 PyObject *resultobj;
20062 wxEffects *arg1 = (wxEffects *) 0 ;
20063 wxColour *arg2 = 0 ;
20064 wxColour temp2 ;
20065 PyObject * obj0 = 0 ;
20066 PyObject * obj1 = 0 ;
20067 char *kwnames[] = {
20068 (char *) "self",(char *) "c", NULL
20069 };
20070
20071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetLightShadow",kwnames,&obj0,&obj1)) goto fail;
20072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20073 if (SWIG_arg_fail(1)) SWIG_fail;
20074 {
20075 arg2 = &temp2;
20076 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20077 }
20078 {
20079 PyThreadState* __tstate = wxPyBeginAllowThreads();
20080 (arg1)->SetLightShadow((wxColour const &)*arg2);
20081
20082 wxPyEndAllowThreads(__tstate);
20083 if (PyErr_Occurred()) SWIG_fail;
20084 }
20085 Py_INCREF(Py_None); resultobj = Py_None;
20086 return resultobj;
20087 fail:
20088 return NULL;
20089 }
20090
20091
20092 static PyObject *_wrap_Effects_SetFaceColour(PyObject *, PyObject *args, PyObject *kwargs) {
20093 PyObject *resultobj;
20094 wxEffects *arg1 = (wxEffects *) 0 ;
20095 wxColour *arg2 = 0 ;
20096 wxColour temp2 ;
20097 PyObject * obj0 = 0 ;
20098 PyObject * obj1 = 0 ;
20099 char *kwnames[] = {
20100 (char *) "self",(char *) "c", NULL
20101 };
20102
20103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetFaceColour",kwnames,&obj0,&obj1)) goto fail;
20104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20105 if (SWIG_arg_fail(1)) SWIG_fail;
20106 {
20107 arg2 = &temp2;
20108 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20109 }
20110 {
20111 PyThreadState* __tstate = wxPyBeginAllowThreads();
20112 (arg1)->SetFaceColour((wxColour const &)*arg2);
20113
20114 wxPyEndAllowThreads(__tstate);
20115 if (PyErr_Occurred()) SWIG_fail;
20116 }
20117 Py_INCREF(Py_None); resultobj = Py_None;
20118 return resultobj;
20119 fail:
20120 return NULL;
20121 }
20122
20123
20124 static PyObject *_wrap_Effects_SetMediumShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20125 PyObject *resultobj;
20126 wxEffects *arg1 = (wxEffects *) 0 ;
20127 wxColour *arg2 = 0 ;
20128 wxColour temp2 ;
20129 PyObject * obj0 = 0 ;
20130 PyObject * obj1 = 0 ;
20131 char *kwnames[] = {
20132 (char *) "self",(char *) "c", NULL
20133 };
20134
20135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetMediumShadow",kwnames,&obj0,&obj1)) goto fail;
20136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20137 if (SWIG_arg_fail(1)) SWIG_fail;
20138 {
20139 arg2 = &temp2;
20140 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20141 }
20142 {
20143 PyThreadState* __tstate = wxPyBeginAllowThreads();
20144 (arg1)->SetMediumShadow((wxColour const &)*arg2);
20145
20146 wxPyEndAllowThreads(__tstate);
20147 if (PyErr_Occurred()) SWIG_fail;
20148 }
20149 Py_INCREF(Py_None); resultobj = Py_None;
20150 return resultobj;
20151 fail:
20152 return NULL;
20153 }
20154
20155
20156 static PyObject *_wrap_Effects_SetDarkShadow(PyObject *, PyObject *args, PyObject *kwargs) {
20157 PyObject *resultobj;
20158 wxEffects *arg1 = (wxEffects *) 0 ;
20159 wxColour *arg2 = 0 ;
20160 wxColour temp2 ;
20161 PyObject * obj0 = 0 ;
20162 PyObject * obj1 = 0 ;
20163 char *kwnames[] = {
20164 (char *) "self",(char *) "c", NULL
20165 };
20166
20167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Effects_SetDarkShadow",kwnames,&obj0,&obj1)) goto fail;
20168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20169 if (SWIG_arg_fail(1)) SWIG_fail;
20170 {
20171 arg2 = &temp2;
20172 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20173 }
20174 {
20175 PyThreadState* __tstate = wxPyBeginAllowThreads();
20176 (arg1)->SetDarkShadow((wxColour const &)*arg2);
20177
20178 wxPyEndAllowThreads(__tstate);
20179 if (PyErr_Occurred()) SWIG_fail;
20180 }
20181 Py_INCREF(Py_None); resultobj = Py_None;
20182 return resultobj;
20183 fail:
20184 return NULL;
20185 }
20186
20187
20188 static PyObject *_wrap_Effects_Set(PyObject *, PyObject *args, PyObject *kwargs) {
20189 PyObject *resultobj;
20190 wxEffects *arg1 = (wxEffects *) 0 ;
20191 wxColour *arg2 = 0 ;
20192 wxColour *arg3 = 0 ;
20193 wxColour *arg4 = 0 ;
20194 wxColour *arg5 = 0 ;
20195 wxColour *arg6 = 0 ;
20196 wxColour temp2 ;
20197 wxColour temp3 ;
20198 wxColour temp4 ;
20199 wxColour temp5 ;
20200 wxColour temp6 ;
20201 PyObject * obj0 = 0 ;
20202 PyObject * obj1 = 0 ;
20203 PyObject * obj2 = 0 ;
20204 PyObject * obj3 = 0 ;
20205 PyObject * obj4 = 0 ;
20206 PyObject * obj5 = 0 ;
20207 char *kwnames[] = {
20208 (char *) "self",(char *) "highlightColour",(char *) "lightShadow",(char *) "faceColour",(char *) "mediumShadow",(char *) "darkShadow", NULL
20209 };
20210
20211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Effects_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
20212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20213 if (SWIG_arg_fail(1)) SWIG_fail;
20214 {
20215 arg2 = &temp2;
20216 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
20217 }
20218 {
20219 arg3 = &temp3;
20220 if ( ! wxColour_helper(obj2, &arg3)) SWIG_fail;
20221 }
20222 {
20223 arg4 = &temp4;
20224 if ( ! wxColour_helper(obj3, &arg4)) SWIG_fail;
20225 }
20226 {
20227 arg5 = &temp5;
20228 if ( ! wxColour_helper(obj4, &arg5)) SWIG_fail;
20229 }
20230 {
20231 arg6 = &temp6;
20232 if ( ! wxColour_helper(obj5, &arg6)) SWIG_fail;
20233 }
20234 {
20235 PyThreadState* __tstate = wxPyBeginAllowThreads();
20236 (arg1)->Set((wxColour const &)*arg2,(wxColour const &)*arg3,(wxColour const &)*arg4,(wxColour const &)*arg5,(wxColour const &)*arg6);
20237
20238 wxPyEndAllowThreads(__tstate);
20239 if (PyErr_Occurred()) SWIG_fail;
20240 }
20241 Py_INCREF(Py_None); resultobj = Py_None;
20242 return resultobj;
20243 fail:
20244 return NULL;
20245 }
20246
20247
20248 static PyObject *_wrap_Effects_DrawSunkenEdge(PyObject *, PyObject *args, PyObject *kwargs) {
20249 PyObject *resultobj;
20250 wxEffects *arg1 = (wxEffects *) 0 ;
20251 wxDC *arg2 = 0 ;
20252 wxRect *arg3 = 0 ;
20253 int arg4 = (int) 1 ;
20254 wxRect temp3 ;
20255 PyObject * obj0 = 0 ;
20256 PyObject * obj1 = 0 ;
20257 PyObject * obj2 = 0 ;
20258 PyObject * obj3 = 0 ;
20259 char *kwnames[] = {
20260 (char *) "self",(char *) "dc",(char *) "rect",(char *) "borderSize", NULL
20261 };
20262
20263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Effects_DrawSunkenEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20265 if (SWIG_arg_fail(1)) SWIG_fail;
20266 {
20267 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20268 if (SWIG_arg_fail(2)) SWIG_fail;
20269 if (arg2 == NULL) {
20270 SWIG_null_ref("wxDC");
20271 }
20272 if (SWIG_arg_fail(2)) SWIG_fail;
20273 }
20274 {
20275 arg3 = &temp3;
20276 if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;
20277 }
20278 if (obj3) {
20279 {
20280 arg4 = (int)(SWIG_As_int(obj3));
20281 if (SWIG_arg_fail(4)) SWIG_fail;
20282 }
20283 }
20284 {
20285 PyThreadState* __tstate = wxPyBeginAllowThreads();
20286 (arg1)->DrawSunkenEdge(*arg2,(wxRect const &)*arg3,arg4);
20287
20288 wxPyEndAllowThreads(__tstate);
20289 if (PyErr_Occurred()) SWIG_fail;
20290 }
20291 Py_INCREF(Py_None); resultobj = Py_None;
20292 return resultobj;
20293 fail:
20294 return NULL;
20295 }
20296
20297
20298 static PyObject *_wrap_Effects_TileBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
20299 PyObject *resultobj;
20300 wxEffects *arg1 = (wxEffects *) 0 ;
20301 wxRect *arg2 = 0 ;
20302 wxDC *arg3 = 0 ;
20303 wxBitmap *arg4 = 0 ;
20304 bool result;
20305 wxRect temp2 ;
20306 PyObject * obj0 = 0 ;
20307 PyObject * obj1 = 0 ;
20308 PyObject * obj2 = 0 ;
20309 PyObject * obj3 = 0 ;
20310 char *kwnames[] = {
20311 (char *) "self",(char *) "rect",(char *) "dc",(char *) "bitmap", NULL
20312 };
20313
20314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Effects_TileBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEffects, SWIG_POINTER_EXCEPTION | 0);
20316 if (SWIG_arg_fail(1)) SWIG_fail;
20317 {
20318 arg2 = &temp2;
20319 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
20320 }
20321 {
20322 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20323 if (SWIG_arg_fail(3)) SWIG_fail;
20324 if (arg3 == NULL) {
20325 SWIG_null_ref("wxDC");
20326 }
20327 if (SWIG_arg_fail(3)) SWIG_fail;
20328 }
20329 {
20330 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
20331 if (SWIG_arg_fail(4)) SWIG_fail;
20332 if (arg4 == NULL) {
20333 SWIG_null_ref("wxBitmap");
20334 }
20335 if (SWIG_arg_fail(4)) SWIG_fail;
20336 }
20337 {
20338 PyThreadState* __tstate = wxPyBeginAllowThreads();
20339 result = (bool)(arg1)->TileBitmap((wxRect const &)*arg2,*arg3,*arg4);
20340
20341 wxPyEndAllowThreads(__tstate);
20342 if (PyErr_Occurred()) SWIG_fail;
20343 }
20344 {
20345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20346 }
20347 return resultobj;
20348 fail:
20349 return NULL;
20350 }
20351
20352
20353 static PyObject * Effects_swigregister(PyObject *, PyObject *args) {
20354 PyObject *obj;
20355 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20356 SWIG_TypeClientData(SWIGTYPE_p_wxEffects, obj);
20357 Py_INCREF(obj);
20358 return Py_BuildValue((char *)"");
20359 }
20360 static PyMethodDef SwigMethods[] = {
20361 { (char *)"new_GDIObject", (PyCFunction) _wrap_new_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
20362 { (char *)"delete_GDIObject", (PyCFunction) _wrap_delete_GDIObject, METH_VARARGS | METH_KEYWORDS, NULL},
20363 { (char *)"GDIObject_GetVisible", (PyCFunction) _wrap_GDIObject_GetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20364 { (char *)"GDIObject_SetVisible", (PyCFunction) _wrap_GDIObject_SetVisible, METH_VARARGS | METH_KEYWORDS, NULL},
20365 { (char *)"GDIObject_IsNull", (PyCFunction) _wrap_GDIObject_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
20366 { (char *)"GDIObject_swigregister", GDIObject_swigregister, METH_VARARGS, NULL},
20367 { (char *)"new_Colour", (PyCFunction) _wrap_new_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
20368 { (char *)"new_NamedColour", (PyCFunction) _wrap_new_NamedColour, METH_VARARGS | METH_KEYWORDS, NULL},
20369 { (char *)"new_ColourRGB", (PyCFunction) _wrap_new_ColourRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20370 { (char *)"delete_Colour", (PyCFunction) _wrap_delete_Colour, METH_VARARGS | METH_KEYWORDS, NULL},
20371 { (char *)"Colour_Red", (PyCFunction) _wrap_Colour_Red, METH_VARARGS | METH_KEYWORDS, NULL},
20372 { (char *)"Colour_Green", (PyCFunction) _wrap_Colour_Green, METH_VARARGS | METH_KEYWORDS, NULL},
20373 { (char *)"Colour_Blue", (PyCFunction) _wrap_Colour_Blue, METH_VARARGS | METH_KEYWORDS, NULL},
20374 { (char *)"Colour_Ok", (PyCFunction) _wrap_Colour_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20375 { (char *)"Colour_Set", (PyCFunction) _wrap_Colour_Set, METH_VARARGS | METH_KEYWORDS, NULL},
20376 { (char *)"Colour_SetRGB", (PyCFunction) _wrap_Colour_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20377 { (char *)"Colour_SetFromName", (PyCFunction) _wrap_Colour_SetFromName, METH_VARARGS | METH_KEYWORDS, NULL},
20378 { (char *)"Colour_GetPixel", (PyCFunction) _wrap_Colour_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
20379 { (char *)"Colour___eq__", (PyCFunction) _wrap_Colour___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20380 { (char *)"Colour___ne__", (PyCFunction) _wrap_Colour___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20381 { (char *)"Colour_Get", (PyCFunction) _wrap_Colour_Get, METH_VARARGS | METH_KEYWORDS, NULL},
20382 { (char *)"Colour_GetRGB", (PyCFunction) _wrap_Colour_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20383 { (char *)"Colour_swigregister", Colour_swigregister, METH_VARARGS, NULL},
20384 { (char *)"new_Palette", (PyCFunction) _wrap_new_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
20385 { (char *)"delete_Palette", (PyCFunction) _wrap_delete_Palette, METH_VARARGS | METH_KEYWORDS, NULL},
20386 { (char *)"Palette_GetPixel", (PyCFunction) _wrap_Palette_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
20387 { (char *)"Palette_GetRGB", (PyCFunction) _wrap_Palette_GetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
20388 { (char *)"Palette_GetColoursCount", (PyCFunction) _wrap_Palette_GetColoursCount, METH_VARARGS | METH_KEYWORDS, NULL},
20389 { (char *)"Palette_Ok", (PyCFunction) _wrap_Palette_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20390 { (char *)"Palette_swigregister", Palette_swigregister, METH_VARARGS, NULL},
20391 { (char *)"new_Pen", (PyCFunction) _wrap_new_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
20392 { (char *)"delete_Pen", (PyCFunction) _wrap_delete_Pen, METH_VARARGS | METH_KEYWORDS, NULL},
20393 { (char *)"Pen_GetCap", (PyCFunction) _wrap_Pen_GetCap, METH_VARARGS | METH_KEYWORDS, NULL},
20394 { (char *)"Pen_GetColour", (PyCFunction) _wrap_Pen_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20395 { (char *)"Pen_GetJoin", (PyCFunction) _wrap_Pen_GetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
20396 { (char *)"Pen_GetStyle", (PyCFunction) _wrap_Pen_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20397 { (char *)"Pen_GetWidth", (PyCFunction) _wrap_Pen_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20398 { (char *)"Pen_Ok", (PyCFunction) _wrap_Pen_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20399 { (char *)"Pen_SetCap", (PyCFunction) _wrap_Pen_SetCap, METH_VARARGS | METH_KEYWORDS, NULL},
20400 { (char *)"Pen_SetColour", (PyCFunction) _wrap_Pen_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20401 { (char *)"Pen_SetJoin", (PyCFunction) _wrap_Pen_SetJoin, METH_VARARGS | METH_KEYWORDS, NULL},
20402 { (char *)"Pen_SetStyle", (PyCFunction) _wrap_Pen_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20403 { (char *)"Pen_SetWidth", (PyCFunction) _wrap_Pen_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20404 { (char *)"Pen_SetDashes", (PyCFunction) _wrap_Pen_SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
20405 { (char *)"Pen_GetDashes", (PyCFunction) _wrap_Pen_GetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
20406 { (char *)"Pen__SetDashes", (PyCFunction) _wrap_Pen__SetDashes, METH_VARARGS | METH_KEYWORDS, NULL},
20407 { (char *)"Pen_GetDashCount", (PyCFunction) _wrap_Pen_GetDashCount, METH_VARARGS | METH_KEYWORDS, NULL},
20408 { (char *)"Pen___eq__", (PyCFunction) _wrap_Pen___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20409 { (char *)"Pen___ne__", (PyCFunction) _wrap_Pen___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20410 { (char *)"Pen_swigregister", Pen_swigregister, METH_VARARGS, NULL},
20411 { (char *)"new_Brush", (PyCFunction) _wrap_new_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
20412 { (char *)"delete_Brush", (PyCFunction) _wrap_delete_Brush, METH_VARARGS | METH_KEYWORDS, NULL},
20413 { (char *)"Brush_SetColour", (PyCFunction) _wrap_Brush_SetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20414 { (char *)"Brush_SetStyle", (PyCFunction) _wrap_Brush_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20415 { (char *)"Brush_SetStipple", (PyCFunction) _wrap_Brush_SetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
20416 { (char *)"Brush_GetColour", (PyCFunction) _wrap_Brush_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
20417 { (char *)"Brush_GetStyle", (PyCFunction) _wrap_Brush_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20418 { (char *)"Brush_GetStipple", (PyCFunction) _wrap_Brush_GetStipple, METH_VARARGS | METH_KEYWORDS, NULL},
20419 { (char *)"Brush_IsHatch", (PyCFunction) _wrap_Brush_IsHatch, METH_VARARGS | METH_KEYWORDS, NULL},
20420 { (char *)"Brush_Ok", (PyCFunction) _wrap_Brush_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20421 { (char *)"Brush_swigregister", Brush_swigregister, METH_VARARGS, NULL},
20422 { (char *)"new_Bitmap", (PyCFunction) _wrap_new_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20423 { (char *)"delete_Bitmap", (PyCFunction) _wrap_delete_Bitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20424 { (char *)"new_EmptyBitmap", (PyCFunction) _wrap_new_EmptyBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20425 { (char *)"new_BitmapFromIcon", (PyCFunction) _wrap_new_BitmapFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20426 { (char *)"new_BitmapFromImage", (PyCFunction) _wrap_new_BitmapFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
20427 { (char *)"new_BitmapFromXPMData", (PyCFunction) _wrap_new_BitmapFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
20428 { (char *)"new_BitmapFromBits", (PyCFunction) _wrap_new_BitmapFromBits, METH_VARARGS | METH_KEYWORDS, NULL},
20429 { (char *)"Bitmap_Ok", (PyCFunction) _wrap_Bitmap_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20430 { (char *)"Bitmap_GetWidth", (PyCFunction) _wrap_Bitmap_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20431 { (char *)"Bitmap_GetHeight", (PyCFunction) _wrap_Bitmap_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20432 { (char *)"Bitmap_GetDepth", (PyCFunction) _wrap_Bitmap_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20433 { (char *)"Bitmap_GetSize", (PyCFunction) _wrap_Bitmap_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20434 { (char *)"Bitmap_ConvertToImage", (PyCFunction) _wrap_Bitmap_ConvertToImage, METH_VARARGS | METH_KEYWORDS, NULL},
20435 { (char *)"Bitmap_GetMask", (PyCFunction) _wrap_Bitmap_GetMask, METH_VARARGS | METH_KEYWORDS, NULL},
20436 { (char *)"Bitmap_SetMask", (PyCFunction) _wrap_Bitmap_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
20437 { (char *)"Bitmap_SetMaskColour", (PyCFunction) _wrap_Bitmap_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
20438 { (char *)"Bitmap_GetSubBitmap", (PyCFunction) _wrap_Bitmap_GetSubBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20439 { (char *)"Bitmap_SaveFile", (PyCFunction) _wrap_Bitmap_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
20440 { (char *)"Bitmap_LoadFile", (PyCFunction) _wrap_Bitmap_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
20441 { (char *)"Bitmap_GetPalette", (PyCFunction) _wrap_Bitmap_GetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
20442 { (char *)"Bitmap_CopyFromIcon", (PyCFunction) _wrap_Bitmap_CopyFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20443 { (char *)"Bitmap_SetHeight", (PyCFunction) _wrap_Bitmap_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20444 { (char *)"Bitmap_SetWidth", (PyCFunction) _wrap_Bitmap_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20445 { (char *)"Bitmap_SetDepth", (PyCFunction) _wrap_Bitmap_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20446 { (char *)"Bitmap_SetSize", (PyCFunction) _wrap_Bitmap_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20447 { (char *)"Bitmap___eq__", (PyCFunction) _wrap_Bitmap___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20448 { (char *)"Bitmap___ne__", (PyCFunction) _wrap_Bitmap___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20449 { (char *)"Bitmap_swigregister", Bitmap_swigregister, METH_VARARGS, NULL},
20450 { (char *)"new_Mask", (PyCFunction) _wrap_new_Mask, METH_VARARGS | METH_KEYWORDS, NULL},
20451 { (char *)"Mask_swigregister", Mask_swigregister, METH_VARARGS, NULL},
20452 { (char *)"new_Icon", (PyCFunction) _wrap_new_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
20453 { (char *)"delete_Icon", (PyCFunction) _wrap_delete_Icon, METH_VARARGS | METH_KEYWORDS, NULL},
20454 { (char *)"new_EmptyIcon", (PyCFunction) _wrap_new_EmptyIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20455 { (char *)"new_IconFromLocation", (PyCFunction) _wrap_new_IconFromLocation, METH_VARARGS | METH_KEYWORDS, NULL},
20456 { (char *)"new_IconFromBitmap", (PyCFunction) _wrap_new_IconFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20457 { (char *)"new_IconFromXPMData", (PyCFunction) _wrap_new_IconFromXPMData, METH_VARARGS | METH_KEYWORDS, NULL},
20458 { (char *)"Icon_LoadFile", (PyCFunction) _wrap_Icon_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
20459 { (char *)"Icon_Ok", (PyCFunction) _wrap_Icon_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20460 { (char *)"Icon_GetWidth", (PyCFunction) _wrap_Icon_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20461 { (char *)"Icon_GetHeight", (PyCFunction) _wrap_Icon_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20462 { (char *)"Icon_GetDepth", (PyCFunction) _wrap_Icon_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20463 { (char *)"Icon_SetWidth", (PyCFunction) _wrap_Icon_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20464 { (char *)"Icon_SetHeight", (PyCFunction) _wrap_Icon_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20465 { (char *)"Icon_SetDepth", (PyCFunction) _wrap_Icon_SetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20466 { (char *)"Icon_CopyFromBitmap", (PyCFunction) _wrap_Icon_CopyFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20467 { (char *)"Icon_swigregister", Icon_swigregister, METH_VARARGS, NULL},
20468 { (char *)"new_IconLocation", (PyCFunction) _wrap_new_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
20469 { (char *)"delete_IconLocation", (PyCFunction) _wrap_delete_IconLocation, METH_VARARGS | METH_KEYWORDS, NULL},
20470 { (char *)"IconLocation_IsOk", (PyCFunction) _wrap_IconLocation_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
20471 { (char *)"IconLocation_SetFileName", (PyCFunction) _wrap_IconLocation_SetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
20472 { (char *)"IconLocation_GetFileName", (PyCFunction) _wrap_IconLocation_GetFileName, METH_VARARGS | METH_KEYWORDS, NULL},
20473 { (char *)"IconLocation_SetIndex", (PyCFunction) _wrap_IconLocation_SetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
20474 { (char *)"IconLocation_GetIndex", (PyCFunction) _wrap_IconLocation_GetIndex, METH_VARARGS | METH_KEYWORDS, NULL},
20475 { (char *)"IconLocation_swigregister", IconLocation_swigregister, METH_VARARGS, NULL},
20476 { (char *)"new_IconBundle", (PyCFunction) _wrap_new_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
20477 { (char *)"new_IconBundleFromFile", (PyCFunction) _wrap_new_IconBundleFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
20478 { (char *)"new_IconBundleFromIcon", (PyCFunction) _wrap_new_IconBundleFromIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20479 { (char *)"delete_IconBundle", (PyCFunction) _wrap_delete_IconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
20480 { (char *)"IconBundle_AddIcon", (PyCFunction) _wrap_IconBundle_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20481 { (char *)"IconBundle_AddIconFromFile", (PyCFunction) _wrap_IconBundle_AddIconFromFile, METH_VARARGS | METH_KEYWORDS, NULL},
20482 { (char *)"IconBundle_GetIcon", (PyCFunction) _wrap_IconBundle_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20483 { (char *)"IconBundle_swigregister", IconBundle_swigregister, METH_VARARGS, NULL},
20484 { (char *)"new_Cursor", (PyCFunction) _wrap_new_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
20485 { (char *)"delete_Cursor", (PyCFunction) _wrap_delete_Cursor, METH_VARARGS | METH_KEYWORDS, NULL},
20486 { (char *)"new_StockCursor", (PyCFunction) _wrap_new_StockCursor, METH_VARARGS | METH_KEYWORDS, NULL},
20487 { (char *)"new_CursorFromImage", (PyCFunction) _wrap_new_CursorFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
20488 { (char *)"Cursor_Ok", (PyCFunction) _wrap_Cursor_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20489 { (char *)"Cursor_swigregister", Cursor_swigregister, METH_VARARGS, NULL},
20490 { (char *)"new_Region", (PyCFunction) _wrap_new_Region, METH_VARARGS | METH_KEYWORDS, NULL},
20491 { (char *)"new_RegionFromBitmap", (PyCFunction) _wrap_new_RegionFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20492 { (char *)"new_RegionFromBitmapColour", (PyCFunction) _wrap_new_RegionFromBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
20493 { (char *)"new_RegionFromPoints", (PyCFunction) _wrap_new_RegionFromPoints, METH_VARARGS | METH_KEYWORDS, NULL},
20494 { (char *)"delete_Region", (PyCFunction) _wrap_delete_Region, METH_VARARGS | METH_KEYWORDS, NULL},
20495 { (char *)"Region_Clear", (PyCFunction) _wrap_Region_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
20496 { (char *)"Region_Offset", (PyCFunction) _wrap_Region_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
20497 { (char *)"Region_Contains", (PyCFunction) _wrap_Region_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
20498 { (char *)"Region_ContainsPoint", (PyCFunction) _wrap_Region_ContainsPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20499 { (char *)"Region_ContainsRect", (PyCFunction) _wrap_Region_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
20500 { (char *)"Region_ContainsRectDim", (PyCFunction) _wrap_Region_ContainsRectDim, METH_VARARGS | METH_KEYWORDS, NULL},
20501 { (char *)"Region_GetBox", (PyCFunction) _wrap_Region_GetBox, METH_VARARGS | METH_KEYWORDS, NULL},
20502 { (char *)"Region_Intersect", (PyCFunction) _wrap_Region_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
20503 { (char *)"Region_IntersectRect", (PyCFunction) _wrap_Region_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
20504 { (char *)"Region_IntersectRegion", (PyCFunction) _wrap_Region_IntersectRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20505 { (char *)"Region_IsEmpty", (PyCFunction) _wrap_Region_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
20506 { (char *)"Region_Union", (PyCFunction) _wrap_Region_Union, METH_VARARGS | METH_KEYWORDS, NULL},
20507 { (char *)"Region_UnionRect", (PyCFunction) _wrap_Region_UnionRect, METH_VARARGS | METH_KEYWORDS, NULL},
20508 { (char *)"Region_UnionRegion", (PyCFunction) _wrap_Region_UnionRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20509 { (char *)"Region_Subtract", (PyCFunction) _wrap_Region_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
20510 { (char *)"Region_SubtractRect", (PyCFunction) _wrap_Region_SubtractRect, METH_VARARGS | METH_KEYWORDS, NULL},
20511 { (char *)"Region_SubtractRegion", (PyCFunction) _wrap_Region_SubtractRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20512 { (char *)"Region_Xor", (PyCFunction) _wrap_Region_Xor, METH_VARARGS | METH_KEYWORDS, NULL},
20513 { (char *)"Region_XorRect", (PyCFunction) _wrap_Region_XorRect, METH_VARARGS | METH_KEYWORDS, NULL},
20514 { (char *)"Region_XorRegion", (PyCFunction) _wrap_Region_XorRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20515 { (char *)"Region_ConvertToBitmap", (PyCFunction) _wrap_Region_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20516 { (char *)"Region_UnionBitmap", (PyCFunction) _wrap_Region_UnionBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20517 { (char *)"Region_UnionBitmapColour", (PyCFunction) _wrap_Region_UnionBitmapColour, METH_VARARGS | METH_KEYWORDS, NULL},
20518 { (char *)"Region_swigregister", Region_swigregister, METH_VARARGS, NULL},
20519 { (char *)"new_RegionIterator", (PyCFunction) _wrap_new_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
20520 { (char *)"delete_RegionIterator", (PyCFunction) _wrap_delete_RegionIterator, METH_VARARGS | METH_KEYWORDS, NULL},
20521 { (char *)"RegionIterator_GetX", (PyCFunction) _wrap_RegionIterator_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
20522 { (char *)"RegionIterator_GetY", (PyCFunction) _wrap_RegionIterator_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
20523 { (char *)"RegionIterator_GetW", (PyCFunction) _wrap_RegionIterator_GetW, METH_VARARGS | METH_KEYWORDS, NULL},
20524 { (char *)"RegionIterator_GetWidth", (PyCFunction) _wrap_RegionIterator_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20525 { (char *)"RegionIterator_GetH", (PyCFunction) _wrap_RegionIterator_GetH, METH_VARARGS | METH_KEYWORDS, NULL},
20526 { (char *)"RegionIterator_GetHeight", (PyCFunction) _wrap_RegionIterator_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20527 { (char *)"RegionIterator_GetRect", (PyCFunction) _wrap_RegionIterator_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
20528 { (char *)"RegionIterator_HaveRects", (PyCFunction) _wrap_RegionIterator_HaveRects, METH_VARARGS | METH_KEYWORDS, NULL},
20529 { (char *)"RegionIterator_Reset", (PyCFunction) _wrap_RegionIterator_Reset, METH_VARARGS | METH_KEYWORDS, NULL},
20530 { (char *)"RegionIterator_Next", (PyCFunction) _wrap_RegionIterator_Next, METH_VARARGS | METH_KEYWORDS, NULL},
20531 { (char *)"RegionIterator___nonzero__", (PyCFunction) _wrap_RegionIterator___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
20532 { (char *)"RegionIterator_swigregister", RegionIterator_swigregister, METH_VARARGS, NULL},
20533 { (char *)"new_NativeFontInfo", (PyCFunction) _wrap_new_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20534 { (char *)"delete_NativeFontInfo", (PyCFunction) _wrap_delete_NativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20535 { (char *)"NativeFontInfo_Init", (PyCFunction) _wrap_NativeFontInfo_Init, METH_VARARGS | METH_KEYWORDS, NULL},
20536 { (char *)"NativeFontInfo_InitFromFont", (PyCFunction) _wrap_NativeFontInfo_InitFromFont, METH_VARARGS | METH_KEYWORDS, NULL},
20537 { (char *)"NativeFontInfo_GetPointSize", (PyCFunction) _wrap_NativeFontInfo_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20538 { (char *)"NativeFontInfo_GetStyle", (PyCFunction) _wrap_NativeFontInfo_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20539 { (char *)"NativeFontInfo_GetWeight", (PyCFunction) _wrap_NativeFontInfo_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20540 { (char *)"NativeFontInfo_GetUnderlined", (PyCFunction) _wrap_NativeFontInfo_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20541 { (char *)"NativeFontInfo_GetFaceName", (PyCFunction) _wrap_NativeFontInfo_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20542 { (char *)"NativeFontInfo_GetFamily", (PyCFunction) _wrap_NativeFontInfo_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20543 { (char *)"NativeFontInfo_GetEncoding", (PyCFunction) _wrap_NativeFontInfo_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20544 { (char *)"NativeFontInfo_SetPointSize", (PyCFunction) _wrap_NativeFontInfo_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20545 { (char *)"NativeFontInfo_SetStyle", (PyCFunction) _wrap_NativeFontInfo_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20546 { (char *)"NativeFontInfo_SetWeight", (PyCFunction) _wrap_NativeFontInfo_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20547 { (char *)"NativeFontInfo_SetUnderlined", (PyCFunction) _wrap_NativeFontInfo_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20548 { (char *)"NativeFontInfo_SetFaceName", (PyCFunction) _wrap_NativeFontInfo_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20549 { (char *)"NativeFontInfo_SetFamily", (PyCFunction) _wrap_NativeFontInfo_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20550 { (char *)"NativeFontInfo_SetEncoding", (PyCFunction) _wrap_NativeFontInfo_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20551 { (char *)"NativeFontInfo_FromString", (PyCFunction) _wrap_NativeFontInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
20552 { (char *)"NativeFontInfo_ToString", (PyCFunction) _wrap_NativeFontInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
20553 { (char *)"NativeFontInfo___str__", (PyCFunction) _wrap_NativeFontInfo___str__, METH_VARARGS | METH_KEYWORDS, NULL},
20554 { (char *)"NativeFontInfo_FromUserString", (PyCFunction) _wrap_NativeFontInfo_FromUserString, METH_VARARGS | METH_KEYWORDS, NULL},
20555 { (char *)"NativeFontInfo_ToUserString", (PyCFunction) _wrap_NativeFontInfo_ToUserString, METH_VARARGS | METH_KEYWORDS, NULL},
20556 { (char *)"NativeFontInfo_swigregister", NativeFontInfo_swigregister, METH_VARARGS, NULL},
20557 { (char *)"NativeEncodingInfo_facename_set", (PyCFunction) _wrap_NativeEncodingInfo_facename_set, METH_VARARGS | METH_KEYWORDS, NULL},
20558 { (char *)"NativeEncodingInfo_facename_get", (PyCFunction) _wrap_NativeEncodingInfo_facename_get, METH_VARARGS | METH_KEYWORDS, NULL},
20559 { (char *)"NativeEncodingInfo_encoding_set", (PyCFunction) _wrap_NativeEncodingInfo_encoding_set, METH_VARARGS | METH_KEYWORDS, NULL},
20560 { (char *)"NativeEncodingInfo_encoding_get", (PyCFunction) _wrap_NativeEncodingInfo_encoding_get, METH_VARARGS | METH_KEYWORDS, NULL},
20561 { (char *)"new_NativeEncodingInfo", (PyCFunction) _wrap_new_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20562 { (char *)"delete_NativeEncodingInfo", (PyCFunction) _wrap_delete_NativeEncodingInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20563 { (char *)"NativeEncodingInfo_FromString", (PyCFunction) _wrap_NativeEncodingInfo_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
20564 { (char *)"NativeEncodingInfo_ToString", (PyCFunction) _wrap_NativeEncodingInfo_ToString, METH_VARARGS | METH_KEYWORDS, NULL},
20565 { (char *)"NativeEncodingInfo_swigregister", NativeEncodingInfo_swigregister, METH_VARARGS, NULL},
20566 { (char *)"GetNativeFontEncoding", (PyCFunction) _wrap_GetNativeFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20567 { (char *)"TestFontEncoding", (PyCFunction) _wrap_TestFontEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20568 { (char *)"new_FontMapper", (PyCFunction) _wrap_new_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
20569 { (char *)"delete_FontMapper", (PyCFunction) _wrap_delete_FontMapper, METH_VARARGS | METH_KEYWORDS, NULL},
20570 { (char *)"FontMapper_Get", (PyCFunction) _wrap_FontMapper_Get, METH_VARARGS | METH_KEYWORDS, NULL},
20571 { (char *)"FontMapper_Set", (PyCFunction) _wrap_FontMapper_Set, METH_VARARGS | METH_KEYWORDS, NULL},
20572 { (char *)"FontMapper_CharsetToEncoding", (PyCFunction) _wrap_FontMapper_CharsetToEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20573 { (char *)"FontMapper_GetSupportedEncodingsCount", (PyCFunction) _wrap_FontMapper_GetSupportedEncodingsCount, METH_VARARGS | METH_KEYWORDS, NULL},
20574 { (char *)"FontMapper_GetEncoding", (PyCFunction) _wrap_FontMapper_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20575 { (char *)"FontMapper_GetEncodingName", (PyCFunction) _wrap_FontMapper_GetEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
20576 { (char *)"FontMapper_GetEncodingDescription", (PyCFunction) _wrap_FontMapper_GetEncodingDescription, METH_VARARGS | METH_KEYWORDS, NULL},
20577 { (char *)"FontMapper_GetEncodingFromName", (PyCFunction) _wrap_FontMapper_GetEncodingFromName, METH_VARARGS | METH_KEYWORDS, NULL},
20578 { (char *)"FontMapper_SetConfig", (PyCFunction) _wrap_FontMapper_SetConfig, METH_VARARGS | METH_KEYWORDS, NULL},
20579 { (char *)"FontMapper_SetConfigPath", (PyCFunction) _wrap_FontMapper_SetConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
20580 { (char *)"FontMapper_GetDefaultConfigPath", (PyCFunction) _wrap_FontMapper_GetDefaultConfigPath, METH_VARARGS | METH_KEYWORDS, NULL},
20581 { (char *)"FontMapper_GetAltForEncoding", (PyCFunction) _wrap_FontMapper_GetAltForEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20582 { (char *)"FontMapper_IsEncodingAvailable", (PyCFunction) _wrap_FontMapper_IsEncodingAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
20583 { (char *)"FontMapper_SetDialogParent", (PyCFunction) _wrap_FontMapper_SetDialogParent, METH_VARARGS | METH_KEYWORDS, NULL},
20584 { (char *)"FontMapper_SetDialogTitle", (PyCFunction) _wrap_FontMapper_SetDialogTitle, METH_VARARGS | METH_KEYWORDS, NULL},
20585 { (char *)"FontMapper_swigregister", FontMapper_swigregister, METH_VARARGS, NULL},
20586 { (char *)"new_Font", (PyCFunction) _wrap_new_Font, METH_VARARGS | METH_KEYWORDS, NULL},
20587 { (char *)"delete_Font", (PyCFunction) _wrap_delete_Font, METH_VARARGS | METH_KEYWORDS, NULL},
20588 { (char *)"new_FontFromNativeInfo", (PyCFunction) _wrap_new_FontFromNativeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20589 { (char *)"new_FontFromNativeInfoString", (PyCFunction) _wrap_new_FontFromNativeInfoString, METH_VARARGS | METH_KEYWORDS, NULL},
20590 { (char *)"new_Font2", (PyCFunction) _wrap_new_Font2, METH_VARARGS | METH_KEYWORDS, NULL},
20591 { (char *)"new_FontFromPixelSize", (PyCFunction) _wrap_new_FontFromPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20592 { (char *)"Font_Ok", (PyCFunction) _wrap_Font_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20593 { (char *)"Font___eq__", (PyCFunction) _wrap_Font___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
20594 { (char *)"Font___ne__", (PyCFunction) _wrap_Font___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
20595 { (char *)"Font_GetPointSize", (PyCFunction) _wrap_Font_GetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20596 { (char *)"Font_GetPixelSize", (PyCFunction) _wrap_Font_GetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20597 { (char *)"Font_IsUsingSizeInPixels", (PyCFunction) _wrap_Font_IsUsingSizeInPixels, METH_VARARGS | METH_KEYWORDS, NULL},
20598 { (char *)"Font_GetFamily", (PyCFunction) _wrap_Font_GetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20599 { (char *)"Font_GetStyle", (PyCFunction) _wrap_Font_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20600 { (char *)"Font_GetWeight", (PyCFunction) _wrap_Font_GetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20601 { (char *)"Font_GetUnderlined", (PyCFunction) _wrap_Font_GetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20602 { (char *)"Font_GetFaceName", (PyCFunction) _wrap_Font_GetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20603 { (char *)"Font_GetEncoding", (PyCFunction) _wrap_Font_GetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20604 { (char *)"Font_GetNativeFontInfo", (PyCFunction) _wrap_Font_GetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20605 { (char *)"Font_IsFixedWidth", (PyCFunction) _wrap_Font_IsFixedWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20606 { (char *)"Font_GetNativeFontInfoDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoDesc, METH_VARARGS | METH_KEYWORDS, NULL},
20607 { (char *)"Font_GetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_GetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
20608 { (char *)"Font_SetPointSize", (PyCFunction) _wrap_Font_SetPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20609 { (char *)"Font_SetPixelSize", (PyCFunction) _wrap_Font_SetPixelSize, METH_VARARGS | METH_KEYWORDS, NULL},
20610 { (char *)"Font_SetFamily", (PyCFunction) _wrap_Font_SetFamily, METH_VARARGS | METH_KEYWORDS, NULL},
20611 { (char *)"Font_SetStyle", (PyCFunction) _wrap_Font_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
20612 { (char *)"Font_SetWeight", (PyCFunction) _wrap_Font_SetWeight, METH_VARARGS | METH_KEYWORDS, NULL},
20613 { (char *)"Font_SetFaceName", (PyCFunction) _wrap_Font_SetFaceName, METH_VARARGS | METH_KEYWORDS, NULL},
20614 { (char *)"Font_SetUnderlined", (PyCFunction) _wrap_Font_SetUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},
20615 { (char *)"Font_SetEncoding", (PyCFunction) _wrap_Font_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20616 { (char *)"Font_SetNativeFontInfo", (PyCFunction) _wrap_Font_SetNativeFontInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20617 { (char *)"Font_SetNativeFontInfoFromString", (PyCFunction) _wrap_Font_SetNativeFontInfoFromString, METH_VARARGS | METH_KEYWORDS, NULL},
20618 { (char *)"Font_SetNativeFontInfoUserDesc", (PyCFunction) _wrap_Font_SetNativeFontInfoUserDesc, METH_VARARGS | METH_KEYWORDS, NULL},
20619 { (char *)"Font_GetFamilyString", (PyCFunction) _wrap_Font_GetFamilyString, METH_VARARGS | METH_KEYWORDS, NULL},
20620 { (char *)"Font_GetStyleString", (PyCFunction) _wrap_Font_GetStyleString, METH_VARARGS | METH_KEYWORDS, NULL},
20621 { (char *)"Font_GetWeightString", (PyCFunction) _wrap_Font_GetWeightString, METH_VARARGS | METH_KEYWORDS, NULL},
20622 { (char *)"Font_SetNoAntiAliasing", (PyCFunction) _wrap_Font_SetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
20623 { (char *)"Font_GetNoAntiAliasing", (PyCFunction) _wrap_Font_GetNoAntiAliasing, METH_VARARGS | METH_KEYWORDS, NULL},
20624 { (char *)"Font_GetDefaultEncoding", (PyCFunction) _wrap_Font_GetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20625 { (char *)"Font_SetDefaultEncoding", (PyCFunction) _wrap_Font_SetDefaultEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20626 { (char *)"Font_swigregister", Font_swigregister, METH_VARARGS, NULL},
20627 { (char *)"new_FontEnumerator", (PyCFunction) _wrap_new_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
20628 { (char *)"delete_FontEnumerator", (PyCFunction) _wrap_delete_FontEnumerator, METH_VARARGS | METH_KEYWORDS, NULL},
20629 { (char *)"FontEnumerator__setCallbackInfo", (PyCFunction) _wrap_FontEnumerator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20630 { (char *)"FontEnumerator_EnumerateFacenames", (PyCFunction) _wrap_FontEnumerator_EnumerateFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
20631 { (char *)"FontEnumerator_EnumerateEncodings", (PyCFunction) _wrap_FontEnumerator_EnumerateEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
20632 { (char *)"FontEnumerator_GetEncodings", (PyCFunction) _wrap_FontEnumerator_GetEncodings, METH_VARARGS | METH_KEYWORDS, NULL},
20633 { (char *)"FontEnumerator_GetFacenames", (PyCFunction) _wrap_FontEnumerator_GetFacenames, METH_VARARGS | METH_KEYWORDS, NULL},
20634 { (char *)"FontEnumerator_swigregister", FontEnumerator_swigregister, METH_VARARGS, NULL},
20635 { (char *)"LanguageInfo_Language_set", (PyCFunction) _wrap_LanguageInfo_Language_set, METH_VARARGS | METH_KEYWORDS, NULL},
20636 { (char *)"LanguageInfo_Language_get", (PyCFunction) _wrap_LanguageInfo_Language_get, METH_VARARGS | METH_KEYWORDS, NULL},
20637 { (char *)"LanguageInfo_CanonicalName_set", (PyCFunction) _wrap_LanguageInfo_CanonicalName_set, METH_VARARGS | METH_KEYWORDS, NULL},
20638 { (char *)"LanguageInfo_CanonicalName_get", (PyCFunction) _wrap_LanguageInfo_CanonicalName_get, METH_VARARGS | METH_KEYWORDS, NULL},
20639 { (char *)"LanguageInfo_Description_set", (PyCFunction) _wrap_LanguageInfo_Description_set, METH_VARARGS | METH_KEYWORDS, NULL},
20640 { (char *)"LanguageInfo_Description_get", (PyCFunction) _wrap_LanguageInfo_Description_get, METH_VARARGS | METH_KEYWORDS, NULL},
20641 { (char *)"LanguageInfo_swigregister", LanguageInfo_swigregister, METH_VARARGS, NULL},
20642 { (char *)"new_Locale", (PyCFunction) _wrap_new_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
20643 { (char *)"delete_Locale", (PyCFunction) _wrap_delete_Locale, METH_VARARGS | METH_KEYWORDS, NULL},
20644 { (char *)"Locale_Init1", (PyCFunction) _wrap_Locale_Init1, METH_VARARGS | METH_KEYWORDS, NULL},
20645 { (char *)"Locale_Init2", (PyCFunction) _wrap_Locale_Init2, METH_VARARGS | METH_KEYWORDS, NULL},
20646 { (char *)"Locale_GetSystemLanguage", (PyCFunction) _wrap_Locale_GetSystemLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
20647 { (char *)"Locale_GetSystemEncoding", (PyCFunction) _wrap_Locale_GetSystemEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
20648 { (char *)"Locale_GetSystemEncodingName", (PyCFunction) _wrap_Locale_GetSystemEncodingName, METH_VARARGS | METH_KEYWORDS, NULL},
20649 { (char *)"Locale_IsOk", (PyCFunction) _wrap_Locale_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
20650 { (char *)"Locale_GetLocale", (PyCFunction) _wrap_Locale_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
20651 { (char *)"Locale_GetLanguage", (PyCFunction) _wrap_Locale_GetLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
20652 { (char *)"Locale_GetSysName", (PyCFunction) _wrap_Locale_GetSysName, METH_VARARGS | METH_KEYWORDS, NULL},
20653 { (char *)"Locale_GetCanonicalName", (PyCFunction) _wrap_Locale_GetCanonicalName, METH_VARARGS | METH_KEYWORDS, NULL},
20654 { (char *)"Locale_AddCatalogLookupPathPrefix", (PyCFunction) _wrap_Locale_AddCatalogLookupPathPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
20655 { (char *)"Locale_AddCatalog", (PyCFunction) _wrap_Locale_AddCatalog, METH_VARARGS | METH_KEYWORDS, NULL},
20656 { (char *)"Locale_IsLoaded", (PyCFunction) _wrap_Locale_IsLoaded, METH_VARARGS | METH_KEYWORDS, NULL},
20657 { (char *)"Locale_GetLanguageInfo", (PyCFunction) _wrap_Locale_GetLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20658 { (char *)"Locale_GetLanguageName", (PyCFunction) _wrap_Locale_GetLanguageName, METH_VARARGS | METH_KEYWORDS, NULL},
20659 { (char *)"Locale_FindLanguageInfo", (PyCFunction) _wrap_Locale_FindLanguageInfo, METH_VARARGS | METH_KEYWORDS, NULL},
20660 { (char *)"Locale_AddLanguage", (PyCFunction) _wrap_Locale_AddLanguage, METH_VARARGS | METH_KEYWORDS, NULL},
20661 { (char *)"Locale_GetString", (PyCFunction) _wrap_Locale_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
20662 { (char *)"Locale_GetName", (PyCFunction) _wrap_Locale_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
20663 { (char *)"Locale_swigregister", Locale_swigregister, METH_VARARGS, NULL},
20664 { (char *)"GetLocale", (PyCFunction) _wrap_GetLocale, METH_VARARGS | METH_KEYWORDS, NULL},
20665 { (char *)"GetTranslation", _wrap_GetTranslation, METH_VARARGS, NULL},
20666 { (char *)"new_EncodingConverter", (PyCFunction) _wrap_new_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
20667 { (char *)"delete_EncodingConverter", (PyCFunction) _wrap_delete_EncodingConverter, METH_VARARGS | METH_KEYWORDS, NULL},
20668 { (char *)"EncodingConverter_Init", (PyCFunction) _wrap_EncodingConverter_Init, METH_VARARGS | METH_KEYWORDS, NULL},
20669 { (char *)"EncodingConverter_Convert", (PyCFunction) _wrap_EncodingConverter_Convert, METH_VARARGS | METH_KEYWORDS, NULL},
20670 { (char *)"EncodingConverter_GetPlatformEquivalents", (PyCFunction) _wrap_EncodingConverter_GetPlatformEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
20671 { (char *)"EncodingConverter_GetAllEquivalents", (PyCFunction) _wrap_EncodingConverter_GetAllEquivalents, METH_VARARGS | METH_KEYWORDS, NULL},
20672 { (char *)"EncodingConverter_CanConvert", (PyCFunction) _wrap_EncodingConverter_CanConvert, METH_VARARGS | METH_KEYWORDS, NULL},
20673 { (char *)"EncodingConverter_swigregister", EncodingConverter_swigregister, METH_VARARGS, NULL},
20674 { (char *)"delete_DC", (PyCFunction) _wrap_delete_DC, METH_VARARGS | METH_KEYWORDS, NULL},
20675 { (char *)"DC_BeginDrawing", (PyCFunction) _wrap_DC_BeginDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
20676 { (char *)"DC_EndDrawing", (PyCFunction) _wrap_DC_EndDrawing, METH_VARARGS | METH_KEYWORDS, NULL},
20677 { (char *)"DC_FloodFill", (PyCFunction) _wrap_DC_FloodFill, METH_VARARGS | METH_KEYWORDS, NULL},
20678 { (char *)"DC_FloodFillPoint", (PyCFunction) _wrap_DC_FloodFillPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20679 { (char *)"DC_GetPixel", (PyCFunction) _wrap_DC_GetPixel, METH_VARARGS | METH_KEYWORDS, NULL},
20680 { (char *)"DC_GetPixelPoint", (PyCFunction) _wrap_DC_GetPixelPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20681 { (char *)"DC_DrawLine", (PyCFunction) _wrap_DC_DrawLine, METH_VARARGS | METH_KEYWORDS, NULL},
20682 { (char *)"DC_DrawLinePoint", (PyCFunction) _wrap_DC_DrawLinePoint, METH_VARARGS | METH_KEYWORDS, NULL},
20683 { (char *)"DC_CrossHair", (PyCFunction) _wrap_DC_CrossHair, METH_VARARGS | METH_KEYWORDS, NULL},
20684 { (char *)"DC_CrossHairPoint", (PyCFunction) _wrap_DC_CrossHairPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20685 { (char *)"DC_DrawArc", (PyCFunction) _wrap_DC_DrawArc, METH_VARARGS | METH_KEYWORDS, NULL},
20686 { (char *)"DC_DrawArcPoint", (PyCFunction) _wrap_DC_DrawArcPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20687 { (char *)"DC_DrawCheckMark", (PyCFunction) _wrap_DC_DrawCheckMark, METH_VARARGS | METH_KEYWORDS, NULL},
20688 { (char *)"DC_DrawCheckMarkRect", (PyCFunction) _wrap_DC_DrawCheckMarkRect, METH_VARARGS | METH_KEYWORDS, NULL},
20689 { (char *)"DC_DrawEllipticArc", (PyCFunction) _wrap_DC_DrawEllipticArc, METH_VARARGS | METH_KEYWORDS, NULL},
20690 { (char *)"DC_DrawEllipticArcPointSize", (PyCFunction) _wrap_DC_DrawEllipticArcPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20691 { (char *)"DC_DrawPoint", (PyCFunction) _wrap_DC_DrawPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20692 { (char *)"DC_DrawPointPoint", (PyCFunction) _wrap_DC_DrawPointPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20693 { (char *)"DC_DrawRectangle", (PyCFunction) _wrap_DC_DrawRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
20694 { (char *)"DC_DrawRectangleRect", (PyCFunction) _wrap_DC_DrawRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
20695 { (char *)"DC_DrawRectanglePointSize", (PyCFunction) _wrap_DC_DrawRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20696 { (char *)"DC_DrawRoundedRectangle", (PyCFunction) _wrap_DC_DrawRoundedRectangle, METH_VARARGS | METH_KEYWORDS, NULL},
20697 { (char *)"DC_DrawRoundedRectangleRect", (PyCFunction) _wrap_DC_DrawRoundedRectangleRect, METH_VARARGS | METH_KEYWORDS, NULL},
20698 { (char *)"DC_DrawRoundedRectanglePointSize", (PyCFunction) _wrap_DC_DrawRoundedRectanglePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20699 { (char *)"DC_DrawCircle", (PyCFunction) _wrap_DC_DrawCircle, METH_VARARGS | METH_KEYWORDS, NULL},
20700 { (char *)"DC_DrawCirclePoint", (PyCFunction) _wrap_DC_DrawCirclePoint, METH_VARARGS | METH_KEYWORDS, NULL},
20701 { (char *)"DC_DrawEllipse", (PyCFunction) _wrap_DC_DrawEllipse, METH_VARARGS | METH_KEYWORDS, NULL},
20702 { (char *)"DC_DrawEllipseRect", (PyCFunction) _wrap_DC_DrawEllipseRect, METH_VARARGS | METH_KEYWORDS, NULL},
20703 { (char *)"DC_DrawEllipsePointSize", (PyCFunction) _wrap_DC_DrawEllipsePointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20704 { (char *)"DC_DrawIcon", (PyCFunction) _wrap_DC_DrawIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20705 { (char *)"DC_DrawIconPoint", (PyCFunction) _wrap_DC_DrawIconPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20706 { (char *)"DC_DrawBitmap", (PyCFunction) _wrap_DC_DrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20707 { (char *)"DC_DrawBitmapPoint", (PyCFunction) _wrap_DC_DrawBitmapPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20708 { (char *)"DC_DrawText", (PyCFunction) _wrap_DC_DrawText, METH_VARARGS | METH_KEYWORDS, NULL},
20709 { (char *)"DC_DrawTextPoint", (PyCFunction) _wrap_DC_DrawTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20710 { (char *)"DC_DrawRotatedText", (PyCFunction) _wrap_DC_DrawRotatedText, METH_VARARGS | METH_KEYWORDS, NULL},
20711 { (char *)"DC_DrawRotatedTextPoint", (PyCFunction) _wrap_DC_DrawRotatedTextPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20712 { (char *)"DC_Blit", (PyCFunction) _wrap_DC_Blit, METH_VARARGS | METH_KEYWORDS, NULL},
20713 { (char *)"DC_BlitPointSize", (PyCFunction) _wrap_DC_BlitPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20714 { (char *)"DC_SetClippingRegion", (PyCFunction) _wrap_DC_SetClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20715 { (char *)"DC_SetClippingRegionPointSize", (PyCFunction) _wrap_DC_SetClippingRegionPointSize, METH_VARARGS | METH_KEYWORDS, NULL},
20716 { (char *)"DC_SetClippingRegionAsRegion", (PyCFunction) _wrap_DC_SetClippingRegionAsRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20717 { (char *)"DC_SetClippingRect", (PyCFunction) _wrap_DC_SetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
20718 { (char *)"DC_DrawLines", (PyCFunction) _wrap_DC_DrawLines, METH_VARARGS | METH_KEYWORDS, NULL},
20719 { (char *)"DC_DrawPolygon", (PyCFunction) _wrap_DC_DrawPolygon, METH_VARARGS | METH_KEYWORDS, NULL},
20720 { (char *)"DC_DrawLabel", (PyCFunction) _wrap_DC_DrawLabel, METH_VARARGS | METH_KEYWORDS, NULL},
20721 { (char *)"DC_DrawImageLabel", (PyCFunction) _wrap_DC_DrawImageLabel, METH_VARARGS | METH_KEYWORDS, NULL},
20722 { (char *)"DC_DrawSpline", (PyCFunction) _wrap_DC_DrawSpline, METH_VARARGS | METH_KEYWORDS, NULL},
20723 { (char *)"DC_Clear", (PyCFunction) _wrap_DC_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
20724 { (char *)"DC_StartDoc", (PyCFunction) _wrap_DC_StartDoc, METH_VARARGS | METH_KEYWORDS, NULL},
20725 { (char *)"DC_EndDoc", (PyCFunction) _wrap_DC_EndDoc, METH_VARARGS | METH_KEYWORDS, NULL},
20726 { (char *)"DC_StartPage", (PyCFunction) _wrap_DC_StartPage, METH_VARARGS | METH_KEYWORDS, NULL},
20727 { (char *)"DC_EndPage", (PyCFunction) _wrap_DC_EndPage, METH_VARARGS | METH_KEYWORDS, NULL},
20728 { (char *)"DC_SetFont", (PyCFunction) _wrap_DC_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
20729 { (char *)"DC_SetPen", (PyCFunction) _wrap_DC_SetPen, METH_VARARGS | METH_KEYWORDS, NULL},
20730 { (char *)"DC_SetBrush", (PyCFunction) _wrap_DC_SetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
20731 { (char *)"DC_SetBackground", (PyCFunction) _wrap_DC_SetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20732 { (char *)"DC_SetBackgroundMode", (PyCFunction) _wrap_DC_SetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
20733 { (char *)"DC_SetPalette", (PyCFunction) _wrap_DC_SetPalette, METH_VARARGS | METH_KEYWORDS, NULL},
20734 { (char *)"DC_DestroyClippingRegion", (PyCFunction) _wrap_DC_DestroyClippingRegion, METH_VARARGS | METH_KEYWORDS, NULL},
20735 { (char *)"DC_GetClippingBox", (PyCFunction) _wrap_DC_GetClippingBox, METH_VARARGS | METH_KEYWORDS, NULL},
20736 { (char *)"DC_GetClippingRect", (PyCFunction) _wrap_DC_GetClippingRect, METH_VARARGS | METH_KEYWORDS, NULL},
20737 { (char *)"DC_GetCharHeight", (PyCFunction) _wrap_DC_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
20738 { (char *)"DC_GetCharWidth", (PyCFunction) _wrap_DC_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
20739 { (char *)"DC_GetTextExtent", (PyCFunction) _wrap_DC_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
20740 { (char *)"DC_GetFullTextExtent", (PyCFunction) _wrap_DC_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
20741 { (char *)"DC_GetMultiLineTextExtent", (PyCFunction) _wrap_DC_GetMultiLineTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
20742 { (char *)"DC_GetPartialTextExtents", (PyCFunction) _wrap_DC_GetPartialTextExtents, METH_VARARGS | METH_KEYWORDS, NULL},
20743 { (char *)"DC_GetSize", (PyCFunction) _wrap_DC_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20744 { (char *)"DC_GetSizeTuple", (PyCFunction) _wrap_DC_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
20745 { (char *)"DC_GetSizeMM", (PyCFunction) _wrap_DC_GetSizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
20746 { (char *)"DC_GetSizeMMTuple", (PyCFunction) _wrap_DC_GetSizeMMTuple, METH_VARARGS | METH_KEYWORDS, NULL},
20747 { (char *)"DC_DeviceToLogicalX", (PyCFunction) _wrap_DC_DeviceToLogicalX, METH_VARARGS | METH_KEYWORDS, NULL},
20748 { (char *)"DC_DeviceToLogicalY", (PyCFunction) _wrap_DC_DeviceToLogicalY, METH_VARARGS | METH_KEYWORDS, NULL},
20749 { (char *)"DC_DeviceToLogicalXRel", (PyCFunction) _wrap_DC_DeviceToLogicalXRel, METH_VARARGS | METH_KEYWORDS, NULL},
20750 { (char *)"DC_DeviceToLogicalYRel", (PyCFunction) _wrap_DC_DeviceToLogicalYRel, METH_VARARGS | METH_KEYWORDS, NULL},
20751 { (char *)"DC_LogicalToDeviceX", (PyCFunction) _wrap_DC_LogicalToDeviceX, METH_VARARGS | METH_KEYWORDS, NULL},
20752 { (char *)"DC_LogicalToDeviceY", (PyCFunction) _wrap_DC_LogicalToDeviceY, METH_VARARGS | METH_KEYWORDS, NULL},
20753 { (char *)"DC_LogicalToDeviceXRel", (PyCFunction) _wrap_DC_LogicalToDeviceXRel, METH_VARARGS | METH_KEYWORDS, NULL},
20754 { (char *)"DC_LogicalToDeviceYRel", (PyCFunction) _wrap_DC_LogicalToDeviceYRel, METH_VARARGS | METH_KEYWORDS, NULL},
20755 { (char *)"DC_CanDrawBitmap", (PyCFunction) _wrap_DC_CanDrawBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20756 { (char *)"DC_CanGetTextExtent", (PyCFunction) _wrap_DC_CanGetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
20757 { (char *)"DC_GetDepth", (PyCFunction) _wrap_DC_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
20758 { (char *)"DC_GetPPI", (PyCFunction) _wrap_DC_GetPPI, METH_VARARGS | METH_KEYWORDS, NULL},
20759 { (char *)"DC_Ok", (PyCFunction) _wrap_DC_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
20760 { (char *)"DC_GetBackgroundMode", (PyCFunction) _wrap_DC_GetBackgroundMode, METH_VARARGS | METH_KEYWORDS, NULL},
20761 { (char *)"DC_GetBackground", (PyCFunction) _wrap_DC_GetBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20762 { (char *)"DC_GetBrush", (PyCFunction) _wrap_DC_GetBrush, METH_VARARGS | METH_KEYWORDS, NULL},
20763 { (char *)"DC_GetFont", (PyCFunction) _wrap_DC_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
20764 { (char *)"DC_GetPen", (PyCFunction) _wrap_DC_GetPen, METH_VARARGS | METH_KEYWORDS, NULL},
20765 { (char *)"DC_GetTextBackground", (PyCFunction) _wrap_DC_GetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20766 { (char *)"DC_GetTextForeground", (PyCFunction) _wrap_DC_GetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
20767 { (char *)"DC_SetTextForeground", (PyCFunction) _wrap_DC_SetTextForeground, METH_VARARGS | METH_KEYWORDS, NULL},
20768 { (char *)"DC_SetTextBackground", (PyCFunction) _wrap_DC_SetTextBackground, METH_VARARGS | METH_KEYWORDS, NULL},
20769 { (char *)"DC_GetMapMode", (PyCFunction) _wrap_DC_GetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
20770 { (char *)"DC_SetMapMode", (PyCFunction) _wrap_DC_SetMapMode, METH_VARARGS | METH_KEYWORDS, NULL},
20771 { (char *)"DC_GetUserScale", (PyCFunction) _wrap_DC_GetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
20772 { (char *)"DC_SetUserScale", (PyCFunction) _wrap_DC_SetUserScale, METH_VARARGS | METH_KEYWORDS, NULL},
20773 { (char *)"DC_GetLogicalScale", (PyCFunction) _wrap_DC_GetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
20774 { (char *)"DC_SetLogicalScale", (PyCFunction) _wrap_DC_SetLogicalScale, METH_VARARGS | METH_KEYWORDS, NULL},
20775 { (char *)"DC_GetLogicalOrigin", (PyCFunction) _wrap_DC_GetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
20776 { (char *)"DC_GetLogicalOriginTuple", (PyCFunction) _wrap_DC_GetLogicalOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
20777 { (char *)"DC_SetLogicalOrigin", (PyCFunction) _wrap_DC_SetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
20778 { (char *)"DC_SetLogicalOriginPoint", (PyCFunction) _wrap_DC_SetLogicalOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20779 { (char *)"DC_GetDeviceOrigin", (PyCFunction) _wrap_DC_GetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
20780 { (char *)"DC_GetDeviceOriginTuple", (PyCFunction) _wrap_DC_GetDeviceOriginTuple, METH_VARARGS | METH_KEYWORDS, NULL},
20781 { (char *)"DC_SetDeviceOrigin", (PyCFunction) _wrap_DC_SetDeviceOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
20782 { (char *)"DC_SetDeviceOriginPoint", (PyCFunction) _wrap_DC_SetDeviceOriginPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20783 { (char *)"DC_SetAxisOrientation", (PyCFunction) _wrap_DC_SetAxisOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
20784 { (char *)"DC_GetLogicalFunction", (PyCFunction) _wrap_DC_GetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
20785 { (char *)"DC_SetLogicalFunction", (PyCFunction) _wrap_DC_SetLogicalFunction, METH_VARARGS | METH_KEYWORDS, NULL},
20786 { (char *)"DC_ComputeScaleAndOrigin", (PyCFunction) _wrap_DC_ComputeScaleAndOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
20787 { (char *)"DC_CalcBoundingBox", (PyCFunction) _wrap_DC_CalcBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
20788 { (char *)"DC_CalcBoundingBoxPoint", (PyCFunction) _wrap_DC_CalcBoundingBoxPoint, METH_VARARGS | METH_KEYWORDS, NULL},
20789 { (char *)"DC_ResetBoundingBox", (PyCFunction) _wrap_DC_ResetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
20790 { (char *)"DC_MinX", (PyCFunction) _wrap_DC_MinX, METH_VARARGS | METH_KEYWORDS, NULL},
20791 { (char *)"DC_MaxX", (PyCFunction) _wrap_DC_MaxX, METH_VARARGS | METH_KEYWORDS, NULL},
20792 { (char *)"DC_MinY", (PyCFunction) _wrap_DC_MinY, METH_VARARGS | METH_KEYWORDS, NULL},
20793 { (char *)"DC_MaxY", (PyCFunction) _wrap_DC_MaxY, METH_VARARGS | METH_KEYWORDS, NULL},
20794 { (char *)"DC_GetBoundingBox", (PyCFunction) _wrap_DC_GetBoundingBox, METH_VARARGS | METH_KEYWORDS, NULL},
20795 { (char *)"DC__DrawPointList", (PyCFunction) _wrap_DC__DrawPointList, METH_VARARGS | METH_KEYWORDS, NULL},
20796 { (char *)"DC__DrawLineList", (PyCFunction) _wrap_DC__DrawLineList, METH_VARARGS | METH_KEYWORDS, NULL},
20797 { (char *)"DC__DrawRectangleList", (PyCFunction) _wrap_DC__DrawRectangleList, METH_VARARGS | METH_KEYWORDS, NULL},
20798 { (char *)"DC__DrawEllipseList", (PyCFunction) _wrap_DC__DrawEllipseList, METH_VARARGS | METH_KEYWORDS, NULL},
20799 { (char *)"DC__DrawPolygonList", (PyCFunction) _wrap_DC__DrawPolygonList, METH_VARARGS | METH_KEYWORDS, NULL},
20800 { (char *)"DC__DrawTextList", (PyCFunction) _wrap_DC__DrawTextList, METH_VARARGS | METH_KEYWORDS, NULL},
20801 { (char *)"DC_swigregister", DC_swigregister, METH_VARARGS, NULL},
20802 { (char *)"new_MemoryDC", (PyCFunction) _wrap_new_MemoryDC, METH_VARARGS | METH_KEYWORDS, NULL},
20803 { (char *)"new_MemoryDCFromDC", (PyCFunction) _wrap_new_MemoryDCFromDC, METH_VARARGS | METH_KEYWORDS, NULL},
20804 { (char *)"MemoryDC_SelectObject", (PyCFunction) _wrap_MemoryDC_SelectObject, METH_VARARGS | METH_KEYWORDS, NULL},
20805 { (char *)"MemoryDC_swigregister", MemoryDC_swigregister, METH_VARARGS, NULL},
20806 { (char *)"new_BufferedDC", _wrap_new_BufferedDC, METH_VARARGS, NULL},
20807 { (char *)"delete_BufferedDC", (PyCFunction) _wrap_delete_BufferedDC, METH_VARARGS | METH_KEYWORDS, NULL},
20808 { (char *)"BufferedDC_UnMask", (PyCFunction) _wrap_BufferedDC_UnMask, METH_VARARGS | METH_KEYWORDS, NULL},
20809 { (char *)"BufferedDC_swigregister", BufferedDC_swigregister, METH_VARARGS, NULL},
20810 { (char *)"new_BufferedPaintDC", (PyCFunction) _wrap_new_BufferedPaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
20811 { (char *)"BufferedPaintDC_swigregister", BufferedPaintDC_swigregister, METH_VARARGS, NULL},
20812 { (char *)"new_ScreenDC", (PyCFunction) _wrap_new_ScreenDC, METH_VARARGS | METH_KEYWORDS, NULL},
20813 { (char *)"ScreenDC_StartDrawingOnTopWin", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTopWin, METH_VARARGS | METH_KEYWORDS, NULL},
20814 { (char *)"ScreenDC_StartDrawingOnTop", (PyCFunction) _wrap_ScreenDC_StartDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
20815 { (char *)"ScreenDC_EndDrawingOnTop", (PyCFunction) _wrap_ScreenDC_EndDrawingOnTop, METH_VARARGS | METH_KEYWORDS, NULL},
20816 { (char *)"ScreenDC_swigregister", ScreenDC_swigregister, METH_VARARGS, NULL},
20817 { (char *)"new_ClientDC", (PyCFunction) _wrap_new_ClientDC, METH_VARARGS | METH_KEYWORDS, NULL},
20818 { (char *)"ClientDC_swigregister", ClientDC_swigregister, METH_VARARGS, NULL},
20819 { (char *)"new_PaintDC", (PyCFunction) _wrap_new_PaintDC, METH_VARARGS | METH_KEYWORDS, NULL},
20820 { (char *)"PaintDC_swigregister", PaintDC_swigregister, METH_VARARGS, NULL},
20821 { (char *)"new_WindowDC", (PyCFunction) _wrap_new_WindowDC, METH_VARARGS | METH_KEYWORDS, NULL},
20822 { (char *)"WindowDC_swigregister", WindowDC_swigregister, METH_VARARGS, NULL},
20823 { (char *)"new_MirrorDC", (PyCFunction) _wrap_new_MirrorDC, METH_VARARGS | METH_KEYWORDS, NULL},
20824 { (char *)"MirrorDC_swigregister", MirrorDC_swigregister, METH_VARARGS, NULL},
20825 { (char *)"new_PostScriptDC", (PyCFunction) _wrap_new_PostScriptDC, METH_VARARGS | METH_KEYWORDS, NULL},
20826 { (char *)"PostScriptDC_GetPrintData", (PyCFunction) _wrap_PostScriptDC_GetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
20827 { (char *)"PostScriptDC_SetPrintData", (PyCFunction) _wrap_PostScriptDC_SetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},
20828 { (char *)"PostScriptDC_SetResolution", (PyCFunction) _wrap_PostScriptDC_SetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
20829 { (char *)"PostScriptDC_GetResolution", (PyCFunction) _wrap_PostScriptDC_GetResolution, METH_VARARGS | METH_KEYWORDS, NULL},
20830 { (char *)"PostScriptDC_swigregister", PostScriptDC_swigregister, METH_VARARGS, NULL},
20831 { (char *)"new_MetaFile", (PyCFunction) _wrap_new_MetaFile, METH_VARARGS | METH_KEYWORDS, NULL},
20832 { (char *)"MetaFile_swigregister", MetaFile_swigregister, METH_VARARGS, NULL},
20833 { (char *)"new_MetaFileDC", (PyCFunction) _wrap_new_MetaFileDC, METH_VARARGS | METH_KEYWORDS, NULL},
20834 { (char *)"MetaFileDC_swigregister", MetaFileDC_swigregister, METH_VARARGS, NULL},
20835 { (char *)"new_PrinterDC", (PyCFunction) _wrap_new_PrinterDC, METH_VARARGS | METH_KEYWORDS, NULL},
20836 { (char *)"PrinterDC_swigregister", PrinterDC_swigregister, METH_VARARGS, NULL},
20837 { (char *)"new_ImageList", (PyCFunction) _wrap_new_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
20838 { (char *)"delete_ImageList", (PyCFunction) _wrap_delete_ImageList, METH_VARARGS | METH_KEYWORDS, NULL},
20839 { (char *)"ImageList_Add", (PyCFunction) _wrap_ImageList_Add, METH_VARARGS | METH_KEYWORDS, NULL},
20840 { (char *)"ImageList_AddWithColourMask", (PyCFunction) _wrap_ImageList_AddWithColourMask, METH_VARARGS | METH_KEYWORDS, NULL},
20841 { (char *)"ImageList_AddIcon", (PyCFunction) _wrap_ImageList_AddIcon, METH_VARARGS | METH_KEYWORDS, NULL},
20842 { (char *)"ImageList_Replace", (PyCFunction) _wrap_ImageList_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
20843 { (char *)"ImageList_Draw", (PyCFunction) _wrap_ImageList_Draw, METH_VARARGS | METH_KEYWORDS, NULL},
20844 { (char *)"ImageList_GetImageCount", (PyCFunction) _wrap_ImageList_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
20845 { (char *)"ImageList_Remove", (PyCFunction) _wrap_ImageList_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
20846 { (char *)"ImageList_RemoveAll", (PyCFunction) _wrap_ImageList_RemoveAll, METH_VARARGS | METH_KEYWORDS, NULL},
20847 { (char *)"ImageList_GetSize", (PyCFunction) _wrap_ImageList_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
20848 { (char *)"ImageList_swigregister", ImageList_swigregister, METH_VARARGS, NULL},
20849 { (char *)"PenList_AddPen", (PyCFunction) _wrap_PenList_AddPen, METH_VARARGS | METH_KEYWORDS, NULL},
20850 { (char *)"PenList_FindOrCreatePen", (PyCFunction) _wrap_PenList_FindOrCreatePen, METH_VARARGS | METH_KEYWORDS, NULL},
20851 { (char *)"PenList_RemovePen", (PyCFunction) _wrap_PenList_RemovePen, METH_VARARGS | METH_KEYWORDS, NULL},
20852 { (char *)"PenList_GetCount", (PyCFunction) _wrap_PenList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
20853 { (char *)"PenList_swigregister", PenList_swigregister, METH_VARARGS, NULL},
20854 { (char *)"BrushList_AddBrush", (PyCFunction) _wrap_BrushList_AddBrush, METH_VARARGS | METH_KEYWORDS, NULL},
20855 { (char *)"BrushList_FindOrCreateBrush", (PyCFunction) _wrap_BrushList_FindOrCreateBrush, METH_VARARGS | METH_KEYWORDS, NULL},
20856 { (char *)"BrushList_RemoveBrush", (PyCFunction) _wrap_BrushList_RemoveBrush, METH_VARARGS | METH_KEYWORDS, NULL},
20857 { (char *)"BrushList_GetCount", (PyCFunction) _wrap_BrushList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
20858 { (char *)"BrushList_swigregister", BrushList_swigregister, METH_VARARGS, NULL},
20859 { (char *)"new_ColourDatabase", (PyCFunction) _wrap_new_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
20860 { (char *)"delete_ColourDatabase", (PyCFunction) _wrap_delete_ColourDatabase, METH_VARARGS | METH_KEYWORDS, NULL},
20861 { (char *)"ColourDatabase_Find", (PyCFunction) _wrap_ColourDatabase_Find, METH_VARARGS | METH_KEYWORDS, NULL},
20862 { (char *)"ColourDatabase_FindName", (PyCFunction) _wrap_ColourDatabase_FindName, METH_VARARGS | METH_KEYWORDS, NULL},
20863 { (char *)"ColourDatabase_AddColour", (PyCFunction) _wrap_ColourDatabase_AddColour, METH_VARARGS | METH_KEYWORDS, NULL},
20864 { (char *)"ColourDatabase_Append", (PyCFunction) _wrap_ColourDatabase_Append, METH_VARARGS | METH_KEYWORDS, NULL},
20865 { (char *)"ColourDatabase_swigregister", ColourDatabase_swigregister, METH_VARARGS, NULL},
20866 { (char *)"FontList_AddFont", (PyCFunction) _wrap_FontList_AddFont, METH_VARARGS | METH_KEYWORDS, NULL},
20867 { (char *)"FontList_FindOrCreateFont", (PyCFunction) _wrap_FontList_FindOrCreateFont, METH_VARARGS | METH_KEYWORDS, NULL},
20868 { (char *)"FontList_RemoveFont", (PyCFunction) _wrap_FontList_RemoveFont, METH_VARARGS | METH_KEYWORDS, NULL},
20869 { (char *)"FontList_GetCount", (PyCFunction) _wrap_FontList_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
20870 { (char *)"FontList_swigregister", FontList_swigregister, METH_VARARGS, NULL},
20871 { (char *)"new_Effects", (PyCFunction) _wrap_new_Effects, METH_VARARGS | METH_KEYWORDS, NULL},
20872 { (char *)"Effects_GetHighlightColour", (PyCFunction) _wrap_Effects_GetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
20873 { (char *)"Effects_GetLightShadow", (PyCFunction) _wrap_Effects_GetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
20874 { (char *)"Effects_GetFaceColour", (PyCFunction) _wrap_Effects_GetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
20875 { (char *)"Effects_GetMediumShadow", (PyCFunction) _wrap_Effects_GetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
20876 { (char *)"Effects_GetDarkShadow", (PyCFunction) _wrap_Effects_GetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
20877 { (char *)"Effects_SetHighlightColour", (PyCFunction) _wrap_Effects_SetHighlightColour, METH_VARARGS | METH_KEYWORDS, NULL},
20878 { (char *)"Effects_SetLightShadow", (PyCFunction) _wrap_Effects_SetLightShadow, METH_VARARGS | METH_KEYWORDS, NULL},
20879 { (char *)"Effects_SetFaceColour", (PyCFunction) _wrap_Effects_SetFaceColour, METH_VARARGS | METH_KEYWORDS, NULL},
20880 { (char *)"Effects_SetMediumShadow", (PyCFunction) _wrap_Effects_SetMediumShadow, METH_VARARGS | METH_KEYWORDS, NULL},
20881 { (char *)"Effects_SetDarkShadow", (PyCFunction) _wrap_Effects_SetDarkShadow, METH_VARARGS | METH_KEYWORDS, NULL},
20882 { (char *)"Effects_Set", (PyCFunction) _wrap_Effects_Set, METH_VARARGS | METH_KEYWORDS, NULL},
20883 { (char *)"Effects_DrawSunkenEdge", (PyCFunction) _wrap_Effects_DrawSunkenEdge, METH_VARARGS | METH_KEYWORDS, NULL},
20884 { (char *)"Effects_TileBitmap", (PyCFunction) _wrap_Effects_TileBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
20885 { (char *)"Effects_swigregister", Effects_swigregister, METH_VARARGS, NULL},
20886 { NULL, NULL, 0, NULL }
20887 };
20888
20889
20890 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
20891
20892 static void *_p_wxBufferedDCTo_p_wxMemoryDC(void *x) {
20893 return (void *)((wxMemoryDC *) ((wxBufferedDC *) x));
20894 }
20895 static void *_p_wxBufferedPaintDCTo_p_wxMemoryDC(void *x) {
20896 return (void *)((wxMemoryDC *) (wxBufferedDC *) ((wxBufferedPaintDC *) x));
20897 }
20898 static void *_p_wxIconTo_p_wxGDIObject(void *x) {
20899 return (void *)((wxGDIObject *) ((wxIcon *) x));
20900 }
20901 static void *_p_wxPaletteTo_p_wxGDIObject(void *x) {
20902 return (void *)((wxGDIObject *) ((wxPalette *) x));
20903 }
20904 static void *_p_wxPenTo_p_wxGDIObject(void *x) {
20905 return (void *)((wxGDIObject *) ((wxPen *) x));
20906 }
20907 static void *_p_wxFontTo_p_wxGDIObject(void *x) {
20908 return (void *)((wxGDIObject *) ((wxFont *) x));
20909 }
20910 static void *_p_wxCursorTo_p_wxGDIObject(void *x) {
20911 return (void *)((wxGDIObject *) ((wxCursor *) x));
20912 }
20913 static void *_p_wxBitmapTo_p_wxGDIObject(void *x) {
20914 return (void *)((wxGDIObject *) ((wxBitmap *) x));
20915 }
20916 static void *_p_wxRegionTo_p_wxGDIObject(void *x) {
20917 return (void *)((wxGDIObject *) ((wxRegion *) x));
20918 }
20919 static void *_p_wxBrushTo_p_wxGDIObject(void *x) {
20920 return (void *)((wxGDIObject *) ((wxBrush *) x));
20921 }
20922 static void *_p_wxBufferedDCTo_p_wxDC(void *x) {
20923 return (void *)((wxDC *) (wxMemoryDC *) ((wxBufferedDC *) x));
20924 }
20925 static void *_p_wxScreenDCTo_p_wxDC(void *x) {
20926 return (void *)((wxDC *) ((wxScreenDC *) x));
20927 }
20928 static void *_p_wxMirrorDCTo_p_wxDC(void *x) {
20929 return (void *)((wxDC *) ((wxMirrorDC *) x));
20930 }
20931 static void *_p_wxMemoryDCTo_p_wxDC(void *x) {
20932 return (void *)((wxDC *) ((wxMemoryDC *) x));
20933 }
20934 static void *_p_wxWindowDCTo_p_wxDC(void *x) {
20935 return (void *)((wxDC *) ((wxWindowDC *) x));
20936 }
20937 static void *_p_wxMetaFileDCTo_p_wxDC(void *x) {
20938 return (void *)((wxDC *) ((wxMetaFileDC *) x));
20939 }
20940 static void *_p_wxBufferedPaintDCTo_p_wxDC(void *x) {
20941 return (void *)((wxDC *) (wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
20942 }
20943 static void *_p_wxClientDCTo_p_wxDC(void *x) {
20944 return (void *)((wxDC *) ((wxClientDC *) x));
20945 }
20946 static void *_p_wxPaintDCTo_p_wxDC(void *x) {
20947 return (void *)((wxDC *) ((wxPaintDC *) x));
20948 }
20949 static void *_p_wxPostScriptDCTo_p_wxDC(void *x) {
20950 return (void *)((wxDC *) ((wxPostScriptDC *) x));
20951 }
20952 static void *_p_wxPrinterDCTo_p_wxDC(void *x) {
20953 return (void *)((wxDC *) ((wxPrinterDC *) x));
20954 }
20955 static void *_p_wxBufferedPaintDCTo_p_wxBufferedDC(void *x) {
20956 return (void *)((wxBufferedDC *) ((wxBufferedPaintDC *) x));
20957 }
20958 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
20959 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
20960 }
20961 static void *_p_wxPenTo_p_wxObject(void *x) {
20962 return (void *)((wxObject *) (wxGDIObject *) ((wxPen *) x));
20963 }
20964 static void *_p_wxRegionIteratorTo_p_wxObject(void *x) {
20965 return (void *)((wxObject *) ((wxRegionIterator *) x));
20966 }
20967 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
20968 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
20969 }
20970 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
20971 return (void *)((wxObject *) ((wxSizerItem *) x));
20972 }
20973 static void *_p_wxColourDatabaseTo_p_wxObject(void *x) {
20974 return (void *)((wxObject *) ((wxColourDatabase *) x));
20975 }
20976 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
20977 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
20978 }
20979 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
20980 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
20981 }
20982 static void *_p_wxIconTo_p_wxObject(void *x) {
20983 return (void *)((wxObject *) (wxGDIObject *) ((wxIcon *) x));
20984 }
20985 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
20986 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
20987 }
20988 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
20989 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
20990 }
20991 static void *_p_wxSizerTo_p_wxObject(void *x) {
20992 return (void *)((wxObject *) ((wxSizer *) x));
20993 }
20994 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
20995 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
20996 }
20997 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
20998 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
20999 }
21000 static void *_p_wxPenListTo_p_wxObject(void *x) {
21001 return (void *)((wxObject *) ((wxPenList *) x));
21002 }
21003 static void *_p_wxEventTo_p_wxObject(void *x) {
21004 return (void *)((wxObject *) ((wxEvent *) x));
21005 }
21006 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
21007 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
21008 }
21009 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
21010 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
21011 }
21012 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
21013 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
21014 }
21015 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
21016 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
21017 }
21018 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
21019 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
21020 }
21021 static void *_p_wxDCTo_p_wxObject(void *x) {
21022 return (void *)((wxObject *) ((wxDC *) x));
21023 }
21024 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
21025 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
21026 }
21027 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
21028 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
21029 }
21030 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
21031 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
21032 }
21033 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
21034 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
21035 }
21036 static void *_p_wxControlTo_p_wxObject(void *x) {
21037 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
21038 }
21039 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
21040 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
21041 }
21042 static void *_p_wxClientDCTo_p_wxObject(void *x) {
21043 return (void *)((wxObject *) (wxDC *) ((wxClientDC *) x));
21044 }
21045 static void *_p_wxFSFileTo_p_wxObject(void *x) {
21046 return (void *)((wxObject *) ((wxFSFile *) x));
21047 }
21048 static void *_p_wxMemoryDCTo_p_wxObject(void *x) {
21049 return (void *)((wxObject *) (wxDC *) ((wxMemoryDC *) x));
21050 }
21051 static void *_p_wxRegionTo_p_wxObject(void *x) {
21052 return (void *)((wxObject *) (wxGDIObject *) ((wxRegion *) x));
21053 }
21054 static void *_p_wxPySizerTo_p_wxObject(void *x) {
21055 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
21056 }
21057 static void *_p_wxWindowDCTo_p_wxObject(void *x) {
21058 return (void *)((wxObject *) (wxDC *) ((wxWindowDC *) x));
21059 }
21060 static void *_p_wxGDIObjectTo_p_wxObject(void *x) {
21061 return (void *)((wxObject *) ((wxGDIObject *) x));
21062 }
21063 static void *_p_wxEffectsTo_p_wxObject(void *x) {
21064 return (void *)((wxObject *) ((wxEffects *) x));
21065 }
21066 static void *_p_wxPyEventTo_p_wxObject(void *x) {
21067 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
21068 }
21069 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
21070 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
21071 }
21072 static void *_p_wxPostScriptDCTo_p_wxObject(void *x) {
21073 return (void *)((wxObject *) (wxDC *) ((wxPostScriptDC *) x));
21074 }
21075 static void *_p_wxShowEventTo_p_wxObject(void *x) {
21076 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
21077 }
21078 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
21079 return (void *)((wxObject *) ((wxMenuItem *) x));
21080 }
21081 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
21082 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
21083 }
21084 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
21085 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
21086 }
21087 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
21088 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
21089 }
21090 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
21091 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
21092 }
21093 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
21094 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
21095 }
21096 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
21097 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
21098 }
21099 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
21100 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
21101 }
21102 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
21103 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
21104 }
21105 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
21106 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
21107 }
21108 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
21109 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
21110 }
21111 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
21112 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
21113 }
21114 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
21115 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
21116 }
21117 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
21118 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
21119 }
21120 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
21121 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
21122 }
21123 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
21124 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
21125 }
21126 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
21127 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
21128 }
21129 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
21130 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
21131 }
21132 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
21133 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
21134 }
21135 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
21136 return (void *)((wxObject *) ((wxImageHandler *) x));
21137 }
21138 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
21139 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
21140 }
21141 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
21142 return (void *)((wxObject *) ((wxEvtHandler *) x));
21143 }
21144 static void *_p_wxBufferedPaintDCTo_p_wxObject(void *x) {
21145 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *)(wxBufferedDC *) ((wxBufferedPaintDC *) x));
21146 }
21147 static void *_p_wxPaintDCTo_p_wxObject(void *x) {
21148 return (void *)((wxObject *) (wxDC *) ((wxPaintDC *) x));
21149 }
21150 static void *_p_wxPrinterDCTo_p_wxObject(void *x) {
21151 return (void *)((wxObject *) (wxDC *) ((wxPrinterDC *) x));
21152 }
21153 static void *_p_wxScreenDCTo_p_wxObject(void *x) {
21154 return (void *)((wxObject *) (wxDC *) ((wxScreenDC *) x));
21155 }
21156 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
21157 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
21158 }
21159 static void *_p_wxImageTo_p_wxObject(void *x) {
21160 return (void *)((wxObject *) ((wxImage *) x));
21161 }
21162 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
21163 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
21164 }
21165 static void *_p_wxPaletteTo_p_wxObject(void *x) {
21166 return (void *)((wxObject *) (wxGDIObject *) ((wxPalette *) x));
21167 }
21168 static void *_p_wxBufferedDCTo_p_wxObject(void *x) {
21169 return (void *)((wxObject *) (wxDC *)(wxMemoryDC *) ((wxBufferedDC *) x));
21170 }
21171 static void *_p_wxImageListTo_p_wxObject(void *x) {
21172 return (void *)((wxObject *) ((wxImageList *) x));
21173 }
21174 static void *_p_wxCursorTo_p_wxObject(void *x) {
21175 return (void *)((wxObject *) (wxGDIObject *) ((wxCursor *) x));
21176 }
21177 static void *_p_wxEncodingConverterTo_p_wxObject(void *x) {
21178 return (void *)((wxObject *) ((wxEncodingConverter *) x));
21179 }
21180 static void *_p_wxMirrorDCTo_p_wxObject(void *x) {
21181 return (void *)((wxObject *) (wxDC *) ((wxMirrorDC *) x));
21182 }
21183 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
21184 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
21185 }
21186 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
21187 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
21188 }
21189 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
21190 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
21191 }
21192 static void *_p_wxWindowTo_p_wxObject(void *x) {
21193 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
21194 }
21195 static void *_p_wxMenuTo_p_wxObject(void *x) {
21196 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
21197 }
21198 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
21199 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
21200 }
21201 static void *_p_wxMetaFileDCTo_p_wxObject(void *x) {
21202 return (void *)((wxObject *) (wxDC *) ((wxMetaFileDC *) x));
21203 }
21204 static void *_p_wxBrushListTo_p_wxObject(void *x) {
21205 return (void *)((wxObject *) ((wxBrushList *) x));
21206 }
21207 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
21208 return (void *)((wxObject *) ((wxFileSystem *) x));
21209 }
21210 static void *_p_wxBitmapTo_p_wxObject(void *x) {
21211 return (void *)((wxObject *) (wxGDIObject *) ((wxBitmap *) x));
21212 }
21213 static void *_p_wxMaskTo_p_wxObject(void *x) {
21214 return (void *)((wxObject *) ((wxMask *) x));
21215 }
21216 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
21217 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
21218 }
21219 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
21220 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
21221 }
21222 static void *_p_wxPyAppTo_p_wxObject(void *x) {
21223 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
21224 }
21225 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
21226 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
21227 }
21228 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
21229 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
21230 }
21231 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
21232 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
21233 }
21234 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
21235 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
21236 }
21237 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
21238 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
21239 }
21240 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
21241 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
21242 }
21243 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
21244 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
21245 }
21246 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
21247 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
21248 }
21249 static void *_p_wxFontTo_p_wxObject(void *x) {
21250 return (void *)((wxObject *) (wxGDIObject *) ((wxFont *) x));
21251 }
21252 static void *_p_wxBrushTo_p_wxObject(void *x) {
21253 return (void *)((wxObject *) (wxGDIObject *) ((wxBrush *) x));
21254 }
21255 static void *_p_wxMetaFileTo_p_wxObject(void *x) {
21256 return (void *)((wxObject *) ((wxMetaFile *) x));
21257 }
21258 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
21259 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
21260 }
21261 static void *_p_wxColourTo_p_wxObject(void *x) {
21262 return (void *)((wxObject *) ((wxColour *) x));
21263 }
21264 static void *_p_wxFontListTo_p_wxObject(void *x) {
21265 return (void *)((wxObject *) ((wxFontList *) x));
21266 }
21267 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
21268 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
21269 }
21270 static void *_p_wxValidatorTo_p_wxObject(void *x) {
21271 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
21272 }
21273 static void *_p_wxControlTo_p_wxWindow(void *x) {
21274 return (void *)((wxWindow *) ((wxControl *) x));
21275 }
21276 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
21277 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
21278 }
21279 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
21280 return (void *)((wxWindow *) ((wxMenuBar *) x));
21281 }
21282 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}};
21283 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}};
21284 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}};
21285 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}};
21286 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}};
21287 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}};
21288 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}};
21289 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}};
21290 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}};
21291 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}};
21292 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}};
21293 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}};
21294 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}};
21295 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}};
21296 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}};
21297 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}};
21298 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}};
21299 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}};
21300 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}};
21301 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}};
21302 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}};
21303 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}};
21304 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}};
21305 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_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_wxPCXHandler", _p_wxPCXHandlerTo_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_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_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}};
21306 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}};
21307 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}};
21308 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}};
21309 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}};
21310 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}};
21311 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}};
21312 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}};
21313 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}};
21314 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}};
21315 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}};
21316 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}};
21317 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}};
21318 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}};
21319 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}};
21320 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}};
21321 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}};
21322 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}};
21323 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}};
21324 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}};
21325 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}};
21326 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}};
21327 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}};
21328 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}};
21329 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}};
21330 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}};
21331 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}};
21332 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}};
21333 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}};
21334 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}};
21335 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}};
21336 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}};
21337 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}};
21338 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}};
21339 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}};
21340 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}};
21341 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}};
21342 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}};
21343 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}};
21344
21345 static swig_type_info *swig_types_initial[] = {
21346 _swigt__p_wxPostScriptDC,
21347 _swigt__p_wxBrush,
21348 _swigt__p_wxColour,
21349 _swigt__p_wxDC,
21350 _swigt__p_wxMirrorDC,
21351 _swigt__p_form_ops_t,
21352 _swigt__p_wxDuplexMode,
21353 _swigt__p_wxPyFontEnumerator,
21354 _swigt__p_char,
21355 _swigt__p_wxIconLocation,
21356 _swigt__p_wxImage,
21357 _swigt__p_wxMetaFileDC,
21358 _swigt__p_wxMask,
21359 _swigt__p_wxSize,
21360 _swigt__p_wxFont,
21361 _swigt__p_wxWindow,
21362 _swigt__p_double,
21363 _swigt__p_wxMemoryDC,
21364 _swigt__p_wxFontMapper,
21365 _swigt__p_wxEffects,
21366 _swigt__p_wxNativeEncodingInfo,
21367 _swigt__p_wxPalette,
21368 _swigt__p_wxBitmap,
21369 _swigt__p_wxObject,
21370 _swigt__p_wxRegionIterator,
21371 _swigt__p_wxRect,
21372 _swigt__p_wxPaperSize,
21373 _swigt__p_wxString,
21374 _swigt__unsigned_int,
21375 _swigt__p_unsigned_int,
21376 _swigt__p_wxPrinterDC,
21377 _swigt__p_wxIconBundle,
21378 _swigt__p_wxPoint,
21379 _swigt__p_wxDash,
21380 _swigt__p_wxScreenDC,
21381 _swigt__p_wxCursor,
21382 _swigt__p_wxClientDC,
21383 _swigt__p_wxBufferedDC,
21384 _swigt__p_wxImageList,
21385 _swigt__p_unsigned_char,
21386 _swigt__p_wxGDIObject,
21387 _swigt__p_wxIcon,
21388 _swigt__p_wxLocale,
21389 _swigt__ptrdiff_t,
21390 _swigt__std__ptrdiff_t,
21391 _swigt__p_wxRegion,
21392 _swigt__p_wxConfigBase,
21393 _swigt__p_wxLanguageInfo,
21394 _swigt__p_wxWindowDC,
21395 _swigt__p_wxPrintData,
21396 _swigt__p_wxBrushList,
21397 _swigt__p_wxFontList,
21398 _swigt__p_wxPen,
21399 _swigt__p_wxBufferedPaintDC,
21400 _swigt__p_wxPaintDC,
21401 _swigt__p_wxPenList,
21402 _swigt__p_int,
21403 _swigt__p_wxMetaFile,
21404 _swigt__p_unsigned_long,
21405 _swigt__p_wxNativeFontInfo,
21406 _swigt__p_wxEncodingConverter,
21407 _swigt__p_wxColourDatabase,
21408 0
21409 };
21410
21411
21412 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
21413
21414 static swig_const_info swig_const_table[] = {
21415 {0, 0, 0, 0.0, 0, 0}};
21416
21417 #ifdef __cplusplus
21418 }
21419 #endif
21420
21421
21422 #ifdef __cplusplus
21423 extern "C" {
21424 #endif
21425
21426 /* Python-specific SWIG API */
21427 #define SWIG_newvarlink() SWIG_Python_newvarlink()
21428 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
21429 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
21430
21431 /* -----------------------------------------------------------------------------
21432 * global variable support code.
21433 * ----------------------------------------------------------------------------- */
21434
21435 typedef struct swig_globalvar {
21436 char *name; /* Name of global variable */
21437 PyObject *(*get_attr)(); /* Return the current value */
21438 int (*set_attr)(PyObject *); /* Set the value */
21439 struct swig_globalvar *next;
21440 } swig_globalvar;
21441
21442 typedef struct swig_varlinkobject {
21443 PyObject_HEAD
21444 swig_globalvar *vars;
21445 } swig_varlinkobject;
21446
21447 static PyObject *
21448 swig_varlink_repr(swig_varlinkobject *v) {
21449 v = v;
21450 return PyString_FromString("<Swig global variables>");
21451 }
21452
21453 static int
21454 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
21455 swig_globalvar *var;
21456 flags = flags;
21457 fprintf(fp,"Swig global variables { ");
21458 for (var = v->vars; var; var=var->next) {
21459 fprintf(fp,"%s", var->name);
21460 if (var->next) fprintf(fp,", ");
21461 }
21462 fprintf(fp," }\n");
21463 return 0;
21464 }
21465
21466 static PyObject *
21467 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
21468 swig_globalvar *var = v->vars;
21469 while (var) {
21470 if (strcmp(var->name,n) == 0) {
21471 return (*var->get_attr)();
21472 }
21473 var = var->next;
21474 }
21475 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
21476 return NULL;
21477 }
21478
21479 static int
21480 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
21481 swig_globalvar *var = v->vars;
21482 while (var) {
21483 if (strcmp(var->name,n) == 0) {
21484 return (*var->set_attr)(p);
21485 }
21486 var = var->next;
21487 }
21488 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
21489 return 1;
21490 }
21491
21492 static PyTypeObject varlinktype = {
21493 PyObject_HEAD_INIT(0)
21494 0, /* Number of items in variable part (ob_size) */
21495 (char *)"swigvarlink", /* Type name (tp_name) */
21496 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
21497 0, /* Itemsize (tp_itemsize) */
21498 0, /* Deallocator (tp_dealloc) */
21499 (printfunc) swig_varlink_print, /* Print (tp_print) */
21500 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
21501 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
21502 0, /* tp_compare */
21503 (reprfunc) swig_varlink_repr, /* tp_repr */
21504 0, /* tp_as_number */
21505 0, /* tp_as_sequence */
21506 0, /* tp_as_mapping */
21507 0, /* tp_hash */
21508 0, /* tp_call */
21509 0, /* tp_str */
21510 0, /* tp_getattro */
21511 0, /* tp_setattro */
21512 0, /* tp_as_buffer */
21513 0, /* tp_flags */
21514 0, /* tp_doc */
21515 #if PY_VERSION_HEX >= 0x02000000
21516 0, /* tp_traverse */
21517 0, /* tp_clear */
21518 #endif
21519 #if PY_VERSION_HEX >= 0x02010000
21520 0, /* tp_richcompare */
21521 0, /* tp_weaklistoffset */
21522 #endif
21523 #if PY_VERSION_HEX >= 0x02020000
21524 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
21525 #endif
21526 #if PY_VERSION_HEX >= 0x02030000
21527 0, /* tp_del */
21528 #endif
21529 #ifdef COUNT_ALLOCS
21530 0,0,0,0 /* tp_alloc -> tp_next */
21531 #endif
21532 };
21533
21534 /* Create a variable linking object for use later */
21535 static PyObject *
21536 SWIG_Python_newvarlink(void) {
21537 swig_varlinkobject *result = 0;
21538 result = PyMem_NEW(swig_varlinkobject,1);
21539 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
21540 result->ob_type = &varlinktype;
21541 result->vars = 0;
21542 result->ob_refcnt = 0;
21543 Py_XINCREF((PyObject *) result);
21544 return ((PyObject*) result);
21545 }
21546
21547 static void
21548 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
21549 swig_varlinkobject *v;
21550 swig_globalvar *gv;
21551 v= (swig_varlinkobject *) p;
21552 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
21553 gv->name = (char *) malloc(strlen(name)+1);
21554 strcpy(gv->name,name);
21555 gv->get_attr = get_attr;
21556 gv->set_attr = set_attr;
21557 gv->next = v->vars;
21558 v->vars = gv;
21559 }
21560
21561 /* -----------------------------------------------------------------------------
21562 * constants/methods manipulation
21563 * ----------------------------------------------------------------------------- */
21564
21565 /* Install Constants */
21566 static void
21567 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
21568 PyObject *obj = 0;
21569 size_t i;
21570 for (i = 0; constants[i].type; i++) {
21571 switch(constants[i].type) {
21572 case SWIG_PY_INT:
21573 obj = PyInt_FromLong(constants[i].lvalue);
21574 break;
21575 case SWIG_PY_FLOAT:
21576 obj = PyFloat_FromDouble(constants[i].dvalue);
21577 break;
21578 case SWIG_PY_STRING:
21579 if (constants[i].pvalue) {
21580 obj = PyString_FromString((char *) constants[i].pvalue);
21581 } else {
21582 Py_INCREF(Py_None);
21583 obj = Py_None;
21584 }
21585 break;
21586 case SWIG_PY_POINTER:
21587 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
21588 break;
21589 case SWIG_PY_BINARY:
21590 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
21591 break;
21592 default:
21593 obj = 0;
21594 break;
21595 }
21596 if (obj) {
21597 PyDict_SetItemString(d,constants[i].name,obj);
21598 Py_DECREF(obj);
21599 }
21600 }
21601 }
21602
21603 /* -----------------------------------------------------------------------------*/
21604 /* Fix SwigMethods to carry the callback ptrs when needed */
21605 /* -----------------------------------------------------------------------------*/
21606
21607 static void
21608 SWIG_Python_FixMethods(PyMethodDef *methods,
21609 swig_const_info *const_table,
21610 swig_type_info **types,
21611 swig_type_info **types_initial) {
21612 size_t i;
21613 for (i = 0; methods[i].ml_name; ++i) {
21614 char *c = methods[i].ml_doc;
21615 if (c && (c = strstr(c, "swig_ptr: "))) {
21616 int j;
21617 swig_const_info *ci = 0;
21618 char *name = c + 10;
21619 for (j = 0; const_table[j].type; j++) {
21620 if (strncmp(const_table[j].name, name,
21621 strlen(const_table[j].name)) == 0) {
21622 ci = &(const_table[j]);
21623 break;
21624 }
21625 }
21626 if (ci) {
21627 size_t shift = (ci->ptype) - types;
21628 swig_type_info *ty = types_initial[shift];
21629 size_t ldoc = (c - methods[i].ml_doc);
21630 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
21631 char *ndoc = (char*)malloc(ldoc + lptr + 10);
21632 char *buff = ndoc;
21633 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
21634 strncpy(buff, methods[i].ml_doc, ldoc);
21635 buff += ldoc;
21636 strncpy(buff, "swig_ptr: ", 10);
21637 buff += 10;
21638 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
21639 methods[i].ml_doc = ndoc;
21640 }
21641 }
21642 }
21643 }
21644
21645 /* -----------------------------------------------------------------------------*
21646 * Initialize type list
21647 * -----------------------------------------------------------------------------*/
21648
21649 #if PY_MAJOR_VERSION < 2
21650 /* PyModule_AddObject function was introduced in Python 2.0. The following function
21651 is copied out of Python/modsupport.c in python version 2.3.4 */
21652 static int
21653 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
21654 {
21655 PyObject *dict;
21656 if (!PyModule_Check(m)) {
21657 PyErr_SetString(PyExc_TypeError,
21658 "PyModule_AddObject() needs module as first arg");
21659 return -1;
21660 }
21661 if (!o) {
21662 PyErr_SetString(PyExc_TypeError,
21663 "PyModule_AddObject() needs non-NULL value");
21664 return -1;
21665 }
21666
21667 dict = PyModule_GetDict(m);
21668 if (dict == NULL) {
21669 /* Internal error -- modules must have a dict! */
21670 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
21671 PyModule_GetName(m));
21672 return -1;
21673 }
21674 if (PyDict_SetItemString(dict, name, o))
21675 return -1;
21676 Py_DECREF(o);
21677 return 0;
21678 }
21679 #endif
21680
21681 static swig_type_info **
21682 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
21683 static PyMethodDef swig_empty_runtime_method_table[] = {
21684 {
21685 NULL, NULL, 0, NULL
21686 }
21687 };/* Sentinel */
21688
21689 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
21690 swig_empty_runtime_method_table);
21691 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
21692 if (pointer && module) {
21693 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
21694 }
21695 return type_list_handle;
21696 }
21697
21698 static swig_type_info **
21699 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
21700 swig_type_info **type_pointer;
21701
21702 /* first check if module already created */
21703 type_pointer = SWIG_Python_GetTypeListHandle();
21704 if (type_pointer) {
21705 return type_pointer;
21706 } else {
21707 /* create a new module and variable */
21708 return SWIG_Python_SetTypeListHandle(type_list_handle);
21709 }
21710 }
21711
21712 #ifdef __cplusplus
21713 }
21714 #endif
21715
21716 /* -----------------------------------------------------------------------------*
21717 * Partial Init method
21718 * -----------------------------------------------------------------------------*/
21719
21720 #ifdef SWIG_LINK_RUNTIME
21721 #ifdef __cplusplus
21722 extern "C"
21723 #endif
21724 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
21725 #endif
21726
21727 #ifdef __cplusplus
21728 extern "C"
21729 #endif
21730 SWIGEXPORT(void) SWIG_init(void) {
21731 static PyObject *SWIG_globals = 0;
21732 static int typeinit = 0;
21733 PyObject *m, *d;
21734 int i;
21735 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
21736
21737 /* Fix SwigMethods to carry the callback ptrs when needed */
21738 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
21739
21740 m = Py_InitModule((char *) SWIG_name, SwigMethods);
21741 d = PyModule_GetDict(m);
21742
21743 if (!typeinit) {
21744 #ifdef SWIG_LINK_RUNTIME
21745 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
21746 #else
21747 # ifndef SWIG_STATIC_RUNTIME
21748 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
21749 # endif
21750 #endif
21751 for (i = 0; swig_types_initial[i]; i++) {
21752 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
21753 }
21754 typeinit = 1;
21755 }
21756 SWIG_InstallConstants(d,swig_const_table);
21757
21758 {
21759 PyDict_SetItemString(d,"OutRegion", SWIG_From_int((int)(wxOutRegion)));
21760 }
21761 {
21762 PyDict_SetItemString(d,"PartRegion", SWIG_From_int((int)(wxPartRegion)));
21763 }
21764 {
21765 PyDict_SetItemString(d,"InRegion", SWIG_From_int((int)(wxInRegion)));
21766 }
21767 {
21768 PyDict_SetItemString(d,"FONTFAMILY_DEFAULT", SWIG_From_int((int)(wxFONTFAMILY_DEFAULT)));
21769 }
21770 {
21771 PyDict_SetItemString(d,"FONTFAMILY_DECORATIVE", SWIG_From_int((int)(wxFONTFAMILY_DECORATIVE)));
21772 }
21773 {
21774 PyDict_SetItemString(d,"FONTFAMILY_ROMAN", SWIG_From_int((int)(wxFONTFAMILY_ROMAN)));
21775 }
21776 {
21777 PyDict_SetItemString(d,"FONTFAMILY_SCRIPT", SWIG_From_int((int)(wxFONTFAMILY_SCRIPT)));
21778 }
21779 {
21780 PyDict_SetItemString(d,"FONTFAMILY_SWISS", SWIG_From_int((int)(wxFONTFAMILY_SWISS)));
21781 }
21782 {
21783 PyDict_SetItemString(d,"FONTFAMILY_MODERN", SWIG_From_int((int)(wxFONTFAMILY_MODERN)));
21784 }
21785 {
21786 PyDict_SetItemString(d,"FONTFAMILY_TELETYPE", SWIG_From_int((int)(wxFONTFAMILY_TELETYPE)));
21787 }
21788 {
21789 PyDict_SetItemString(d,"FONTFAMILY_MAX", SWIG_From_int((int)(wxFONTFAMILY_MAX)));
21790 }
21791 {
21792 PyDict_SetItemString(d,"FONTFAMILY_UNKNOWN", SWIG_From_int((int)(wxFONTFAMILY_UNKNOWN)));
21793 }
21794 {
21795 PyDict_SetItemString(d,"FONTSTYLE_NORMAL", SWIG_From_int((int)(wxFONTSTYLE_NORMAL)));
21796 }
21797 {
21798 PyDict_SetItemString(d,"FONTSTYLE_ITALIC", SWIG_From_int((int)(wxFONTSTYLE_ITALIC)));
21799 }
21800 {
21801 PyDict_SetItemString(d,"FONTSTYLE_SLANT", SWIG_From_int((int)(wxFONTSTYLE_SLANT)));
21802 }
21803 {
21804 PyDict_SetItemString(d,"FONTSTYLE_MAX", SWIG_From_int((int)(wxFONTSTYLE_MAX)));
21805 }
21806 {
21807 PyDict_SetItemString(d,"FONTWEIGHT_NORMAL", SWIG_From_int((int)(wxFONTWEIGHT_NORMAL)));
21808 }
21809 {
21810 PyDict_SetItemString(d,"FONTWEIGHT_LIGHT", SWIG_From_int((int)(wxFONTWEIGHT_LIGHT)));
21811 }
21812 {
21813 PyDict_SetItemString(d,"FONTWEIGHT_BOLD", SWIG_From_int((int)(wxFONTWEIGHT_BOLD)));
21814 }
21815 {
21816 PyDict_SetItemString(d,"FONTWEIGHT_MAX", SWIG_From_int((int)(wxFONTWEIGHT_MAX)));
21817 }
21818 {
21819 PyDict_SetItemString(d,"FONTFLAG_DEFAULT", SWIG_From_int((int)(wxFONTFLAG_DEFAULT)));
21820 }
21821 {
21822 PyDict_SetItemString(d,"FONTFLAG_ITALIC", SWIG_From_int((int)(wxFONTFLAG_ITALIC)));
21823 }
21824 {
21825 PyDict_SetItemString(d,"FONTFLAG_SLANT", SWIG_From_int((int)(wxFONTFLAG_SLANT)));
21826 }
21827 {
21828 PyDict_SetItemString(d,"FONTFLAG_LIGHT", SWIG_From_int((int)(wxFONTFLAG_LIGHT)));
21829 }
21830 {
21831 PyDict_SetItemString(d,"FONTFLAG_BOLD", SWIG_From_int((int)(wxFONTFLAG_BOLD)));
21832 }
21833 {
21834 PyDict_SetItemString(d,"FONTFLAG_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_ANTIALIASED)));
21835 }
21836 {
21837 PyDict_SetItemString(d,"FONTFLAG_NOT_ANTIALIASED", SWIG_From_int((int)(wxFONTFLAG_NOT_ANTIALIASED)));
21838 }
21839 {
21840 PyDict_SetItemString(d,"FONTFLAG_UNDERLINED", SWIG_From_int((int)(wxFONTFLAG_UNDERLINED)));
21841 }
21842 {
21843 PyDict_SetItemString(d,"FONTFLAG_STRIKETHROUGH", SWIG_From_int((int)(wxFONTFLAG_STRIKETHROUGH)));
21844 }
21845 {
21846 PyDict_SetItemString(d,"FONTFLAG_MASK", SWIG_From_int((int)(wxFONTFLAG_MASK)));
21847 }
21848 {
21849 PyDict_SetItemString(d,"FONTENCODING_SYSTEM", SWIG_From_int((int)(wxFONTENCODING_SYSTEM)));
21850 }
21851 {
21852 PyDict_SetItemString(d,"FONTENCODING_DEFAULT", SWIG_From_int((int)(wxFONTENCODING_DEFAULT)));
21853 }
21854 {
21855 PyDict_SetItemString(d,"FONTENCODING_ISO8859_1", SWIG_From_int((int)(wxFONTENCODING_ISO8859_1)));
21856 }
21857 {
21858 PyDict_SetItemString(d,"FONTENCODING_ISO8859_2", SWIG_From_int((int)(wxFONTENCODING_ISO8859_2)));
21859 }
21860 {
21861 PyDict_SetItemString(d,"FONTENCODING_ISO8859_3", SWIG_From_int((int)(wxFONTENCODING_ISO8859_3)));
21862 }
21863 {
21864 PyDict_SetItemString(d,"FONTENCODING_ISO8859_4", SWIG_From_int((int)(wxFONTENCODING_ISO8859_4)));
21865 }
21866 {
21867 PyDict_SetItemString(d,"FONTENCODING_ISO8859_5", SWIG_From_int((int)(wxFONTENCODING_ISO8859_5)));
21868 }
21869 {
21870 PyDict_SetItemString(d,"FONTENCODING_ISO8859_6", SWIG_From_int((int)(wxFONTENCODING_ISO8859_6)));
21871 }
21872 {
21873 PyDict_SetItemString(d,"FONTENCODING_ISO8859_7", SWIG_From_int((int)(wxFONTENCODING_ISO8859_7)));
21874 }
21875 {
21876 PyDict_SetItemString(d,"FONTENCODING_ISO8859_8", SWIG_From_int((int)(wxFONTENCODING_ISO8859_8)));
21877 }
21878 {
21879 PyDict_SetItemString(d,"FONTENCODING_ISO8859_9", SWIG_From_int((int)(wxFONTENCODING_ISO8859_9)));
21880 }
21881 {
21882 PyDict_SetItemString(d,"FONTENCODING_ISO8859_10", SWIG_From_int((int)(wxFONTENCODING_ISO8859_10)));
21883 }
21884 {
21885 PyDict_SetItemString(d,"FONTENCODING_ISO8859_11", SWIG_From_int((int)(wxFONTENCODING_ISO8859_11)));
21886 }
21887 {
21888 PyDict_SetItemString(d,"FONTENCODING_ISO8859_12", SWIG_From_int((int)(wxFONTENCODING_ISO8859_12)));
21889 }
21890 {
21891 PyDict_SetItemString(d,"FONTENCODING_ISO8859_13", SWIG_From_int((int)(wxFONTENCODING_ISO8859_13)));
21892 }
21893 {
21894 PyDict_SetItemString(d,"FONTENCODING_ISO8859_14", SWIG_From_int((int)(wxFONTENCODING_ISO8859_14)));
21895 }
21896 {
21897 PyDict_SetItemString(d,"FONTENCODING_ISO8859_15", SWIG_From_int((int)(wxFONTENCODING_ISO8859_15)));
21898 }
21899 {
21900 PyDict_SetItemString(d,"FONTENCODING_ISO8859_MAX", SWIG_From_int((int)(wxFONTENCODING_ISO8859_MAX)));
21901 }
21902 {
21903 PyDict_SetItemString(d,"FONTENCODING_KOI8", SWIG_From_int((int)(wxFONTENCODING_KOI8)));
21904 }
21905 {
21906 PyDict_SetItemString(d,"FONTENCODING_KOI8_U", SWIG_From_int((int)(wxFONTENCODING_KOI8_U)));
21907 }
21908 {
21909 PyDict_SetItemString(d,"FONTENCODING_ALTERNATIVE", SWIG_From_int((int)(wxFONTENCODING_ALTERNATIVE)));
21910 }
21911 {
21912 PyDict_SetItemString(d,"FONTENCODING_BULGARIAN", SWIG_From_int((int)(wxFONTENCODING_BULGARIAN)));
21913 }
21914 {
21915 PyDict_SetItemString(d,"FONTENCODING_CP437", SWIG_From_int((int)(wxFONTENCODING_CP437)));
21916 }
21917 {
21918 PyDict_SetItemString(d,"FONTENCODING_CP850", SWIG_From_int((int)(wxFONTENCODING_CP850)));
21919 }
21920 {
21921 PyDict_SetItemString(d,"FONTENCODING_CP852", SWIG_From_int((int)(wxFONTENCODING_CP852)));
21922 }
21923 {
21924 PyDict_SetItemString(d,"FONTENCODING_CP855", SWIG_From_int((int)(wxFONTENCODING_CP855)));
21925 }
21926 {
21927 PyDict_SetItemString(d,"FONTENCODING_CP866", SWIG_From_int((int)(wxFONTENCODING_CP866)));
21928 }
21929 {
21930 PyDict_SetItemString(d,"FONTENCODING_CP874", SWIG_From_int((int)(wxFONTENCODING_CP874)));
21931 }
21932 {
21933 PyDict_SetItemString(d,"FONTENCODING_CP932", SWIG_From_int((int)(wxFONTENCODING_CP932)));
21934 }
21935 {
21936 PyDict_SetItemString(d,"FONTENCODING_CP936", SWIG_From_int((int)(wxFONTENCODING_CP936)));
21937 }
21938 {
21939 PyDict_SetItemString(d,"FONTENCODING_CP949", SWIG_From_int((int)(wxFONTENCODING_CP949)));
21940 }
21941 {
21942 PyDict_SetItemString(d,"FONTENCODING_CP950", SWIG_From_int((int)(wxFONTENCODING_CP950)));
21943 }
21944 {
21945 PyDict_SetItemString(d,"FONTENCODING_CP1250", SWIG_From_int((int)(wxFONTENCODING_CP1250)));
21946 }
21947 {
21948 PyDict_SetItemString(d,"FONTENCODING_CP1251", SWIG_From_int((int)(wxFONTENCODING_CP1251)));
21949 }
21950 {
21951 PyDict_SetItemString(d,"FONTENCODING_CP1252", SWIG_From_int((int)(wxFONTENCODING_CP1252)));
21952 }
21953 {
21954 PyDict_SetItemString(d,"FONTENCODING_CP1253", SWIG_From_int((int)(wxFONTENCODING_CP1253)));
21955 }
21956 {
21957 PyDict_SetItemString(d,"FONTENCODING_CP1254", SWIG_From_int((int)(wxFONTENCODING_CP1254)));
21958 }
21959 {
21960 PyDict_SetItemString(d,"FONTENCODING_CP1255", SWIG_From_int((int)(wxFONTENCODING_CP1255)));
21961 }
21962 {
21963 PyDict_SetItemString(d,"FONTENCODING_CP1256", SWIG_From_int((int)(wxFONTENCODING_CP1256)));
21964 }
21965 {
21966 PyDict_SetItemString(d,"FONTENCODING_CP1257", SWIG_From_int((int)(wxFONTENCODING_CP1257)));
21967 }
21968 {
21969 PyDict_SetItemString(d,"FONTENCODING_CP12_MAX", SWIG_From_int((int)(wxFONTENCODING_CP12_MAX)));
21970 }
21971 {
21972 PyDict_SetItemString(d,"FONTENCODING_UTF7", SWIG_From_int((int)(wxFONTENCODING_UTF7)));
21973 }
21974 {
21975 PyDict_SetItemString(d,"FONTENCODING_UTF8", SWIG_From_int((int)(wxFONTENCODING_UTF8)));
21976 }
21977 {
21978 PyDict_SetItemString(d,"FONTENCODING_EUC_JP", SWIG_From_int((int)(wxFONTENCODING_EUC_JP)));
21979 }
21980 {
21981 PyDict_SetItemString(d,"FONTENCODING_UTF16BE", SWIG_From_int((int)(wxFONTENCODING_UTF16BE)));
21982 }
21983 {
21984 PyDict_SetItemString(d,"FONTENCODING_UTF16LE", SWIG_From_int((int)(wxFONTENCODING_UTF16LE)));
21985 }
21986 {
21987 PyDict_SetItemString(d,"FONTENCODING_UTF32BE", SWIG_From_int((int)(wxFONTENCODING_UTF32BE)));
21988 }
21989 {
21990 PyDict_SetItemString(d,"FONTENCODING_UTF32LE", SWIG_From_int((int)(wxFONTENCODING_UTF32LE)));
21991 }
21992 {
21993 PyDict_SetItemString(d,"FONTENCODING_MACROMAN", SWIG_From_int((int)(wxFONTENCODING_MACROMAN)));
21994 }
21995 {
21996 PyDict_SetItemString(d,"FONTENCODING_MACJAPANESE", SWIG_From_int((int)(wxFONTENCODING_MACJAPANESE)));
21997 }
21998 {
21999 PyDict_SetItemString(d,"FONTENCODING_MACCHINESETRAD", SWIG_From_int((int)(wxFONTENCODING_MACCHINESETRAD)));
22000 }
22001 {
22002 PyDict_SetItemString(d,"FONTENCODING_MACKOREAN", SWIG_From_int((int)(wxFONTENCODING_MACKOREAN)));
22003 }
22004 {
22005 PyDict_SetItemString(d,"FONTENCODING_MACARABIC", SWIG_From_int((int)(wxFONTENCODING_MACARABIC)));
22006 }
22007 {
22008 PyDict_SetItemString(d,"FONTENCODING_MACHEBREW", SWIG_From_int((int)(wxFONTENCODING_MACHEBREW)));
22009 }
22010 {
22011 PyDict_SetItemString(d,"FONTENCODING_MACGREEK", SWIG_From_int((int)(wxFONTENCODING_MACGREEK)));
22012 }
22013 {
22014 PyDict_SetItemString(d,"FONTENCODING_MACCYRILLIC", SWIG_From_int((int)(wxFONTENCODING_MACCYRILLIC)));
22015 }
22016 {
22017 PyDict_SetItemString(d,"FONTENCODING_MACDEVANAGARI", SWIG_From_int((int)(wxFONTENCODING_MACDEVANAGARI)));
22018 }
22019 {
22020 PyDict_SetItemString(d,"FONTENCODING_MACGURMUKHI", SWIG_From_int((int)(wxFONTENCODING_MACGURMUKHI)));
22021 }
22022 {
22023 PyDict_SetItemString(d,"FONTENCODING_MACGUJARATI", SWIG_From_int((int)(wxFONTENCODING_MACGUJARATI)));
22024 }
22025 {
22026 PyDict_SetItemString(d,"FONTENCODING_MACORIYA", SWIG_From_int((int)(wxFONTENCODING_MACORIYA)));
22027 }
22028 {
22029 PyDict_SetItemString(d,"FONTENCODING_MACBENGALI", SWIG_From_int((int)(wxFONTENCODING_MACBENGALI)));
22030 }
22031 {
22032 PyDict_SetItemString(d,"FONTENCODING_MACTAMIL", SWIG_From_int((int)(wxFONTENCODING_MACTAMIL)));
22033 }
22034 {
22035 PyDict_SetItemString(d,"FONTENCODING_MACTELUGU", SWIG_From_int((int)(wxFONTENCODING_MACTELUGU)));
22036 }
22037 {
22038 PyDict_SetItemString(d,"FONTENCODING_MACKANNADA", SWIG_From_int((int)(wxFONTENCODING_MACKANNADA)));
22039 }
22040 {
22041 PyDict_SetItemString(d,"FONTENCODING_MACMALAJALAM", SWIG_From_int((int)(wxFONTENCODING_MACMALAJALAM)));
22042 }
22043 {
22044 PyDict_SetItemString(d,"FONTENCODING_MACSINHALESE", SWIG_From_int((int)(wxFONTENCODING_MACSINHALESE)));
22045 }
22046 {
22047 PyDict_SetItemString(d,"FONTENCODING_MACBURMESE", SWIG_From_int((int)(wxFONTENCODING_MACBURMESE)));
22048 }
22049 {
22050 PyDict_SetItemString(d,"FONTENCODING_MACKHMER", SWIG_From_int((int)(wxFONTENCODING_MACKHMER)));
22051 }
22052 {
22053 PyDict_SetItemString(d,"FONTENCODING_MACTHAI", SWIG_From_int((int)(wxFONTENCODING_MACTHAI)));
22054 }
22055 {
22056 PyDict_SetItemString(d,"FONTENCODING_MACLAOTIAN", SWIG_From_int((int)(wxFONTENCODING_MACLAOTIAN)));
22057 }
22058 {
22059 PyDict_SetItemString(d,"FONTENCODING_MACGEORGIAN", SWIG_From_int((int)(wxFONTENCODING_MACGEORGIAN)));
22060 }
22061 {
22062 PyDict_SetItemString(d,"FONTENCODING_MACARMENIAN", SWIG_From_int((int)(wxFONTENCODING_MACARMENIAN)));
22063 }
22064 {
22065 PyDict_SetItemString(d,"FONTENCODING_MACCHINESESIMP", SWIG_From_int((int)(wxFONTENCODING_MACCHINESESIMP)));
22066 }
22067 {
22068 PyDict_SetItemString(d,"FONTENCODING_MACTIBETAN", SWIG_From_int((int)(wxFONTENCODING_MACTIBETAN)));
22069 }
22070 {
22071 PyDict_SetItemString(d,"FONTENCODING_MACMONGOLIAN", SWIG_From_int((int)(wxFONTENCODING_MACMONGOLIAN)));
22072 }
22073 {
22074 PyDict_SetItemString(d,"FONTENCODING_MACETHIOPIC", SWIG_From_int((int)(wxFONTENCODING_MACETHIOPIC)));
22075 }
22076 {
22077 PyDict_SetItemString(d,"FONTENCODING_MACCENTRALEUR", SWIG_From_int((int)(wxFONTENCODING_MACCENTRALEUR)));
22078 }
22079 {
22080 PyDict_SetItemString(d,"FONTENCODING_MACVIATNAMESE", SWIG_From_int((int)(wxFONTENCODING_MACVIATNAMESE)));
22081 }
22082 {
22083 PyDict_SetItemString(d,"FONTENCODING_MACARABICEXT", SWIG_From_int((int)(wxFONTENCODING_MACARABICEXT)));
22084 }
22085 {
22086 PyDict_SetItemString(d,"FONTENCODING_MACSYMBOL", SWIG_From_int((int)(wxFONTENCODING_MACSYMBOL)));
22087 }
22088 {
22089 PyDict_SetItemString(d,"FONTENCODING_MACDINGBATS", SWIG_From_int((int)(wxFONTENCODING_MACDINGBATS)));
22090 }
22091 {
22092 PyDict_SetItemString(d,"FONTENCODING_MACTURKISH", SWIG_From_int((int)(wxFONTENCODING_MACTURKISH)));
22093 }
22094 {
22095 PyDict_SetItemString(d,"FONTENCODING_MACCROATIAN", SWIG_From_int((int)(wxFONTENCODING_MACCROATIAN)));
22096 }
22097 {
22098 PyDict_SetItemString(d,"FONTENCODING_MACICELANDIC", SWIG_From_int((int)(wxFONTENCODING_MACICELANDIC)));
22099 }
22100 {
22101 PyDict_SetItemString(d,"FONTENCODING_MACROMANIAN", SWIG_From_int((int)(wxFONTENCODING_MACROMANIAN)));
22102 }
22103 {
22104 PyDict_SetItemString(d,"FONTENCODING_MACCELTIC", SWIG_From_int((int)(wxFONTENCODING_MACCELTIC)));
22105 }
22106 {
22107 PyDict_SetItemString(d,"FONTENCODING_MACGAELIC", SWIG_From_int((int)(wxFONTENCODING_MACGAELIC)));
22108 }
22109 {
22110 PyDict_SetItemString(d,"FONTENCODING_MACKEYBOARD", SWIG_From_int((int)(wxFONTENCODING_MACKEYBOARD)));
22111 }
22112 {
22113 PyDict_SetItemString(d,"FONTENCODING_MACMIN", SWIG_From_int((int)(wxFONTENCODING_MACMIN)));
22114 }
22115 {
22116 PyDict_SetItemString(d,"FONTENCODING_MACMAX", SWIG_From_int((int)(wxFONTENCODING_MACMAX)));
22117 }
22118 {
22119 PyDict_SetItemString(d,"FONTENCODING_MAX", SWIG_From_int((int)(wxFONTENCODING_MAX)));
22120 }
22121 {
22122 PyDict_SetItemString(d,"FONTENCODING_UTF16", SWIG_From_int((int)(wxFONTENCODING_UTF16)));
22123 }
22124 {
22125 PyDict_SetItemString(d,"FONTENCODING_UTF32", SWIG_From_int((int)(wxFONTENCODING_UTF32)));
22126 }
22127 {
22128 PyDict_SetItemString(d,"FONTENCODING_UNICODE", SWIG_From_int((int)(wxFONTENCODING_UNICODE)));
22129 }
22130 {
22131 PyDict_SetItemString(d,"FONTENCODING_GB2312", SWIG_From_int((int)(wxFONTENCODING_GB2312)));
22132 }
22133 {
22134 PyDict_SetItemString(d,"FONTENCODING_BIG5", SWIG_From_int((int)(wxFONTENCODING_BIG5)));
22135 }
22136 {
22137 PyDict_SetItemString(d,"FONTENCODING_SHIFT_JIS", SWIG_From_int((int)(wxFONTENCODING_SHIFT_JIS)));
22138 }
22139
22140 wxPyPtrTypeMap_Add("wxFontEnumerator", "wxPyFontEnumerator");
22141
22142 {
22143 PyDict_SetItemString(d,"LANGUAGE_DEFAULT", SWIG_From_int((int)(wxLANGUAGE_DEFAULT)));
22144 }
22145 {
22146 PyDict_SetItemString(d,"LANGUAGE_UNKNOWN", SWIG_From_int((int)(wxLANGUAGE_UNKNOWN)));
22147 }
22148 {
22149 PyDict_SetItemString(d,"LANGUAGE_ABKHAZIAN", SWIG_From_int((int)(wxLANGUAGE_ABKHAZIAN)));
22150 }
22151 {
22152 PyDict_SetItemString(d,"LANGUAGE_AFAR", SWIG_From_int((int)(wxLANGUAGE_AFAR)));
22153 }
22154 {
22155 PyDict_SetItemString(d,"LANGUAGE_AFRIKAANS", SWIG_From_int((int)(wxLANGUAGE_AFRIKAANS)));
22156 }
22157 {
22158 PyDict_SetItemString(d,"LANGUAGE_ALBANIAN", SWIG_From_int((int)(wxLANGUAGE_ALBANIAN)));
22159 }
22160 {
22161 PyDict_SetItemString(d,"LANGUAGE_AMHARIC", SWIG_From_int((int)(wxLANGUAGE_AMHARIC)));
22162 }
22163 {
22164 PyDict_SetItemString(d,"LANGUAGE_ARABIC", SWIG_From_int((int)(wxLANGUAGE_ARABIC)));
22165 }
22166 {
22167 PyDict_SetItemString(d,"LANGUAGE_ARABIC_ALGERIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_ALGERIA)));
22168 }
22169 {
22170 PyDict_SetItemString(d,"LANGUAGE_ARABIC_BAHRAIN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_BAHRAIN)));
22171 }
22172 {
22173 PyDict_SetItemString(d,"LANGUAGE_ARABIC_EGYPT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_EGYPT)));
22174 }
22175 {
22176 PyDict_SetItemString(d,"LANGUAGE_ARABIC_IRAQ", SWIG_From_int((int)(wxLANGUAGE_ARABIC_IRAQ)));
22177 }
22178 {
22179 PyDict_SetItemString(d,"LANGUAGE_ARABIC_JORDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_JORDAN)));
22180 }
22181 {
22182 PyDict_SetItemString(d,"LANGUAGE_ARABIC_KUWAIT", SWIG_From_int((int)(wxLANGUAGE_ARABIC_KUWAIT)));
22183 }
22184 {
22185 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LEBANON", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LEBANON)));
22186 }
22187 {
22188 PyDict_SetItemString(d,"LANGUAGE_ARABIC_LIBYA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_LIBYA)));
22189 }
22190 {
22191 PyDict_SetItemString(d,"LANGUAGE_ARABIC_MOROCCO", SWIG_From_int((int)(wxLANGUAGE_ARABIC_MOROCCO)));
22192 }
22193 {
22194 PyDict_SetItemString(d,"LANGUAGE_ARABIC_OMAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_OMAN)));
22195 }
22196 {
22197 PyDict_SetItemString(d,"LANGUAGE_ARABIC_QATAR", SWIG_From_int((int)(wxLANGUAGE_ARABIC_QATAR)));
22198 }
22199 {
22200 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SAUDI_ARABIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SAUDI_ARABIA)));
22201 }
22202 {
22203 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SUDAN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SUDAN)));
22204 }
22205 {
22206 PyDict_SetItemString(d,"LANGUAGE_ARABIC_SYRIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_SYRIA)));
22207 }
22208 {
22209 PyDict_SetItemString(d,"LANGUAGE_ARABIC_TUNISIA", SWIG_From_int((int)(wxLANGUAGE_ARABIC_TUNISIA)));
22210 }
22211 {
22212 PyDict_SetItemString(d,"LANGUAGE_ARABIC_UAE", SWIG_From_int((int)(wxLANGUAGE_ARABIC_UAE)));
22213 }
22214 {
22215 PyDict_SetItemString(d,"LANGUAGE_ARABIC_YEMEN", SWIG_From_int((int)(wxLANGUAGE_ARABIC_YEMEN)));
22216 }
22217 {
22218 PyDict_SetItemString(d,"LANGUAGE_ARMENIAN", SWIG_From_int((int)(wxLANGUAGE_ARMENIAN)));
22219 }
22220 {
22221 PyDict_SetItemString(d,"LANGUAGE_ASSAMESE", SWIG_From_int((int)(wxLANGUAGE_ASSAMESE)));
22222 }
22223 {
22224 PyDict_SetItemString(d,"LANGUAGE_AYMARA", SWIG_From_int((int)(wxLANGUAGE_AYMARA)));
22225 }
22226 {
22227 PyDict_SetItemString(d,"LANGUAGE_AZERI", SWIG_From_int((int)(wxLANGUAGE_AZERI)));
22228 }
22229 {
22230 PyDict_SetItemString(d,"LANGUAGE_AZERI_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_AZERI_CYRILLIC)));
22231 }
22232 {
22233 PyDict_SetItemString(d,"LANGUAGE_AZERI_LATIN", SWIG_From_int((int)(wxLANGUAGE_AZERI_LATIN)));
22234 }
22235 {
22236 PyDict_SetItemString(d,"LANGUAGE_BASHKIR", SWIG_From_int((int)(wxLANGUAGE_BASHKIR)));
22237 }
22238 {
22239 PyDict_SetItemString(d,"LANGUAGE_BASQUE", SWIG_From_int((int)(wxLANGUAGE_BASQUE)));
22240 }
22241 {
22242 PyDict_SetItemString(d,"LANGUAGE_BELARUSIAN", SWIG_From_int((int)(wxLANGUAGE_BELARUSIAN)));
22243 }
22244 {
22245 PyDict_SetItemString(d,"LANGUAGE_BENGALI", SWIG_From_int((int)(wxLANGUAGE_BENGALI)));
22246 }
22247 {
22248 PyDict_SetItemString(d,"LANGUAGE_BHUTANI", SWIG_From_int((int)(wxLANGUAGE_BHUTANI)));
22249 }
22250 {
22251 PyDict_SetItemString(d,"LANGUAGE_BIHARI", SWIG_From_int((int)(wxLANGUAGE_BIHARI)));
22252 }
22253 {
22254 PyDict_SetItemString(d,"LANGUAGE_BISLAMA", SWIG_From_int((int)(wxLANGUAGE_BISLAMA)));
22255 }
22256 {
22257 PyDict_SetItemString(d,"LANGUAGE_BRETON", SWIG_From_int((int)(wxLANGUAGE_BRETON)));
22258 }
22259 {
22260 PyDict_SetItemString(d,"LANGUAGE_BULGARIAN", SWIG_From_int((int)(wxLANGUAGE_BULGARIAN)));
22261 }
22262 {
22263 PyDict_SetItemString(d,"LANGUAGE_BURMESE", SWIG_From_int((int)(wxLANGUAGE_BURMESE)));
22264 }
22265 {
22266 PyDict_SetItemString(d,"LANGUAGE_CAMBODIAN", SWIG_From_int((int)(wxLANGUAGE_CAMBODIAN)));
22267 }
22268 {
22269 PyDict_SetItemString(d,"LANGUAGE_CATALAN", SWIG_From_int((int)(wxLANGUAGE_CATALAN)));
22270 }
22271 {
22272 PyDict_SetItemString(d,"LANGUAGE_CHINESE", SWIG_From_int((int)(wxLANGUAGE_CHINESE)));
22273 }
22274 {
22275 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SIMPLIFIED", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SIMPLIFIED)));
22276 }
22277 {
22278 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TRADITIONAL", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TRADITIONAL)));
22279 }
22280 {
22281 PyDict_SetItemString(d,"LANGUAGE_CHINESE_HONGKONG", SWIG_From_int((int)(wxLANGUAGE_CHINESE_HONGKONG)));
22282 }
22283 {
22284 PyDict_SetItemString(d,"LANGUAGE_CHINESE_MACAU", SWIG_From_int((int)(wxLANGUAGE_CHINESE_MACAU)));
22285 }
22286 {
22287 PyDict_SetItemString(d,"LANGUAGE_CHINESE_SINGAPORE", SWIG_From_int((int)(wxLANGUAGE_CHINESE_SINGAPORE)));
22288 }
22289 {
22290 PyDict_SetItemString(d,"LANGUAGE_CHINESE_TAIWAN", SWIG_From_int((int)(wxLANGUAGE_CHINESE_TAIWAN)));
22291 }
22292 {
22293 PyDict_SetItemString(d,"LANGUAGE_CORSICAN", SWIG_From_int((int)(wxLANGUAGE_CORSICAN)));
22294 }
22295 {
22296 PyDict_SetItemString(d,"LANGUAGE_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_CROATIAN)));
22297 }
22298 {
22299 PyDict_SetItemString(d,"LANGUAGE_CZECH", SWIG_From_int((int)(wxLANGUAGE_CZECH)));
22300 }
22301 {
22302 PyDict_SetItemString(d,"LANGUAGE_DANISH", SWIG_From_int((int)(wxLANGUAGE_DANISH)));
22303 }
22304 {
22305 PyDict_SetItemString(d,"LANGUAGE_DUTCH", SWIG_From_int((int)(wxLANGUAGE_DUTCH)));
22306 }
22307 {
22308 PyDict_SetItemString(d,"LANGUAGE_DUTCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_DUTCH_BELGIAN)));
22309 }
22310 {
22311 PyDict_SetItemString(d,"LANGUAGE_ENGLISH", SWIG_From_int((int)(wxLANGUAGE_ENGLISH)));
22312 }
22313 {
22314 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_UK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_UK)));
22315 }
22316 {
22317 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_US", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_US)));
22318 }
22319 {
22320 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_AUSTRALIA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_AUSTRALIA)));
22321 }
22322 {
22323 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BELIZE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BELIZE)));
22324 }
22325 {
22326 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_BOTSWANA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_BOTSWANA)));
22327 }
22328 {
22329 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CANADA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CANADA)));
22330 }
22331 {
22332 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_CARIBBEAN", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_CARIBBEAN)));
22333 }
22334 {
22335 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_DENMARK", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_DENMARK)));
22336 }
22337 {
22338 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_EIRE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_EIRE)));
22339 }
22340 {
22341 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_JAMAICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_JAMAICA)));
22342 }
22343 {
22344 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_NEW_ZEALAND", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_NEW_ZEALAND)));
22345 }
22346 {
22347 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_PHILIPPINES", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_PHILIPPINES)));
22348 }
22349 {
22350 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_SOUTH_AFRICA", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_SOUTH_AFRICA)));
22351 }
22352 {
22353 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_TRINIDAD", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_TRINIDAD)));
22354 }
22355 {
22356 PyDict_SetItemString(d,"LANGUAGE_ENGLISH_ZIMBABWE", SWIG_From_int((int)(wxLANGUAGE_ENGLISH_ZIMBABWE)));
22357 }
22358 {
22359 PyDict_SetItemString(d,"LANGUAGE_ESPERANTO", SWIG_From_int((int)(wxLANGUAGE_ESPERANTO)));
22360 }
22361 {
22362 PyDict_SetItemString(d,"LANGUAGE_ESTONIAN", SWIG_From_int((int)(wxLANGUAGE_ESTONIAN)));
22363 }
22364 {
22365 PyDict_SetItemString(d,"LANGUAGE_FAEROESE", SWIG_From_int((int)(wxLANGUAGE_FAEROESE)));
22366 }
22367 {
22368 PyDict_SetItemString(d,"LANGUAGE_FARSI", SWIG_From_int((int)(wxLANGUAGE_FARSI)));
22369 }
22370 {
22371 PyDict_SetItemString(d,"LANGUAGE_FIJI", SWIG_From_int((int)(wxLANGUAGE_FIJI)));
22372 }
22373 {
22374 PyDict_SetItemString(d,"LANGUAGE_FINNISH", SWIG_From_int((int)(wxLANGUAGE_FINNISH)));
22375 }
22376 {
22377 PyDict_SetItemString(d,"LANGUAGE_FRENCH", SWIG_From_int((int)(wxLANGUAGE_FRENCH)));
22378 }
22379 {
22380 PyDict_SetItemString(d,"LANGUAGE_FRENCH_BELGIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_BELGIAN)));
22381 }
22382 {
22383 PyDict_SetItemString(d,"LANGUAGE_FRENCH_CANADIAN", SWIG_From_int((int)(wxLANGUAGE_FRENCH_CANADIAN)));
22384 }
22385 {
22386 PyDict_SetItemString(d,"LANGUAGE_FRENCH_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_FRENCH_LUXEMBOURG)));
22387 }
22388 {
22389 PyDict_SetItemString(d,"LANGUAGE_FRENCH_MONACO", SWIG_From_int((int)(wxLANGUAGE_FRENCH_MONACO)));
22390 }
22391 {
22392 PyDict_SetItemString(d,"LANGUAGE_FRENCH_SWISS", SWIG_From_int((int)(wxLANGUAGE_FRENCH_SWISS)));
22393 }
22394 {
22395 PyDict_SetItemString(d,"LANGUAGE_FRISIAN", SWIG_From_int((int)(wxLANGUAGE_FRISIAN)));
22396 }
22397 {
22398 PyDict_SetItemString(d,"LANGUAGE_GALICIAN", SWIG_From_int((int)(wxLANGUAGE_GALICIAN)));
22399 }
22400 {
22401 PyDict_SetItemString(d,"LANGUAGE_GEORGIAN", SWIG_From_int((int)(wxLANGUAGE_GEORGIAN)));
22402 }
22403 {
22404 PyDict_SetItemString(d,"LANGUAGE_GERMAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN)));
22405 }
22406 {
22407 PyDict_SetItemString(d,"LANGUAGE_GERMAN_AUSTRIAN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_AUSTRIAN)));
22408 }
22409 {
22410 PyDict_SetItemString(d,"LANGUAGE_GERMAN_BELGIUM", SWIG_From_int((int)(wxLANGUAGE_GERMAN_BELGIUM)));
22411 }
22412 {
22413 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LIECHTENSTEIN", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LIECHTENSTEIN)));
22414 }
22415 {
22416 PyDict_SetItemString(d,"LANGUAGE_GERMAN_LUXEMBOURG", SWIG_From_int((int)(wxLANGUAGE_GERMAN_LUXEMBOURG)));
22417 }
22418 {
22419 PyDict_SetItemString(d,"LANGUAGE_GERMAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_GERMAN_SWISS)));
22420 }
22421 {
22422 PyDict_SetItemString(d,"LANGUAGE_GREEK", SWIG_From_int((int)(wxLANGUAGE_GREEK)));
22423 }
22424 {
22425 PyDict_SetItemString(d,"LANGUAGE_GREENLANDIC", SWIG_From_int((int)(wxLANGUAGE_GREENLANDIC)));
22426 }
22427 {
22428 PyDict_SetItemString(d,"LANGUAGE_GUARANI", SWIG_From_int((int)(wxLANGUAGE_GUARANI)));
22429 }
22430 {
22431 PyDict_SetItemString(d,"LANGUAGE_GUJARATI", SWIG_From_int((int)(wxLANGUAGE_GUJARATI)));
22432 }
22433 {
22434 PyDict_SetItemString(d,"LANGUAGE_HAUSA", SWIG_From_int((int)(wxLANGUAGE_HAUSA)));
22435 }
22436 {
22437 PyDict_SetItemString(d,"LANGUAGE_HEBREW", SWIG_From_int((int)(wxLANGUAGE_HEBREW)));
22438 }
22439 {
22440 PyDict_SetItemString(d,"LANGUAGE_HINDI", SWIG_From_int((int)(wxLANGUAGE_HINDI)));
22441 }
22442 {
22443 PyDict_SetItemString(d,"LANGUAGE_HUNGARIAN", SWIG_From_int((int)(wxLANGUAGE_HUNGARIAN)));
22444 }
22445 {
22446 PyDict_SetItemString(d,"LANGUAGE_ICELANDIC", SWIG_From_int((int)(wxLANGUAGE_ICELANDIC)));
22447 }
22448 {
22449 PyDict_SetItemString(d,"LANGUAGE_INDONESIAN", SWIG_From_int((int)(wxLANGUAGE_INDONESIAN)));
22450 }
22451 {
22452 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUA", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUA)));
22453 }
22454 {
22455 PyDict_SetItemString(d,"LANGUAGE_INTERLINGUE", SWIG_From_int((int)(wxLANGUAGE_INTERLINGUE)));
22456 }
22457 {
22458 PyDict_SetItemString(d,"LANGUAGE_INUKTITUT", SWIG_From_int((int)(wxLANGUAGE_INUKTITUT)));
22459 }
22460 {
22461 PyDict_SetItemString(d,"LANGUAGE_INUPIAK", SWIG_From_int((int)(wxLANGUAGE_INUPIAK)));
22462 }
22463 {
22464 PyDict_SetItemString(d,"LANGUAGE_IRISH", SWIG_From_int((int)(wxLANGUAGE_IRISH)));
22465 }
22466 {
22467 PyDict_SetItemString(d,"LANGUAGE_ITALIAN", SWIG_From_int((int)(wxLANGUAGE_ITALIAN)));
22468 }
22469 {
22470 PyDict_SetItemString(d,"LANGUAGE_ITALIAN_SWISS", SWIG_From_int((int)(wxLANGUAGE_ITALIAN_SWISS)));
22471 }
22472 {
22473 PyDict_SetItemString(d,"LANGUAGE_JAPANESE", SWIG_From_int((int)(wxLANGUAGE_JAPANESE)));
22474 }
22475 {
22476 PyDict_SetItemString(d,"LANGUAGE_JAVANESE", SWIG_From_int((int)(wxLANGUAGE_JAVANESE)));
22477 }
22478 {
22479 PyDict_SetItemString(d,"LANGUAGE_KANNADA", SWIG_From_int((int)(wxLANGUAGE_KANNADA)));
22480 }
22481 {
22482 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI)));
22483 }
22484 {
22485 PyDict_SetItemString(d,"LANGUAGE_KASHMIRI_INDIA", SWIG_From_int((int)(wxLANGUAGE_KASHMIRI_INDIA)));
22486 }
22487 {
22488 PyDict_SetItemString(d,"LANGUAGE_KAZAKH", SWIG_From_int((int)(wxLANGUAGE_KAZAKH)));
22489 }
22490 {
22491 PyDict_SetItemString(d,"LANGUAGE_KERNEWEK", SWIG_From_int((int)(wxLANGUAGE_KERNEWEK)));
22492 }
22493 {
22494 PyDict_SetItemString(d,"LANGUAGE_KINYARWANDA", SWIG_From_int((int)(wxLANGUAGE_KINYARWANDA)));
22495 }
22496 {
22497 PyDict_SetItemString(d,"LANGUAGE_KIRGHIZ", SWIG_From_int((int)(wxLANGUAGE_KIRGHIZ)));
22498 }
22499 {
22500 PyDict_SetItemString(d,"LANGUAGE_KIRUNDI", SWIG_From_int((int)(wxLANGUAGE_KIRUNDI)));
22501 }
22502 {
22503 PyDict_SetItemString(d,"LANGUAGE_KONKANI", SWIG_From_int((int)(wxLANGUAGE_KONKANI)));
22504 }
22505 {
22506 PyDict_SetItemString(d,"LANGUAGE_KOREAN", SWIG_From_int((int)(wxLANGUAGE_KOREAN)));
22507 }
22508 {
22509 PyDict_SetItemString(d,"LANGUAGE_KURDISH", SWIG_From_int((int)(wxLANGUAGE_KURDISH)));
22510 }
22511 {
22512 PyDict_SetItemString(d,"LANGUAGE_LAOTHIAN", SWIG_From_int((int)(wxLANGUAGE_LAOTHIAN)));
22513 }
22514 {
22515 PyDict_SetItemString(d,"LANGUAGE_LATIN", SWIG_From_int((int)(wxLANGUAGE_LATIN)));
22516 }
22517 {
22518 PyDict_SetItemString(d,"LANGUAGE_LATVIAN", SWIG_From_int((int)(wxLANGUAGE_LATVIAN)));
22519 }
22520 {
22521 PyDict_SetItemString(d,"LANGUAGE_LINGALA", SWIG_From_int((int)(wxLANGUAGE_LINGALA)));
22522 }
22523 {
22524 PyDict_SetItemString(d,"LANGUAGE_LITHUANIAN", SWIG_From_int((int)(wxLANGUAGE_LITHUANIAN)));
22525 }
22526 {
22527 PyDict_SetItemString(d,"LANGUAGE_MACEDONIAN", SWIG_From_int((int)(wxLANGUAGE_MACEDONIAN)));
22528 }
22529 {
22530 PyDict_SetItemString(d,"LANGUAGE_MALAGASY", SWIG_From_int((int)(wxLANGUAGE_MALAGASY)));
22531 }
22532 {
22533 PyDict_SetItemString(d,"LANGUAGE_MALAY", SWIG_From_int((int)(wxLANGUAGE_MALAY)));
22534 }
22535 {
22536 PyDict_SetItemString(d,"LANGUAGE_MALAYALAM", SWIG_From_int((int)(wxLANGUAGE_MALAYALAM)));
22537 }
22538 {
22539 PyDict_SetItemString(d,"LANGUAGE_MALAY_BRUNEI_DARUSSALAM", SWIG_From_int((int)(wxLANGUAGE_MALAY_BRUNEI_DARUSSALAM)));
22540 }
22541 {
22542 PyDict_SetItemString(d,"LANGUAGE_MALAY_MALAYSIA", SWIG_From_int((int)(wxLANGUAGE_MALAY_MALAYSIA)));
22543 }
22544 {
22545 PyDict_SetItemString(d,"LANGUAGE_MALTESE", SWIG_From_int((int)(wxLANGUAGE_MALTESE)));
22546 }
22547 {
22548 PyDict_SetItemString(d,"LANGUAGE_MANIPURI", SWIG_From_int((int)(wxLANGUAGE_MANIPURI)));
22549 }
22550 {
22551 PyDict_SetItemString(d,"LANGUAGE_MAORI", SWIG_From_int((int)(wxLANGUAGE_MAORI)));
22552 }
22553 {
22554 PyDict_SetItemString(d,"LANGUAGE_MARATHI", SWIG_From_int((int)(wxLANGUAGE_MARATHI)));
22555 }
22556 {
22557 PyDict_SetItemString(d,"LANGUAGE_MOLDAVIAN", SWIG_From_int((int)(wxLANGUAGE_MOLDAVIAN)));
22558 }
22559 {
22560 PyDict_SetItemString(d,"LANGUAGE_MONGOLIAN", SWIG_From_int((int)(wxLANGUAGE_MONGOLIAN)));
22561 }
22562 {
22563 PyDict_SetItemString(d,"LANGUAGE_NAURU", SWIG_From_int((int)(wxLANGUAGE_NAURU)));
22564 }
22565 {
22566 PyDict_SetItemString(d,"LANGUAGE_NEPALI", SWIG_From_int((int)(wxLANGUAGE_NEPALI)));
22567 }
22568 {
22569 PyDict_SetItemString(d,"LANGUAGE_NEPALI_INDIA", SWIG_From_int((int)(wxLANGUAGE_NEPALI_INDIA)));
22570 }
22571 {
22572 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_BOKMAL", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_BOKMAL)));
22573 }
22574 {
22575 PyDict_SetItemString(d,"LANGUAGE_NORWEGIAN_NYNORSK", SWIG_From_int((int)(wxLANGUAGE_NORWEGIAN_NYNORSK)));
22576 }
22577 {
22578 PyDict_SetItemString(d,"LANGUAGE_OCCITAN", SWIG_From_int((int)(wxLANGUAGE_OCCITAN)));
22579 }
22580 {
22581 PyDict_SetItemString(d,"LANGUAGE_ORIYA", SWIG_From_int((int)(wxLANGUAGE_ORIYA)));
22582 }
22583 {
22584 PyDict_SetItemString(d,"LANGUAGE_OROMO", SWIG_From_int((int)(wxLANGUAGE_OROMO)));
22585 }
22586 {
22587 PyDict_SetItemString(d,"LANGUAGE_PASHTO", SWIG_From_int((int)(wxLANGUAGE_PASHTO)));
22588 }
22589 {
22590 PyDict_SetItemString(d,"LANGUAGE_POLISH", SWIG_From_int((int)(wxLANGUAGE_POLISH)));
22591 }
22592 {
22593 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE)));
22594 }
22595 {
22596 PyDict_SetItemString(d,"LANGUAGE_PORTUGUESE_BRAZILIAN", SWIG_From_int((int)(wxLANGUAGE_PORTUGUESE_BRAZILIAN)));
22597 }
22598 {
22599 PyDict_SetItemString(d,"LANGUAGE_PUNJABI", SWIG_From_int((int)(wxLANGUAGE_PUNJABI)));
22600 }
22601 {
22602 PyDict_SetItemString(d,"LANGUAGE_QUECHUA", SWIG_From_int((int)(wxLANGUAGE_QUECHUA)));
22603 }
22604 {
22605 PyDict_SetItemString(d,"LANGUAGE_RHAETO_ROMANCE", SWIG_From_int((int)(wxLANGUAGE_RHAETO_ROMANCE)));
22606 }
22607 {
22608 PyDict_SetItemString(d,"LANGUAGE_ROMANIAN", SWIG_From_int((int)(wxLANGUAGE_ROMANIAN)));
22609 }
22610 {
22611 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN)));
22612 }
22613 {
22614 PyDict_SetItemString(d,"LANGUAGE_RUSSIAN_UKRAINE", SWIG_From_int((int)(wxLANGUAGE_RUSSIAN_UKRAINE)));
22615 }
22616 {
22617 PyDict_SetItemString(d,"LANGUAGE_SAMOAN", SWIG_From_int((int)(wxLANGUAGE_SAMOAN)));
22618 }
22619 {
22620 PyDict_SetItemString(d,"LANGUAGE_SANGHO", SWIG_From_int((int)(wxLANGUAGE_SANGHO)));
22621 }
22622 {
22623 PyDict_SetItemString(d,"LANGUAGE_SANSKRIT", SWIG_From_int((int)(wxLANGUAGE_SANSKRIT)));
22624 }
22625 {
22626 PyDict_SetItemString(d,"LANGUAGE_SCOTS_GAELIC", SWIG_From_int((int)(wxLANGUAGE_SCOTS_GAELIC)));
22627 }
22628 {
22629 PyDict_SetItemString(d,"LANGUAGE_SERBIAN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN)));
22630 }
22631 {
22632 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_CYRILLIC)));
22633 }
22634 {
22635 PyDict_SetItemString(d,"LANGUAGE_SERBIAN_LATIN", SWIG_From_int((int)(wxLANGUAGE_SERBIAN_LATIN)));
22636 }
22637 {
22638 PyDict_SetItemString(d,"LANGUAGE_SERBO_CROATIAN", SWIG_From_int((int)(wxLANGUAGE_SERBO_CROATIAN)));
22639 }
22640 {
22641 PyDict_SetItemString(d,"LANGUAGE_SESOTHO", SWIG_From_int((int)(wxLANGUAGE_SESOTHO)));
22642 }
22643 {
22644 PyDict_SetItemString(d,"LANGUAGE_SETSWANA", SWIG_From_int((int)(wxLANGUAGE_SETSWANA)));
22645 }
22646 {
22647 PyDict_SetItemString(d,"LANGUAGE_SHONA", SWIG_From_int((int)(wxLANGUAGE_SHONA)));
22648 }
22649 {
22650 PyDict_SetItemString(d,"LANGUAGE_SINDHI", SWIG_From_int((int)(wxLANGUAGE_SINDHI)));
22651 }
22652 {
22653 PyDict_SetItemString(d,"LANGUAGE_SINHALESE", SWIG_From_int((int)(wxLANGUAGE_SINHALESE)));
22654 }
22655 {
22656 PyDict_SetItemString(d,"LANGUAGE_SISWATI", SWIG_From_int((int)(wxLANGUAGE_SISWATI)));
22657 }
22658 {
22659 PyDict_SetItemString(d,"LANGUAGE_SLOVAK", SWIG_From_int((int)(wxLANGUAGE_SLOVAK)));
22660 }
22661 {
22662 PyDict_SetItemString(d,"LANGUAGE_SLOVENIAN", SWIG_From_int((int)(wxLANGUAGE_SLOVENIAN)));
22663 }
22664 {
22665 PyDict_SetItemString(d,"LANGUAGE_SOMALI", SWIG_From_int((int)(wxLANGUAGE_SOMALI)));
22666 }
22667 {
22668 PyDict_SetItemString(d,"LANGUAGE_SPANISH", SWIG_From_int((int)(wxLANGUAGE_SPANISH)));
22669 }
22670 {
22671 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ARGENTINA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ARGENTINA)));
22672 }
22673 {
22674 PyDict_SetItemString(d,"LANGUAGE_SPANISH_BOLIVIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_BOLIVIA)));
22675 }
22676 {
22677 PyDict_SetItemString(d,"LANGUAGE_SPANISH_CHILE", SWIG_From_int((int)(wxLANGUAGE_SPANISH_CHILE)));
22678 }
22679 {
22680 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COLOMBIA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COLOMBIA)));
22681 }
22682 {
22683 PyDict_SetItemString(d,"LANGUAGE_SPANISH_COSTA_RICA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_COSTA_RICA)));
22684 }
22685 {
22686 PyDict_SetItemString(d,"LANGUAGE_SPANISH_DOMINICAN_REPUBLIC", SWIG_From_int((int)(wxLANGUAGE_SPANISH_DOMINICAN_REPUBLIC)));
22687 }
22688 {
22689 PyDict_SetItemString(d,"LANGUAGE_SPANISH_ECUADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_ECUADOR)));
22690 }
22691 {
22692 PyDict_SetItemString(d,"LANGUAGE_SPANISH_EL_SALVADOR", SWIG_From_int((int)(wxLANGUAGE_SPANISH_EL_SALVADOR)));
22693 }
22694 {
22695 PyDict_SetItemString(d,"LANGUAGE_SPANISH_GUATEMALA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_GUATEMALA)));
22696 }
22697 {
22698 PyDict_SetItemString(d,"LANGUAGE_SPANISH_HONDURAS", SWIG_From_int((int)(wxLANGUAGE_SPANISH_HONDURAS)));
22699 }
22700 {
22701 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MEXICAN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MEXICAN)));
22702 }
22703 {
22704 PyDict_SetItemString(d,"LANGUAGE_SPANISH_MODERN", SWIG_From_int((int)(wxLANGUAGE_SPANISH_MODERN)));
22705 }
22706 {
22707 PyDict_SetItemString(d,"LANGUAGE_SPANISH_NICARAGUA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_NICARAGUA)));
22708 }
22709 {
22710 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PANAMA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PANAMA)));
22711 }
22712 {
22713 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PARAGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PARAGUAY)));
22714 }
22715 {
22716 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PERU", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PERU)));
22717 }
22718 {
22719 PyDict_SetItemString(d,"LANGUAGE_SPANISH_PUERTO_RICO", SWIG_From_int((int)(wxLANGUAGE_SPANISH_PUERTO_RICO)));
22720 }
22721 {
22722 PyDict_SetItemString(d,"LANGUAGE_SPANISH_URUGUAY", SWIG_From_int((int)(wxLANGUAGE_SPANISH_URUGUAY)));
22723 }
22724 {
22725 PyDict_SetItemString(d,"LANGUAGE_SPANISH_US", SWIG_From_int((int)(wxLANGUAGE_SPANISH_US)));
22726 }
22727 {
22728 PyDict_SetItemString(d,"LANGUAGE_SPANISH_VENEZUELA", SWIG_From_int((int)(wxLANGUAGE_SPANISH_VENEZUELA)));
22729 }
22730 {
22731 PyDict_SetItemString(d,"LANGUAGE_SUNDANESE", SWIG_From_int((int)(wxLANGUAGE_SUNDANESE)));
22732 }
22733 {
22734 PyDict_SetItemString(d,"LANGUAGE_SWAHILI", SWIG_From_int((int)(wxLANGUAGE_SWAHILI)));
22735 }
22736 {
22737 PyDict_SetItemString(d,"LANGUAGE_SWEDISH", SWIG_From_int((int)(wxLANGUAGE_SWEDISH)));
22738 }
22739 {
22740 PyDict_SetItemString(d,"LANGUAGE_SWEDISH_FINLAND", SWIG_From_int((int)(wxLANGUAGE_SWEDISH_FINLAND)));
22741 }
22742 {
22743 PyDict_SetItemString(d,"LANGUAGE_TAGALOG", SWIG_From_int((int)(wxLANGUAGE_TAGALOG)));
22744 }
22745 {
22746 PyDict_SetItemString(d,"LANGUAGE_TAJIK", SWIG_From_int((int)(wxLANGUAGE_TAJIK)));
22747 }
22748 {
22749 PyDict_SetItemString(d,"LANGUAGE_TAMIL", SWIG_From_int((int)(wxLANGUAGE_TAMIL)));
22750 }
22751 {
22752 PyDict_SetItemString(d,"LANGUAGE_TATAR", SWIG_From_int((int)(wxLANGUAGE_TATAR)));
22753 }
22754 {
22755 PyDict_SetItemString(d,"LANGUAGE_TELUGU", SWIG_From_int((int)(wxLANGUAGE_TELUGU)));
22756 }
22757 {
22758 PyDict_SetItemString(d,"LANGUAGE_THAI", SWIG_From_int((int)(wxLANGUAGE_THAI)));
22759 }
22760 {
22761 PyDict_SetItemString(d,"LANGUAGE_TIBETAN", SWIG_From_int((int)(wxLANGUAGE_TIBETAN)));
22762 }
22763 {
22764 PyDict_SetItemString(d,"LANGUAGE_TIGRINYA", SWIG_From_int((int)(wxLANGUAGE_TIGRINYA)));
22765 }
22766 {
22767 PyDict_SetItemString(d,"LANGUAGE_TONGA", SWIG_From_int((int)(wxLANGUAGE_TONGA)));
22768 }
22769 {
22770 PyDict_SetItemString(d,"LANGUAGE_TSONGA", SWIG_From_int((int)(wxLANGUAGE_TSONGA)));
22771 }
22772 {
22773 PyDict_SetItemString(d,"LANGUAGE_TURKISH", SWIG_From_int((int)(wxLANGUAGE_TURKISH)));
22774 }
22775 {
22776 PyDict_SetItemString(d,"LANGUAGE_TURKMEN", SWIG_From_int((int)(wxLANGUAGE_TURKMEN)));
22777 }
22778 {
22779 PyDict_SetItemString(d,"LANGUAGE_TWI", SWIG_From_int((int)(wxLANGUAGE_TWI)));
22780 }
22781 {
22782 PyDict_SetItemString(d,"LANGUAGE_UIGHUR", SWIG_From_int((int)(wxLANGUAGE_UIGHUR)));
22783 }
22784 {
22785 PyDict_SetItemString(d,"LANGUAGE_UKRAINIAN", SWIG_From_int((int)(wxLANGUAGE_UKRAINIAN)));
22786 }
22787 {
22788 PyDict_SetItemString(d,"LANGUAGE_URDU", SWIG_From_int((int)(wxLANGUAGE_URDU)));
22789 }
22790 {
22791 PyDict_SetItemString(d,"LANGUAGE_URDU_INDIA", SWIG_From_int((int)(wxLANGUAGE_URDU_INDIA)));
22792 }
22793 {
22794 PyDict_SetItemString(d,"LANGUAGE_URDU_PAKISTAN", SWIG_From_int((int)(wxLANGUAGE_URDU_PAKISTAN)));
22795 }
22796 {
22797 PyDict_SetItemString(d,"LANGUAGE_UZBEK", SWIG_From_int((int)(wxLANGUAGE_UZBEK)));
22798 }
22799 {
22800 PyDict_SetItemString(d,"LANGUAGE_UZBEK_CYRILLIC", SWIG_From_int((int)(wxLANGUAGE_UZBEK_CYRILLIC)));
22801 }
22802 {
22803 PyDict_SetItemString(d,"LANGUAGE_UZBEK_LATIN", SWIG_From_int((int)(wxLANGUAGE_UZBEK_LATIN)));
22804 }
22805 {
22806 PyDict_SetItemString(d,"LANGUAGE_VIETNAMESE", SWIG_From_int((int)(wxLANGUAGE_VIETNAMESE)));
22807 }
22808 {
22809 PyDict_SetItemString(d,"LANGUAGE_VOLAPUK", SWIG_From_int((int)(wxLANGUAGE_VOLAPUK)));
22810 }
22811 {
22812 PyDict_SetItemString(d,"LANGUAGE_WELSH", SWIG_From_int((int)(wxLANGUAGE_WELSH)));
22813 }
22814 {
22815 PyDict_SetItemString(d,"LANGUAGE_WOLOF", SWIG_From_int((int)(wxLANGUAGE_WOLOF)));
22816 }
22817 {
22818 PyDict_SetItemString(d,"LANGUAGE_XHOSA", SWIG_From_int((int)(wxLANGUAGE_XHOSA)));
22819 }
22820 {
22821 PyDict_SetItemString(d,"LANGUAGE_YIDDISH", SWIG_From_int((int)(wxLANGUAGE_YIDDISH)));
22822 }
22823 {
22824 PyDict_SetItemString(d,"LANGUAGE_YORUBA", SWIG_From_int((int)(wxLANGUAGE_YORUBA)));
22825 }
22826 {
22827 PyDict_SetItemString(d,"LANGUAGE_ZHUANG", SWIG_From_int((int)(wxLANGUAGE_ZHUANG)));
22828 }
22829 {
22830 PyDict_SetItemString(d,"LANGUAGE_ZULU", SWIG_From_int((int)(wxLANGUAGE_ZULU)));
22831 }
22832 {
22833 PyDict_SetItemString(d,"LANGUAGE_USER_DEFINED", SWIG_From_int((int)(wxLANGUAGE_USER_DEFINED)));
22834 }
22835 {
22836 PyDict_SetItemString(d,"LOCALE_CAT_NUMBER", SWIG_From_int((int)(wxLOCALE_CAT_NUMBER)));
22837 }
22838 {
22839 PyDict_SetItemString(d,"LOCALE_CAT_DATE", SWIG_From_int((int)(wxLOCALE_CAT_DATE)));
22840 }
22841 {
22842 PyDict_SetItemString(d,"LOCALE_CAT_MONEY", SWIG_From_int((int)(wxLOCALE_CAT_MONEY)));
22843 }
22844 {
22845 PyDict_SetItemString(d,"LOCALE_CAT_MAX", SWIG_From_int((int)(wxLOCALE_CAT_MAX)));
22846 }
22847 {
22848 PyDict_SetItemString(d,"LOCALE_THOUSANDS_SEP", SWIG_From_int((int)(wxLOCALE_THOUSANDS_SEP)));
22849 }
22850 {
22851 PyDict_SetItemString(d,"LOCALE_DECIMAL_POINT", SWIG_From_int((int)(wxLOCALE_DECIMAL_POINT)));
22852 }
22853 {
22854 PyDict_SetItemString(d,"LOCALE_LOAD_DEFAULT", SWIG_From_int((int)(wxLOCALE_LOAD_DEFAULT)));
22855 }
22856 {
22857 PyDict_SetItemString(d,"LOCALE_CONV_ENCODING", SWIG_From_int((int)(wxLOCALE_CONV_ENCODING)));
22858 }
22859 {
22860 PyDict_SetItemString(d,"CONVERT_STRICT", SWIG_From_int((int)(wxCONVERT_STRICT)));
22861 }
22862 {
22863 PyDict_SetItemString(d,"CONVERT_SUBSTITUTE", SWIG_From_int((int)(wxCONVERT_SUBSTITUTE)));
22864 }
22865 {
22866 PyDict_SetItemString(d,"PLATFORM_CURRENT", SWIG_From_int((int)(wxPLATFORM_CURRENT)));
22867 }
22868 {
22869 PyDict_SetItemString(d,"PLATFORM_UNIX", SWIG_From_int((int)(wxPLATFORM_UNIX)));
22870 }
22871 {
22872 PyDict_SetItemString(d,"PLATFORM_WINDOWS", SWIG_From_int((int)(wxPLATFORM_WINDOWS)));
22873 }
22874 {
22875 PyDict_SetItemString(d,"PLATFORM_OS2", SWIG_From_int((int)(wxPLATFORM_OS2)));
22876 }
22877 {
22878 PyDict_SetItemString(d,"PLATFORM_MAC", SWIG_From_int((int)(wxPLATFORM_MAC)));
22879 }
22880 {
22881 PyDict_SetItemString(d,"IMAGELIST_DRAW_NORMAL", SWIG_From_int((int)(wxIMAGELIST_DRAW_NORMAL)));
22882 }
22883 {
22884 PyDict_SetItemString(d,"IMAGELIST_DRAW_TRANSPARENT", SWIG_From_int((int)(wxIMAGELIST_DRAW_TRANSPARENT)));
22885 }
22886 {
22887 PyDict_SetItemString(d,"IMAGELIST_DRAW_SELECTED", SWIG_From_int((int)(wxIMAGELIST_DRAW_SELECTED)));
22888 }
22889 {
22890 PyDict_SetItemString(d,"IMAGELIST_DRAW_FOCUSED", SWIG_From_int((int)(wxIMAGELIST_DRAW_FOCUSED)));
22891 }
22892 {
22893 PyDict_SetItemString(d,"IMAGE_LIST_NORMAL", SWIG_From_int((int)(wxIMAGE_LIST_NORMAL)));
22894 }
22895 {
22896 PyDict_SetItemString(d,"IMAGE_LIST_SMALL", SWIG_From_int((int)(wxIMAGE_LIST_SMALL)));
22897 }
22898 {
22899 PyDict_SetItemString(d,"IMAGE_LIST_STATE", SWIG_From_int((int)(wxIMAGE_LIST_STATE)));
22900 }
22901 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
22902 SWIG_addvarlink(SWIG_globals,(char*)"NORMAL_FONT",_wrap_NORMAL_FONT_get, _wrap_NORMAL_FONT_set);
22903 SWIG_addvarlink(SWIG_globals,(char*)"SMALL_FONT",_wrap_SMALL_FONT_get, _wrap_SMALL_FONT_set);
22904 SWIG_addvarlink(SWIG_globals,(char*)"ITALIC_FONT",_wrap_ITALIC_FONT_get, _wrap_ITALIC_FONT_set);
22905 SWIG_addvarlink(SWIG_globals,(char*)"SWISS_FONT",_wrap_SWISS_FONT_get, _wrap_SWISS_FONT_set);
22906 SWIG_addvarlink(SWIG_globals,(char*)"RED_PEN",_wrap_RED_PEN_get, _wrap_RED_PEN_set);
22907 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_PEN",_wrap_CYAN_PEN_get, _wrap_CYAN_PEN_set);
22908 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_PEN",_wrap_GREEN_PEN_get, _wrap_GREEN_PEN_set);
22909 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_PEN",_wrap_BLACK_PEN_get, _wrap_BLACK_PEN_set);
22910 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_PEN",_wrap_WHITE_PEN_get, _wrap_WHITE_PEN_set);
22911 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_PEN",_wrap_TRANSPARENT_PEN_get, _wrap_TRANSPARENT_PEN_set);
22912 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_DASHED_PEN",_wrap_BLACK_DASHED_PEN_get, _wrap_BLACK_DASHED_PEN_set);
22913 SWIG_addvarlink(SWIG_globals,(char*)"GREY_PEN",_wrap_GREY_PEN_get, _wrap_GREY_PEN_set);
22914 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_PEN",_wrap_MEDIUM_GREY_PEN_get, _wrap_MEDIUM_GREY_PEN_set);
22915 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_PEN",_wrap_LIGHT_GREY_PEN_get, _wrap_LIGHT_GREY_PEN_set);
22916 SWIG_addvarlink(SWIG_globals,(char*)"BLUE_BRUSH",_wrap_BLUE_BRUSH_get, _wrap_BLUE_BRUSH_set);
22917 SWIG_addvarlink(SWIG_globals,(char*)"GREEN_BRUSH",_wrap_GREEN_BRUSH_get, _wrap_GREEN_BRUSH_set);
22918 SWIG_addvarlink(SWIG_globals,(char*)"WHITE_BRUSH",_wrap_WHITE_BRUSH_get, _wrap_WHITE_BRUSH_set);
22919 SWIG_addvarlink(SWIG_globals,(char*)"BLACK_BRUSH",_wrap_BLACK_BRUSH_get, _wrap_BLACK_BRUSH_set);
22920 SWIG_addvarlink(SWIG_globals,(char*)"TRANSPARENT_BRUSH",_wrap_TRANSPARENT_BRUSH_get, _wrap_TRANSPARENT_BRUSH_set);
22921 SWIG_addvarlink(SWIG_globals,(char*)"CYAN_BRUSH",_wrap_CYAN_BRUSH_get, _wrap_CYAN_BRUSH_set);
22922 SWIG_addvarlink(SWIG_globals,(char*)"RED_BRUSH",_wrap_RED_BRUSH_get, _wrap_RED_BRUSH_set);
22923 SWIG_addvarlink(SWIG_globals,(char*)"GREY_BRUSH",_wrap_GREY_BRUSH_get, _wrap_GREY_BRUSH_set);
22924 SWIG_addvarlink(SWIG_globals,(char*)"MEDIUM_GREY_BRUSH",_wrap_MEDIUM_GREY_BRUSH_get, _wrap_MEDIUM_GREY_BRUSH_set);
22925 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY_BRUSH",_wrap_LIGHT_GREY_BRUSH_get, _wrap_LIGHT_GREY_BRUSH_set);
22926 SWIG_addvarlink(SWIG_globals,(char*)"BLACK",_wrap_BLACK_get, _wrap_BLACK_set);
22927 SWIG_addvarlink(SWIG_globals,(char*)"WHITE",_wrap_WHITE_get, _wrap_WHITE_set);
22928 SWIG_addvarlink(SWIG_globals,(char*)"RED",_wrap_RED_get, _wrap_RED_set);
22929 SWIG_addvarlink(SWIG_globals,(char*)"BLUE",_wrap_BLUE_get, _wrap_BLUE_set);
22930 SWIG_addvarlink(SWIG_globals,(char*)"GREEN",_wrap_GREEN_get, _wrap_GREEN_set);
22931 SWIG_addvarlink(SWIG_globals,(char*)"CYAN",_wrap_CYAN_get, _wrap_CYAN_set);
22932 SWIG_addvarlink(SWIG_globals,(char*)"LIGHT_GREY",_wrap_LIGHT_GREY_get, _wrap_LIGHT_GREY_set);
22933 SWIG_addvarlink(SWIG_globals,(char*)"STANDARD_CURSOR",_wrap_STANDARD_CURSOR_get, _wrap_STANDARD_CURSOR_set);
22934 SWIG_addvarlink(SWIG_globals,(char*)"HOURGLASS_CURSOR",_wrap_HOURGLASS_CURSOR_get, _wrap_HOURGLASS_CURSOR_set);
22935 SWIG_addvarlink(SWIG_globals,(char*)"CROSS_CURSOR",_wrap_CROSS_CURSOR_get, _wrap_CROSS_CURSOR_set);
22936 SWIG_addvarlink(SWIG_globals,(char*)"NullBitmap",_wrap_NullBitmap_get, _wrap_NullBitmap_set);
22937 SWIG_addvarlink(SWIG_globals,(char*)"NullIcon",_wrap_NullIcon_get, _wrap_NullIcon_set);
22938 SWIG_addvarlink(SWIG_globals,(char*)"NullCursor",_wrap_NullCursor_get, _wrap_NullCursor_set);
22939 SWIG_addvarlink(SWIG_globals,(char*)"NullPen",_wrap_NullPen_get, _wrap_NullPen_set);
22940 SWIG_addvarlink(SWIG_globals,(char*)"NullBrush",_wrap_NullBrush_get, _wrap_NullBrush_set);
22941 SWIG_addvarlink(SWIG_globals,(char*)"NullPalette",_wrap_NullPalette_get, _wrap_NullPalette_set);
22942 SWIG_addvarlink(SWIG_globals,(char*)"NullFont",_wrap_NullFont_get, _wrap_NullFont_set);
22943 SWIG_addvarlink(SWIG_globals,(char*)"NullColour",_wrap_NullColour_get, _wrap_NullColour_set);
22944 SWIG_addvarlink(SWIG_globals,(char*)"TheFontList",_wrap_TheFontList_get, _wrap_TheFontList_set);
22945 SWIG_addvarlink(SWIG_globals,(char*)"ThePenList",_wrap_ThePenList_get, _wrap_ThePenList_set);
22946 SWIG_addvarlink(SWIG_globals,(char*)"TheBrushList",_wrap_TheBrushList_get, _wrap_TheBrushList_set);
22947 SWIG_addvarlink(SWIG_globals,(char*)"TheColourDatabase",_wrap_TheColourDatabase_get, _wrap_TheColourDatabase_set);
22948
22949 // Work around a chicken/egg problem in drawlist.cpp
22950 wxPyDrawList_SetAPIPtr();
22951
22952 }
22953
wxWidgets (Impactor)